RTEMS 4.9.6
Annotated Report
Sun Jul 24 19:09:13 2011

0010c238 <IMFS_Set_handlers>: #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) {
  10c238:	55                   	push   %ebp                           
  10c239:	89 e5                	mov    %esp,%ebp                      
  10c23b:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  IMFS_jnode_t    *node = loc->node_access;                           
  IMFS_fs_info_t  *fs_info;                                           
                                                                      
  fs_info = loc->mt_entry->fs_info;                                   
  10c23e:	8b 41 0c             	mov    0xc(%ecx),%eax                 
  10c241:	8b 50 2c             	mov    0x2c(%eax),%edx                
  switch( node->type ) {                                              
  10c244:	8b 01                	mov    (%ecx),%eax                    
  10c246:	8b 40 4c             	mov    0x4c(%eax),%eax                
  10c249:	48                   	dec    %eax                           
  10c24a:	83 f8 05             	cmp    $0x5,%eax                      
  10c24d:	77 24                	ja     10c273 <IMFS_Set_handlers+0x3b><== NEVER TAKEN
  10c24f:	ff 24 85 c4 75 11 00 	jmp    *0x1175c4(,%eax,4)             
    case IMFS_DIRECTORY:                                              
      loc->handlers = fs_info->directory_handlers;                    
  10c256:	8b 42 08             	mov    0x8(%edx),%eax                 
  10c259:	eb 15                	jmp    10c270 <IMFS_Set_handlers+0x38>
      break;                                                          
    case IMFS_DEVICE:                                                 
      loc->handlers = &IMFS_device_handlers;                          
  10c25b:	c7 41 04 b8 76 11 00 	movl   $0x1176b8,0x4(%ecx)            
  10c262:	eb 0f                	jmp    10c273 <IMFS_Set_handlers+0x3b>
      break;                                                          
    case IMFS_SYM_LINK:                                               
    case IMFS_HARD_LINK:                                              
      loc->handlers = &IMFS_link_handlers;                            
  10c264:	c7 41 04 f0 76 11 00 	movl   $0x1176f0,0x4(%ecx)            
  10c26b:	eb 06                	jmp    10c273 <IMFS_Set_handlers+0x3b>
      break;                                                          
    case IMFS_LINEAR_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
      break;                                                          
    case IMFS_MEMORY_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
  10c26d:	8b 42 04             	mov    0x4(%edx),%eax                 
  10c270:	89 41 04             	mov    %eax,0x4(%ecx)                 
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  10c273:	31 c0                	xor    %eax,%eax                      
  10c275:	c9                   	leave                                 
  10c276:	c3                   	ret                                   
                                                                      

0010d718 <IMFS_chown>: int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) {
  10d718:	55                   	push   %ebp                           
  10d719:	89 e5                	mov    %esp,%ebp                      
  10d71b:	57                   	push   %edi                           
  10d71c:	56                   	push   %esi                           
  10d71d:	53                   	push   %ebx                           
  10d71e:	83 ec 1c             	sub    $0x1c,%esp                     
  10d721:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  10d724:	8b 7d 10             	mov    0x10(%ebp),%edi                
  IMFS_jnode_t  *jnode;                                               
#if defined(RTEMS_POSIX_API)                                          
  uid_t          st_uid;                                              
#endif                                                                
                                                                      
  jnode = (IMFS_jnode_t *) pathloc->node_access;                      
  10d727:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10d72a:	8b 18                	mov    (%eax),%ebx                    
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
  10d72c:	e8 87 0c 00 00       	call   10e3b8 <geteuid>               
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
  10d731:	66 3b 43 3c          	cmp    0x3c(%ebx),%ax                 
  10d735:	74 15                	je     10d74c <IMFS_chown+0x34>       <== ALWAYS TAKEN
  10d737:	66 85 c0             	test   %ax,%ax                        <== NOT EXECUTED
  10d73a:	74 10                	je     10d74c <IMFS_chown+0x34>       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EPERM );                    
  10d73c:	e8 9f 38 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  10d741:	c7 00 01 00 00 00    	movl   $0x1,(%eax)                    <== NOT EXECUTED
  10d747:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10d74a:	eb 20                	jmp    10d76c <IMFS_chown+0x54>       <== NOT EXECUTED
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
  10d74c:	66 89 73 3c          	mov    %si,0x3c(%ebx)                 
  jnode->st_gid = group;                                              
  10d750:	66 89 7b 3e          	mov    %di,0x3e(%ebx)                 
                                                                      
  IMFS_update_ctime( jnode );                                         
  10d754:	50                   	push   %eax                           
  10d755:	50                   	push   %eax                           
  10d756:	6a 00                	push   $0x0                           
  10d758:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10d75b:	50                   	push   %eax                           
  10d75c:	e8 07 9d ff ff       	call   107468 <gettimeofday>          
  10d761:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10d764:	89 43 48             	mov    %eax,0x48(%ebx)                
  10d767:	31 c0                	xor    %eax,%eax                      
  10d769:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return 0;                                                           
}                                                                     
  10d76c:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10d76f:	5b                   	pop    %ebx                           
  10d770:	5e                   	pop    %esi                           
  10d771:	5f                   	pop    %edi                           
  10d772:	c9                   	leave                                 
  10d773:	c3                   	ret                                   
                                                                      

0010e770 <IMFS_create_node>: IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) {
  10e770:	55                   	push   %ebp                           
  10e771:	89 e5                	mov    %esp,%ebp                      
  10e773:	57                   	push   %edi                           
  10e774:	56                   	push   %esi                           
  10e775:	53                   	push   %ebx                           
  10e776:	83 ec 1c             	sub    $0x1c,%esp                     
  10e779:	8b 75 14             	mov    0x14(%ebp),%esi                
  IMFS_jnode_t        *node;                                          
  struct timeval       tv;                                            
  IMFS_jnode_t        *parent = NULL;                                 
  IMFS_fs_info_t      *fs_info;                                       
                                                                      
  if ( parent_loc != NULL )                                           
  10e77c:	31 ff                	xor    %edi,%edi                      
  10e77e:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  10e782:	74 05                	je     10e789 <IMFS_create_node+0x19> 
    parent = parent_loc->node_access;                                 
  10e784:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10e787:	8b 38                	mov    (%eax),%edi                    
                                                                      
  /*                                                                  
   *  Allocate an IMFS jnode                                          
   */                                                                 
                                                                      
  node = calloc( 1, sizeof( IMFS_jnode_t ) );                         
  10e789:	50                   	push   %eax                           
  10e78a:	50                   	push   %eax                           
  10e78b:	6a 60                	push   $0x60                          
  10e78d:	6a 01                	push   $0x1                           
  10e78f:	e8 3c e5 ff ff       	call   10ccd0 <calloc>                
  10e794:	89 c3                	mov    %eax,%ebx                      
  if ( !node )                                                        
  10e796:	83 c4 10             	add    $0x10,%esp                     
  10e799:	85 c0                	test   %eax,%eax                      
  10e79b:	0f 84 00 01 00 00    	je     10e8a1 <IMFS_create_node+0x131><== NEVER TAKEN
                                                                      
  /*                                                                  
   *  Fill in the basic information                                   
   */                                                                 
                                                                      
  node->st_nlink = 1;                                                 
  10e7a1:	66 c7 40 34 01 00    	movw   $0x1,0x34(%eax)                
  node->type     = type;                                              
  10e7a7:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10e7aa:	89 50 4c             	mov    %edx,0x4c(%eax)                
  strncpy( node->name, name, IMFS_NAME_MAX );                         
  10e7ad:	50                   	push   %eax                           
  10e7ae:	6a 20                	push   $0x20                          
  10e7b0:	ff 75 10             	pushl  0x10(%ebp)                     
  10e7b3:	8d 43 0c             	lea    0xc(%ebx),%eax                 
  10e7b6:	50                   	push   %eax                           
  10e7b7:	e8 f4 1b 00 00       	call   1103b0 <strncpy>               
                                                                      
  /*                                                                  
   *  Fill in the mode and permission information for the jnode structure.
   */                                                                 
                                                                      
  node->st_mode = mode & ~rtems_filesystem_umask;                     
  10e7bc:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10e7c1:	8b 40 24             	mov    0x24(%eax),%eax                
  10e7c4:	f7 d0                	not    %eax                           
  10e7c6:	21 c6                	and    %eax,%esi                      
  10e7c8:	89 73 30             	mov    %esi,0x30(%ebx)                
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  node->st_uid = geteuid();                                           
  10e7cb:	e8 74 e6 ff ff       	call   10ce44 <geteuid>               
  10e7d0:	66 89 43 3c          	mov    %ax,0x3c(%ebx)                 
  node->st_gid = getegid();                                           
  10e7d4:	e8 5b e6 ff ff       	call   10ce34 <getegid>               
  10e7d9:	66 89 43 3e          	mov    %ax,0x3e(%ebx)                 
                                                                      
  /*                                                                  
   *  Now set all the times.                                          
   */                                                                 
                                                                      
  gettimeofday( &tv, 0 );                                             
  10e7dd:	5a                   	pop    %edx                           
  10e7de:	59                   	pop    %ecx                           
  10e7df:	6a 00                	push   $0x0                           
  10e7e1:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10e7e4:	50                   	push   %eax                           
  10e7e5:	e8 6a e6 ff ff       	call   10ce54 <gettimeofday>          
                                                                      
  node->stat_atime  = (time_t) tv.tv_sec;                             
  10e7ea:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10e7ed:	89 43 40             	mov    %eax,0x40(%ebx)                
  node->stat_mtime  = (time_t) tv.tv_sec;                             
  10e7f0:	89 43 44             	mov    %eax,0x44(%ebx)                
  node->stat_ctime  = (time_t) tv.tv_sec;                             
  10e7f3:	89 43 48             	mov    %eax,0x48(%ebx)                
                                                                      
  /*                                                                  
   *  Set the type specific information                               
   */                                                                 
                                                                      
  switch (type) {                                                     
  10e7f6:	83 c4 10             	add    $0x10,%esp                     
  10e7f9:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10e7fc:	48                   	dec    %eax                           
  10e7fd:	83 f8 05             	cmp    $0x5,%eax                      
  10e800:	77 62                	ja     10e864 <IMFS_create_node+0xf4> <== NEVER TAKEN
  10e802:	ff 24 85 e0 7a 11 00 	jmp    *0x117ae0(,%eax,4)             
  10e809:	8d 43 54             	lea    0x54(%ebx),%eax                
  10e80c:	89 43 50             	mov    %eax,0x50(%ebx)                
  10e80f:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                
  10e816:	8d 43 50             	lea    0x50(%ebx),%eax                
  10e819:	89 43 58             	mov    %eax,0x58(%ebx)                
  10e81c:	eb 5c                	jmp    10e87a <IMFS_create_node+0x10a>
    case IMFS_HARD_LINK:                                              
      node->info.hard_link.link_node = info->hard_link.link_node;     
      break;                                                          
                                                                      
    case IMFS_SYM_LINK:                                               
      node->info.sym_link.name = info->sym_link.name;                 
  10e81e:	8b 55 18             	mov    0x18(%ebp),%edx                
  10e821:	8b 02                	mov    (%edx),%eax                    
  10e823:	89 43 50             	mov    %eax,0x50(%ebx)                
  10e826:	eb 52                	jmp    10e87a <IMFS_create_node+0x10a>
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      node->info.device.major = info->device.major;                   
  10e828:	8b 55 18             	mov    0x18(%ebp),%edx                
  10e82b:	8b 02                	mov    (%edx),%eax                    
  10e82d:	89 43 50             	mov    %eax,0x50(%ebx)                
      node->info.device.minor = info->device.minor;                   
  10e830:	8b 42 04             	mov    0x4(%edx),%eax                 
  10e833:	89 43 54             	mov    %eax,0x54(%ebx)                
  10e836:	eb 42                	jmp    10e87a <IMFS_create_node+0x10a>
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      node->info.linearfile.size      = 0;                            
  10e838:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)                <== NOT EXECUTED
      node->info.linearfile.direct    = 0;                            
  10e83f:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                <== NOT EXECUTED
                                                                      
    case IMFS_MEMORY_FILE:                                            
      node->info.file.size            = 0;                            
  10e846:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)                
      node->info.file.indirect        = 0;                            
  10e84d:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                
      node->info.file.doubly_indirect = 0;                            
  10e854:	c7 43 58 00 00 00 00 	movl   $0x0,0x58(%ebx)                
      node->info.file.triply_indirect = 0;                            
  10e85b:	c7 43 5c 00 00 00 00 	movl   $0x0,0x5c(%ebx)                
  10e862:	eb 16                	jmp    10e87a <IMFS_create_node+0x10a>
      break;                                                          
                                                                      
    default:                                                          
      assert(0);                                                      
  10e864:	68 a3 6b 11 00       	push   $0x116ba3                      <== NOT EXECUTED
  10e869:	68 f8 7a 11 00       	push   $0x117af8                      <== NOT EXECUTED
  10e86e:	6a 74                	push   $0x74                          <== NOT EXECUTED
  10e870:	68 90 7a 11 00       	push   $0x117a90                      <== NOT EXECUTED
  10e875:	e8 0e 7a ff ff       	call   106288 <__assert_func>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If this node has a parent, then put it in that directory list.  
   */                                                                 
                                                                      
  if ( parent ) {                                                     
  10e87a:	85 ff                	test   %edi,%edi                      
  10e87c:	74 23                	je     10e8a1 <IMFS_create_node+0x131>
  10e87e:	50                   	push   %eax                           
  10e87f:	50                   	push   %eax                           
  10e880:	53                   	push   %ebx                           
  10e881:	8d 47 50             	lea    0x50(%edi),%eax                
  10e884:	50                   	push   %eax                           
  10e885:	e8 62 b2 ff ff       	call   109aec <_Chain_Append>         
    rtems_chain_append( &parent->info.directory.Entries, &node->Node );
    node->Parent = parent;                                            
  10e88a:	89 7b 08             	mov    %edi,0x8(%ebx)                 
                                                                      
    fs_info = parent_loc->mt_entry->fs_info;                          
  10e88d:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10e890:	8b 42 0c             	mov    0xc(%edx),%eax                 
  10e893:	8b 50 2c             	mov    0x2c(%eax),%edx                
    node->st_ino = ++fs_info->ino_count;                              
  10e896:	8b 02                	mov    (%edx),%eax                    
  10e898:	40                   	inc    %eax                           
  10e899:	89 02                	mov    %eax,(%edx)                    
  10e89b:	89 43 38             	mov    %eax,0x38(%ebx)                
  10e89e:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
                                                                      
  return node;                                                        
}                                                                     
  10e8a1:	89 d8                	mov    %ebx,%eax                      
  10e8a3:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e8a6:	5b                   	pop    %ebx                           
  10e8a7:	5e                   	pop    %esi                           
  10e8a8:	5f                   	pop    %edi                           
  10e8a9:	c9                   	leave                                 
  10e8aa:	c3                   	ret                                   
                                                                      

00107936 <IMFS_dump_directory>: void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) {
  107936:	55                   	push   %ebp                           
  107937:	89 e5                	mov    %esp,%ebp                      
  107939:	57                   	push   %edi                           
  10793a:	56                   	push   %esi                           
  10793b:	53                   	push   %ebx                           
  10793c:	83 ec 0c             	sub    $0xc,%esp                      
  10793f:	8b 45 08             	mov    0x8(%ebp),%eax                 
  107942:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  rtems_chain_node     *the_node;                                     
  rtems_chain_control  *the_chain;                                    
  IMFS_jnode_t         *the_jnode;                                    
  int                   i;                                            
                                                                      
  assert( the_directory );                                            
  107945:	85 c0                	test   %eax,%eax                      
  107947:	75 0e                	jne    107957 <IMFS_dump_directory+0x21><== ALWAYS TAKEN
  107949:	68 2b cc 11 00       	push   $0x11cc2b                      <== NOT EXECUTED
  10794e:	68 14 cd 11 00       	push   $0x11cd14                      <== NOT EXECUTED
  107953:	6a 7f                	push   $0x7f                          <== NOT EXECUTED
  107955:	eb 13                	jmp    10796a <IMFS_dump_directory+0x34><== NOT EXECUTED
                                                                      
  assert( level >= 0 );                                               
  107957:	85 ff                	test   %edi,%edi                      
  107959:	79 19                	jns    107974 <IMFS_dump_directory+0x3e><== ALWAYS TAKEN
  10795b:	68 39 cc 11 00       	push   $0x11cc39                      <== NOT EXECUTED
  107960:	68 14 cd 11 00       	push   $0x11cd14                      <== NOT EXECUTED
  107965:	68 81 00 00 00       	push   $0x81                          <== NOT EXECUTED
  10796a:	68 8c cb 11 00       	push   $0x11cb8c                      <== NOT EXECUTED
  10796f:	e8 d8 05 00 00       	call   107f4c <__assert_func>         <== NOT EXECUTED
                                                                      
  assert( the_directory->type == IMFS_DIRECTORY );                    
  107974:	83 78 4c 01          	cmpl   $0x1,0x4c(%eax)                
  107978:	74 11                	je     10798b <IMFS_dump_directory+0x55><== ALWAYS TAKEN
  10797a:	68 44 cc 11 00       	push   $0x11cc44                      <== NOT EXECUTED
  10797f:	68 14 cd 11 00       	push   $0x11cd14                      <== NOT EXECUTED
  107984:	68 83 00 00 00       	push   $0x83                          <== NOT EXECUTED
  107989:	eb df                	jmp    10796a <IMFS_dump_directory+0x34><== NOT EXECUTED
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
  10798b:	8b 70 50             	mov    0x50(%eax),%esi                
  10798e:	83 c0 54             	add    $0x54,%eax                     
  107991:	89 45 f0             	mov    %eax,-0x10(%ebp)               
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( the_jnode->type == IMFS_DIRECTORY )                          
      IMFS_dump_directory( the_jnode, level + 1 );                    
  107994:	8d 47 01             	lea    0x1(%edi),%eax                 
  107997:	89 45 ec             	mov    %eax,-0x14(%ebp)               
  10799a:	eb 40                	jmp    1079dc <IMFS_dump_directory+0xa6>
                                                                      
  for ( the_node = the_chain->first;                                  
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
  10799c:	31 db                	xor    %ebx,%ebx                      
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
  10799e:	50                   	push   %eax                           
  10799f:	50                   	push   %eax                           
  1079a0:	a1 80 14 12 00       	mov    0x121480,%eax                  
  1079a5:	ff 70 08             	pushl  0x8(%eax)                      
  1079a8:	68 6a cc 11 00       	push   $0x11cc6a                      
  1079ad:	e8 a2 b2 00 00       	call   112c54 <fputs>                 
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
  1079b2:	43                   	inc    %ebx                           
  1079b3:	83 c4 10             	add    $0x10,%esp                     
  1079b6:	39 fb                	cmp    %edi,%ebx                      
  1079b8:	7e e4                	jle    10799e <IMFS_dump_directory+0x68>
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
  1079ba:	83 ec 0c             	sub    $0xc,%esp                      
  1079bd:	56                   	push   %esi                           
  1079be:	e8 73 fe ff ff       	call   107836 <IMFS_print_jnode>      
    if ( the_jnode->type == IMFS_DIRECTORY )                          
  1079c3:	83 c4 10             	add    $0x10,%esp                     
  1079c6:	83 7e 4c 01          	cmpl   $0x1,0x4c(%esi)                
  1079ca:	75 0e                	jne    1079da <IMFS_dump_directory+0xa4>
      IMFS_dump_directory( the_jnode, level + 1 );                    
  1079cc:	50                   	push   %eax                           
  1079cd:	50                   	push   %eax                           
  1079ce:	ff 75 ec             	pushl  -0x14(%ebp)                    
  1079d1:	56                   	push   %esi                           
  1079d2:	e8 5f ff ff ff       	call   107936 <IMFS_dump_directory>   
  1079d7:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
  1079da:	8b 36                	mov    (%esi),%esi                    
  assert( the_directory->type == IMFS_DIRECTORY );                    
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
        !rtems_chain_is_tail( the_chain, the_node );                  
  1079dc:	3b 75 f0             	cmp    -0x10(%ebp),%esi               
  1079df:	75 bb                	jne    10799c <IMFS_dump_directory+0x66>
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( the_jnode->type == IMFS_DIRECTORY )                          
      IMFS_dump_directory( the_jnode, level + 1 );                    
  }                                                                   
}                                                                     
  1079e1:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1079e4:	5b                   	pop    %ebx                           
  1079e5:	5e                   	pop    %esi                           
  1079e6:	5f                   	pop    %edi                           
  1079e7:	c9                   	leave                                 
  1079e8:	c3                   	ret                                   
                                                                      

0010c3d7 <IMFS_eval_path>: int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) {
  10c3d7:	55                   	push   %ebp                           
  10c3d8:	89 e5                	mov    %esp,%ebp                      
  10c3da:	57                   	push   %edi                           
  10c3db:	56                   	push   %esi                           
  10c3dc:	53                   	push   %ebx                           
  10c3dd:	83 ec 4c             	sub    $0x4c,%esp                     
  10c3e0:	8b 5d 10             	mov    0x10(%ebp),%ebx                
  char                                token[ IMFS_NAME_MAX + 1 ];     
  rtems_filesystem_location_info_t    newloc;                         
  IMFS_jnode_t                       *node;                           
  int                                 result;                         
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) ) {                       
  10c3e3:	f7 45 0c f8 ff ff ff 	testl  $0xfffffff8,0xc(%ebp)          
  10c3ea:	74 19                	je     10c405 <IMFS_eval_path+0x2e>   <== ALWAYS TAKEN
    assert( 0 );                                                      
  10c3ec:	68 a3 6b 11 00       	push   $0x116ba3                      <== NOT EXECUTED
  10c3f1:	68 dc 75 11 00       	push   $0x1175dc                      <== NOT EXECUTED
  10c3f6:	68 ea 01 00 00       	push   $0x1ea                         <== NOT EXECUTED
  10c3fb:	68 eb 75 11 00       	push   $0x1175eb                      <== NOT EXECUTED
  10c400:	e8 83 9e ff ff       	call   106288 <__assert_func>         <== NOT EXECUTED
  /*                                                                  
   *  This was filled in by the caller and is valid in the            
   *  mount table.                                                    
   */                                                                 
                                                                      
  node = pathloc->node_access;                                        
  10c405:	8b 33                	mov    (%ebx),%esi                    
  10c407:	c7 45 b0 00 00 00 00 	movl   $0x0,-0x50(%ebp)               
  10c40e:	bf 01 00 00 00       	mov    $0x1,%edi                      
  10c413:	e9 1d 01 00 00       	jmp    10c535 <IMFS_eval_path+0x15e>  
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], token, &len );               
  10c418:	50                   	push   %eax                           
  10c419:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10c41c:	50                   	push   %eax                           
  10c41d:	8d 45 bf             	lea    -0x41(%ebp),%eax               
  10c420:	50                   	push   %eax                           
  10c421:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c424:	03 45 b0             	add    -0x50(%ebp),%eax               
  10c427:	50                   	push   %eax                           
  10c428:	e8 73 04 00 00       	call   10c8a0 <IMFS_get_token>        
  10c42d:	89 c7                	mov    %eax,%edi                      
    i +=  len;                                                        
  10c42f:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10c432:	89 45 ac             	mov    %eax,-0x54(%ebp)               
                                                                      
    if ( !pathloc->node_access )                                      
  10c435:	83 c4 10             	add    $0x10,%esp                     
  10c438:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10c43b:	0f 84 d0 00 00 00    	je     10c511 <IMFS_eval_path+0x13a>  <== NEVER TAKEN
      rtems_set_errno_and_return_minus_one( ENOENT );                 
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
    if ( type != IMFS_NO_MORE_PATH )                                  
  10c441:	85 ff                	test   %edi,%edi                      
  10c443:	74 1b                	je     10c460 <IMFS_eval_path+0x89>   
      if ( node->type == IMFS_DIRECTORY )                             
  10c445:	83 7e 4c 01          	cmpl   $0x1,0x4c(%esi)                
  10c449:	75 15                	jne    10c460 <IMFS_eval_path+0x89>   
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
  10c44b:	50                   	push   %eax                           
  10c44c:	50                   	push   %eax                           
  10c44d:	6a 01                	push   $0x1                           
  10c44f:	53                   	push   %ebx                           
  10c450:	e8 22 fe ff ff       	call   10c277 <IMFS_evaluate_permission>
  10c455:	83 c4 10             	add    $0x10,%esp                     
  10c458:	85 c0                	test   %eax,%eax                      
  10c45a:	0f 84 3c 01 00 00    	je     10c59c <IMFS_eval_path+0x1c5>  
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], token, &len );               
    i +=  len;                                                        
  10c460:	8b 45 ac             	mov    -0x54(%ebp),%eax               
  10c463:	01 45 b0             	add    %eax,-0x50(%ebp)               
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
           rtems_set_errno_and_return_minus_one( EACCES );            
                                                                      
    node = pathloc->node_access;                                      
  10c466:	8b 33                	mov    (%ebx),%esi                    
                                                                      
    switch( type ) {                                                  
  10c468:	83 ff 03             	cmp    $0x3,%edi                      
  10c46b:	74 34                	je     10c4a1 <IMFS_eval_path+0xca>   
  10c46d:	83 ff 04             	cmp    $0x4,%edi                      
  10c470:	0f 84 b2 00 00 00    	je     10c528 <IMFS_eval_path+0x151>  
  10c476:	83 ff 02             	cmp    $0x2,%edi                      
  10c479:	0f 85 b6 00 00 00    	jne    10c535 <IMFS_eval_path+0x15e>  
      case IMFS_UP_DIR:                                               
       /*                                                             
        *  Am I at the root of all filesystems? (chroot'ed?)          
	*/                                                                   
                                                                      
       if ( pathloc->node_access == rtems_filesystem_root.node_access )
  10c47f:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10c484:	3b 70 14             	cmp    0x14(%eax),%esi                
  10c487:	74 8f                	je     10c418 <IMFS_eval_path+0x41>   
                                                                      
	/*                                                                   
	 *  Am I at the root of this mounted filesystem?                     
	 */                                                                  
                                                                      
        if (pathloc->node_access ==                                   
  10c489:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  10c48c:	3b 70 18             	cmp    0x18(%eax),%esi                
  10c48f:	75 0b                	jne    10c49c <IMFS_eval_path+0xc5>   
	   */                                                                
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;       /* Throw out the .. in this case */          
	  } else {                                                           
            newloc = pathloc->mt_entry->mt_point_node;                
  10c491:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  10c494:	8d 70 08             	lea    0x8(%eax),%esi                 
  10c497:	e9 b9 00 00 00       	jmp    10c555 <IMFS_eval_path+0x17e>  
            *pathloc = newloc;                                        
            return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
	  }                                                                  
	} else {                                                             
                                                                      
          if ( !node->Parent )                                        
  10c49c:	8b 76 08             	mov    0x8(%esi),%esi                 
  10c49f:	eb 6c                	jmp    10c50d <IMFS_eval_path+0x136>  
      case IMFS_NAME:                                                 
	/*                                                                   
	 *  If we are at a link follow it.                                   
	 */                                                                  
                                                                      
	if ( node->type == IMFS_HARD_LINK ) {                                
  10c4a1:	8b 46 4c             	mov    0x4c(%esi),%eax                
  10c4a4:	83 f8 03             	cmp    $0x3,%eax                      
  10c4a7:	75 15                	jne    10c4be <IMFS_eval_path+0xe7>   
                                                                      
          IMFS_evaluate_hard_link( pathloc, 0 );                      
  10c4a9:	50                   	push   %eax                           
  10c4aa:	50                   	push   %eax                           
  10c4ab:	6a 00                	push   $0x0                           
  10c4ad:	53                   	push   %ebx                           
  10c4ae:	e8 2a fe ff ff       	call   10c2dd <IMFS_evaluate_hard_link>
                                                                      
          node = pathloc->node_access;                                
  10c4b3:	8b 33                	mov    (%ebx),%esi                    
          if ( !node )                                                
  10c4b5:	83 c4 10             	add    $0x10,%esp                     
  10c4b8:	85 f6                	test   %esi,%esi                      
  10c4ba:	75 23                	jne    10c4df <IMFS_eval_path+0x108>  <== ALWAYS TAKEN
  10c4bc:	eb 27                	jmp    10c4e5 <IMFS_eval_path+0x10e>  <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one( ENOTDIR );          
                                                                      
	} else if ( node->type == IMFS_SYM_LINK ) {                          
  10c4be:	83 f8 04             	cmp    $0x4,%eax                      
  10c4c1:	75 1c                	jne    10c4df <IMFS_eval_path+0x108>  
                                                                      
          result = IMFS_evaluate_sym_link( pathloc, 0 );              
  10c4c3:	50                   	push   %eax                           
  10c4c4:	50                   	push   %eax                           
  10c4c5:	6a 00                	push   $0x0                           
  10c4c7:	53                   	push   %ebx                           
  10c4c8:	e8 62 fe ff ff       	call   10c32f <IMFS_evaluate_sym_link>
  10c4cd:	89 c6                	mov    %eax,%esi                      
                                                                      
          node = pathloc->node_access;                                
  10c4cf:	8b 03                	mov    (%ebx),%eax                    
          if ( result == -1 )                                         
  10c4d1:	83 c4 10             	add    $0x10,%esp                     
  10c4d4:	83 fe ff             	cmp    $0xffffffff,%esi               
  10c4d7:	0f 84 cd 00 00 00    	je     10c5aa <IMFS_eval_path+0x1d3>  <== NEVER TAKEN
                                                                      
	} else if ( node->type == IMFS_SYM_LINK ) {                          
                                                                      
          result = IMFS_evaluate_sym_link( pathloc, 0 );              
                                                                      
          node = pathloc->node_access;                                
  10c4dd:	89 c6                	mov    %eax,%esi                      
                                                                      
       /*                                                             
        *  Only a directory can be decended into.                     
        */                                                            
                                                                      
       if ( node->type != IMFS_DIRECTORY )                            
  10c4df:	83 7e 4c 01          	cmpl   $0x1,0x4c(%esi)                
  10c4e3:	74 10                	je     10c4f5 <IMFS_eval_path+0x11e>  
          rtems_set_errno_and_return_minus_one( ENOTDIR );            
  10c4e5:	e8 3e 2c 00 00       	call   10f128 <__errno>               
  10c4ea:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   
  10c4f0:	e9 b2 00 00 00       	jmp    10c5a7 <IMFS_eval_path+0x1d0>  
	/*                                                                   
	 *  If we are at a node that is a mount point. Set loc to the        
	 *  new fs root node and let them finish evaluating the path.        
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
  10c4f5:	8b 46 5c             	mov    0x5c(%esi),%eax                
  10c4f8:	85 c0                	test   %eax,%eax                      
  10c4fa:	75 53                	jne    10c54f <IMFS_eval_path+0x178>  
                                                                      
	/*                                                                   
	 *  Otherwise find the token name in the present location.           
	 */                                                                  
                                                                      
        node = IMFS_find_match_in_dir( node, token );                 
  10c4fc:	50                   	push   %eax                           
  10c4fd:	50                   	push   %eax                           
  10c4fe:	8d 45 bf             	lea    -0x41(%ebp),%eax               
  10c501:	50                   	push   %eax                           
  10c502:	56                   	push   %esi                           
  10c503:	e8 0c 03 00 00       	call   10c814 <IMFS_find_match_in_dir>
  10c508:	89 c6                	mov    %eax,%esi                      
        if ( !node )                                                  
  10c50a:	83 c4 10             	add    $0x10,%esp                     
  10c50d:	85 f6                	test   %esi,%esi                      
  10c50f:	75 10                	jne    10c521 <IMFS_eval_path+0x14a>  
          rtems_set_errno_and_return_minus_one( ENOENT );             
  10c511:	e8 12 2c 00 00       	call   10f128 <__errno>               
  10c516:	c7 00 02 00 00 00    	movl   $0x2,(%eax)                    
  10c51c:	e9 86 00 00 00       	jmp    10c5a7 <IMFS_eval_path+0x1d0>  
                                                                      
	/*                                                                   
	 *  Set the node access to the point we have found.                  
	 */                                                                  
                                                                      
        pathloc->node_access = node;                                  
  10c521:	89 33                	mov    %esi,(%ebx)                    
  10c523:	e9 f0 fe ff ff       	jmp    10c418 <IMFS_eval_path+0x41>   
      case IMFS_NO_MORE_PATH:                                         
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
                                                                      
      case IMFS_INVALID_TOKEN:                                        
        rtems_set_errno_and_return_minus_one( ENAMETOOLONG );         
  10c528:	e8 fb 2b 00 00       	call   10f128 <__errno>               
  10c52d:	c7 00 5b 00 00 00    	movl   $0x5b,(%eax)                   
  10c533:	eb 72                	jmp    10c5a7 <IMFS_eval_path+0x1d0>  
                                                                      
  /*                                                                  
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
  10c535:	85 ff                	test   %edi,%edi                      
  10c537:	74 09                	je     10c542 <IMFS_eval_path+0x16b>  
  10c539:	83 ff 04             	cmp    $0x4,%edi                      
  10c53c:	0f 85 d6 fe ff ff    	jne    10c418 <IMFS_eval_path+0x41>   <== ALWAYS TAKEN
   *  new fs root node and let let the mounted filesystem set the handlers.
   *                                                                  
   *  NOTE: The behavior of stat() on a mount point appears to be questionable.
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
  10c542:	83 7e 4c 01          	cmpl   $0x1,0x4c(%esi)                
  10c546:	75 3b                	jne    10c583 <IMFS_eval_path+0x1ac>  
    if ( node->info.directory.mt_fs != NULL ) {                       
  10c548:	8b 46 5c             	mov    0x5c(%esi),%eax                
  10c54b:	85 c0                	test   %eax,%eax                      
  10c54d:	74 34                	je     10c583 <IMFS_eval_path+0x1ac>  
      newloc   = node->info.directory.mt_fs->mt_fs_root;              
  10c54f:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  10c552:	8d 70 18             	lea    0x18(%eax),%esi                
  10c555:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10c55a:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
      *pathloc = newloc;                                              
  10c55c:	8d 75 e0             	lea    -0x20(%ebp),%esi               
  10c55f:	b1 04                	mov    $0x4,%cl                       
  10c561:	89 df                	mov    %ebx,%edi                      
  10c563:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
      return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
  10c565:	50                   	push   %eax                           
  10c566:	8b 53 08             	mov    0x8(%ebx),%edx                 
  10c569:	53                   	push   %ebx                           
  10c56a:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c56d:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10c570:	29 45 b0             	sub    %eax,-0x50(%ebp)               
  10c573:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c576:	03 45 b0             	add    -0x50(%ebp),%eax               
  10c579:	50                   	push   %eax                           
  10c57a:	ff 12                	call   *(%edx)                        
  10c57c:	89 c6                	mov    %eax,%esi                      
  10c57e:	83 c4 10             	add    $0x10,%esp                     
  10c581:	eb 27                	jmp    10c5aa <IMFS_eval_path+0x1d3>  
    } else {                                                          
      result = IMFS_Set_handlers( pathloc );                          
    }                                                                 
  } else {                                                            
    result = IMFS_Set_handlers( pathloc );                            
  10c583:	53                   	push   %ebx                           
  10c584:	e8 af fc ff ff       	call   10c238 <IMFS_Set_handlers>     
  10c589:	89 c6                	mov    %eax,%esi                      
  10c58b:	57                   	push   %edi                           
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, flags ) )                  
  10c58c:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c58f:	53                   	push   %ebx                           
  10c590:	e8 e2 fc ff ff       	call   10c277 <IMFS_evaluate_permission>
  10c595:	83 c4 10             	add    $0x10,%esp                     
  10c598:	85 c0                	test   %eax,%eax                      
  10c59a:	75 0e                	jne    10c5aa <IMFS_eval_path+0x1d3>  
    rtems_set_errno_and_return_minus_one( EACCES );                   
  10c59c:	e8 87 2b 00 00       	call   10f128 <__errno>               
  10c5a1:	c7 00 0d 00 00 00    	movl   $0xd,(%eax)                    
  10c5a7:	83 ce ff             	or     $0xffffffff,%esi               
                                                                      
  return result;                                                      
}                                                                     
  10c5aa:	89 f0                	mov    %esi,%eax                      
  10c5ac:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10c5af:	5b                   	pop    %ebx                           
  10c5b0:	5e                   	pop    %esi                           
  10c5b1:	5f                   	pop    %edi                           
  10c5b2:	c9                   	leave                                 
  10c5b3:	c3                   	ret                                   
                                                                      

0010c63b <IMFS_evaluate_for_make>: int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) {
  10c63b:	55                   	push   %ebp                           
  10c63c:	89 e5                	mov    %esp,%ebp                      
  10c63e:	57                   	push   %edi                           
  10c63f:	56                   	push   %esi                           
  10c640:	53                   	push   %ebx                           
  10c641:	83 ec 4c             	sub    $0x4c,%esp                     
  10c644:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
                                                                      
  /*                                                                  
   * This was filled in by the caller and is valid in the             
   * mount table.                                                     
   */                                                                 
  node = pathloc->node_access;                                        
  10c647:	8b 33                	mov    (%ebx),%esi                    
  10c649:	c7 45 b0 00 00 00 00 	movl   $0x0,-0x50(%ebp)               
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], token, &len );                   
  10c650:	50                   	push   %eax                           
  10c651:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10c654:	50                   	push   %eax                           
  10c655:	8d 55 bf             	lea    -0x41(%ebp),%edx               
  10c658:	52                   	push   %edx                           
  10c659:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c65c:	03 45 b0             	add    -0x50(%ebp),%eax               
  10c65f:	50                   	push   %eax                           
  10c660:	e8 3b 02 00 00       	call   10c8a0 <IMFS_get_token>        
  10c665:	89 c7                	mov    %eax,%edi                      
    i +=  len;                                                        
  10c667:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10c66a:	89 45 ac             	mov    %eax,-0x54(%ebp)               
                                                                      
    if ( !pathloc->node_access )                                      
  10c66d:	83 c4 10             	add    $0x10,%esp                     
  10c670:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10c673:	0f 84 40 01 00 00    	je     10c7b9 <IMFS_evaluate_for_make+0x17e><== NEVER TAKEN
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
                                                                      
    if ( type != IMFS_NO_MORE_PATH )                                  
  10c679:	85 ff                	test   %edi,%edi                      
  10c67b:	74 1b                	je     10c698 <IMFS_evaluate_for_make+0x5d>
      if ( node->type == IMFS_DIRECTORY )                             
  10c67d:	83 7e 4c 01          	cmpl   $0x1,0x4c(%esi)                
  10c681:	75 15                	jne    10c698 <IMFS_evaluate_for_make+0x5d>
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
  10c683:	50                   	push   %eax                           
  10c684:	50                   	push   %eax                           
  10c685:	6a 01                	push   $0x1                           
  10c687:	53                   	push   %ebx                           
  10c688:	e8 ea fb ff ff       	call   10c277 <IMFS_evaluate_permission>
  10c68d:	83 c4 10             	add    $0x10,%esp                     
  10c690:	85 c0                	test   %eax,%eax                      
  10c692:	0f 84 63 01 00 00    	je     10c7fb <IMFS_evaluate_for_make+0x1c0>
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], token, &len );                   
    i +=  len;                                                        
  10c698:	8b 55 ac             	mov    -0x54(%ebp),%edx               
  10c69b:	01 55 b0             	add    %edx,-0x50(%ebp)               
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
           rtems_set_errno_and_return_minus_one( EACCES );            
                                                                      
    node = pathloc->node_access;                                      
  10c69e:	8b 33                	mov    (%ebx),%esi                    
                                                                      
    switch( type ) {                                                  
  10c6a0:	83 ff 02             	cmp    $0x2,%edi                      
  10c6a3:	74 1b                	je     10c6c0 <IMFS_evaluate_for_make+0x85>
  10c6a5:	77 0a                	ja     10c6b1 <IMFS_evaluate_for_make+0x76>
  10c6a7:	85 ff                	test   %edi,%edi                      
  10c6a9:	0f 84 cf 00 00 00    	je     10c77e <IMFS_evaluate_for_make+0x143>
  10c6af:	eb 9f                	jmp    10c650 <IMFS_evaluate_for_make+0x15>
  10c6b1:	83 ff 03             	cmp    $0x3,%edi                      
  10c6b4:	74 34                	je     10c6ea <IMFS_evaluate_for_make+0xaf>
  10c6b6:	83 ff 04             	cmp    $0x4,%edi                      
  10c6b9:	75 95                	jne    10c650 <IMFS_evaluate_for_make+0x15><== NEVER TAKEN
  10c6bb:	e9 cb 00 00 00       	jmp    10c78b <IMFS_evaluate_for_make+0x150>
      case IMFS_UP_DIR:                                               
       /*                                                             
        *  Am I at the root of all filesystems? (chroot'ed?)          
	*/                                                                   
                                                                      
       if ( pathloc->node_access == rtems_filesystem_root.node_access )
  10c6c0:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10c6c5:	3b 70 14             	cmp    0x14(%eax),%esi                
  10c6c8:	74 86                	je     10c650 <IMFS_evaluate_for_make+0x15>
                                                                      
	/*                                                                   
	 * Am I at the root of this mounted filesystem?                      
	 */                                                                  
                                                                      
        if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
  10c6ca:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  10c6cd:	3b 70 18             	cmp    0x18(%eax),%esi                
  10c6d0:	75 08                	jne    10c6da <IMFS_evaluate_for_make+0x9f>
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;                                                    
                                                                      
	  } else {                                                           
            newloc = pathloc->mt_entry->mt_point_node;                
  10c6d2:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  10c6d5:	8d 70 08             	lea    0x8(%eax),%esi                 
  10c6d8:	eb 56                	jmp    10c730 <IMFS_evaluate_for_make+0xf5>
            *pathloc = newloc;                                        
            return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
	  }                                                                  
	} else {                                                             
                                                                      
          if ( !node->Parent )                                        
  10c6da:	8b 76 08             	mov    0x8(%esi),%esi                 
  10c6dd:	85 f6                	test   %esi,%esi                      
  10c6df:	0f 85 92 00 00 00    	jne    10c777 <IMFS_evaluate_for_make+0x13c>
  10c6e5:	e9 cf 00 00 00       	jmp    10c7b9 <IMFS_evaluate_for_make+0x17e>
        pathloc->node_access = node;                                  
        break;                                                        
                                                                      
      case IMFS_NAME:                                                 
                                                                      
	if ( node->type == IMFS_HARD_LINK ) {                                
  10c6ea:	8b 46 4c             	mov    0x4c(%esi),%eax                
  10c6ed:	83 f8 03             	cmp    $0x3,%eax                      
  10c6f0:	74 05                	je     10c6f7 <IMFS_evaluate_for_make+0xbc>
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
          if ( result == -1 )                                         
            return -1;                                                
                                                                      
	} else if ( node->type == IMFS_SYM_LINK ) {                          
  10c6f2:	83 f8 04             	cmp    $0x4,%eax                      
  10c6f5:	75 18                	jne    10c70f <IMFS_evaluate_for_make+0xd4>
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
  10c6f7:	57                   	push   %edi                           
  10c6f8:	57                   	push   %edi                           
  10c6f9:	6a 00                	push   $0x0                           
  10c6fb:	53                   	push   %ebx                           
  10c6fc:	e8 b3 fe ff ff       	call   10c5b4 <IMFS_evaluate_link>    
  10c701:	89 c6                	mov    %eax,%esi                      
                                                                      
          if ( result == -1 )                                         
  10c703:	83 c4 10             	add    $0x10,%esp                     
  10c706:	83 f8 ff             	cmp    $0xffffffff,%eax               
  10c709:	0f 84 fa 00 00 00    	je     10c809 <IMFS_evaluate_for_make+0x1ce><== NEVER TAKEN
            return -1;                                                
	}                                                                    
                                                                      
        node = pathloc->node_access;                                  
  10c70f:	8b 03                	mov    (%ebx),%eax                    
        if ( !node )                                                  
  10c711:	85 c0                	test   %eax,%eax                      
  10c713:	0f 84 c4 00 00 00    	je     10c7dd <IMFS_evaluate_for_make+0x1a2><== NEVER TAKEN
                                                                      
        /*                                                            
         * Only a directory can be decended into.                     
	 */                                                                  
                                                                      
        if ( node->type != IMFS_DIRECTORY )                           
  10c719:	83 78 4c 01          	cmpl   $0x1,0x4c(%eax)                
  10c71d:	0f 85 ba 00 00 00    	jne    10c7dd <IMFS_evaluate_for_make+0x1a2>
	/*                                                                   
	 * If we are at a node that is a mount point. Set loc to the         
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
  10c723:	8b 50 5c             	mov    0x5c(%eax),%edx                
  10c726:	85 d2                	test   %edx,%edx                      
  10c728:	74 38                	je     10c762 <IMFS_evaluate_for_make+0x127>
          newloc  = node->info.directory.mt_fs->mt_fs_root;           
  10c72a:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  10c72d:	8d 72 18             	lea    0x18(%edx),%esi                
  10c730:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10c735:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
          *pathloc = newloc;                                          
  10c737:	8d 75 e0             	lea    -0x20(%ebp),%esi               
  10c73a:	b1 04                	mov    $0x4,%cl                       
  10c73c:	89 df                	mov    %ebx,%edi                      
  10c73e:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
          return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
  10c740:	56                   	push   %esi                           
  10c741:	8b 53 08             	mov    0x8(%ebx),%edx                 
  10c744:	ff 75 10             	pushl  0x10(%ebp)                     
  10c747:	53                   	push   %ebx                           
  10c748:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10c74b:	29 45 b0             	sub    %eax,-0x50(%ebp)               
  10c74e:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c751:	03 45 b0             	add    -0x50(%ebp),%eax               
  10c754:	50                   	push   %eax                           
  10c755:	ff 52 04             	call   *0x4(%edx)                     
  10c758:	89 c6                	mov    %eax,%esi                      
  10c75a:	83 c4 10             	add    $0x10,%esp                     
  10c75d:	e9 a7 00 00 00       	jmp    10c809 <IMFS_evaluate_for_make+0x1ce>
                                                                      
	/*                                                                   
	 * Otherwise find the token name in the present location.            
	 */                                                                  
                                                                      
        node = IMFS_find_match_in_dir( node, token );                 
  10c762:	51                   	push   %ecx                           
  10c763:	51                   	push   %ecx                           
  10c764:	8d 55 bf             	lea    -0x41(%ebp),%edx               
  10c767:	52                   	push   %edx                           
  10c768:	50                   	push   %eax                           
  10c769:	e8 a6 00 00 00       	call   10c814 <IMFS_find_match_in_dir>
  10c76e:	89 c6                	mov    %eax,%esi                      
	/*                                                                   
	 * If there is no node we have found the name of the node we         
         * wish to create.                                            
	 */                                                                  
                                                                      
        if ( ! node )                                                 
  10c770:	83 c4 10             	add    $0x10,%esp                     
  10c773:	85 c0                	test   %eax,%eax                      
  10c775:	74 21                	je     10c798 <IMFS_evaluate_for_make+0x15d>
          done = true;                                                
        else                                                          
          pathloc->node_access = node;                                
  10c777:	89 33                	mov    %esi,(%ebx)                    
  10c779:	e9 d2 fe ff ff       	jmp    10c650 <IMFS_evaluate_for_make+0x15>
                                                                      
        break;                                                        
                                                                      
      case IMFS_NO_MORE_PATH:                                         
        rtems_set_errno_and_return_minus_one( EEXIST );               
  10c77e:	e8 a5 29 00 00       	call   10f128 <__errno>               
  10c783:	c7 00 11 00 00 00    	movl   $0x11,(%eax)                   
  10c789:	eb 7b                	jmp    10c806 <IMFS_evaluate_for_make+0x1cb>
        break;                                                        
                                                                      
      case IMFS_INVALID_TOKEN:                                        
        rtems_set_errno_and_return_minus_one( ENAMETOOLONG );         
  10c78b:	e8 98 29 00 00       	call   10f128 <__errno>               
  10c790:	c7 00 5b 00 00 00    	movl   $0x5b,(%eax)                   
  10c796:	eb 6e                	jmp    10c806 <IMFS_evaluate_for_make+0x1cb>
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  *name = &path[ i - len ];                                           
  10c798:	8b 45 b0             	mov    -0x50(%ebp),%eax               
  10c79b:	2b 45 f0             	sub    -0x10(%ebp),%eax               
  10c79e:	03 45 08             	add    0x8(%ebp),%eax                 
  10c7a1:	8b 55 10             	mov    0x10(%ebp),%edx                
  10c7a4:	89 02                	mov    %eax,(%edx)                    
  10c7a6:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c7a9:	03 45 b0             	add    -0x50(%ebp),%eax               
  10c7ac:	eb 18                	jmp    10c7c6 <IMFS_evaluate_for_make+0x18b>
  /*                                                                  
   * We have evaluated the path as far as we can.                     
   * Verify there is not any invalid stuff at the end of the name.    
   */                                                                 
                                                                      
  for( ; path[i] != '\0'; i++) {                                      
  10c7ae:	40                   	inc    %eax                           
    if ( !IMFS_is_separator( path[ i ] ) )                            
  10c7af:	80 fa 2f             	cmp    $0x2f,%dl                      
  10c7b2:	74 12                	je     10c7c6 <IMFS_evaluate_for_make+0x18b>
  10c7b4:	80 fa 5c             	cmp    $0x5c,%dl                      
  10c7b7:	74 0d                	je     10c7c6 <IMFS_evaluate_for_make+0x18b>
      rtems_set_errno_and_return_minus_one( ENOENT );                 
  10c7b9:	e8 6a 29 00 00       	call   10f128 <__errno>               
  10c7be:	c7 00 02 00 00 00    	movl   $0x2,(%eax)                    
  10c7c4:	eb 40                	jmp    10c806 <IMFS_evaluate_for_make+0x1cb>
  /*                                                                  
   * We have evaluated the path as far as we can.                     
   * Verify there is not any invalid stuff at the end of the name.    
   */                                                                 
                                                                      
  for( ; path[i] != '\0'; i++) {                                      
  10c7c6:	8a 10                	mov    (%eax),%dl                     
  10c7c8:	84 d2                	test   %dl,%dl                        
  10c7ca:	75 e2                	jne    10c7ae <IMFS_evaluate_for_make+0x173>
                                                                      
  /*                                                                  
   * Verify we can execute and write to this directory.               
   */                                                                 
                                                                      
  result = IMFS_Set_handlers( pathloc );                              
  10c7cc:	53                   	push   %ebx                           
  10c7cd:	e8 66 fa ff ff       	call   10c238 <IMFS_Set_handlers>     
  10c7d2:	89 c6                	mov    %eax,%esi                      
                                                                      
  /*                                                                  
   * The returned node must be a directory                            
   */                                                                 
  node = pathloc->node_access;                                        
  if ( node->type != IMFS_DIRECTORY )                                 
  10c7d4:	8b 03                	mov    (%ebx),%eax                    
  10c7d6:	5a                   	pop    %edx                           
  10c7d7:	83 78 4c 01          	cmpl   $0x1,0x4c(%eax)                
  10c7db:	74 0d                	je     10c7ea <IMFS_evaluate_for_make+0x1af><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  10c7dd:	e8 46 29 00 00       	call   10f128 <__errno>               
  10c7e2:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   
  10c7e8:	eb 1c                	jmp    10c806 <IMFS_evaluate_for_make+0x1cb>
                                                                      
  /*                                                                  
   * We must have Write and execute permission on the returned node.  
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )   
  10c7ea:	57                   	push   %edi                           
  10c7eb:	57                   	push   %edi                           
  10c7ec:	6a 03                	push   $0x3                           
  10c7ee:	53                   	push   %ebx                           
  10c7ef:	e8 83 fa ff ff       	call   10c277 <IMFS_evaluate_permission>
  10c7f4:	83 c4 10             	add    $0x10,%esp                     
  10c7f7:	85 c0                	test   %eax,%eax                      
  10c7f9:	75 0e                	jne    10c809 <IMFS_evaluate_for_make+0x1ce>
    rtems_set_errno_and_return_minus_one( EACCES );                   
  10c7fb:	e8 28 29 00 00       	call   10f128 <__errno>               
  10c800:	c7 00 0d 00 00 00    	movl   $0xd,(%eax)                    
  10c806:	83 ce ff             	or     $0xffffffff,%esi               
                                                                      
  return result;                                                      
}                                                                     
  10c809:	89 f0                	mov    %esi,%eax                      
  10c80b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10c80e:	5b                   	pop    %ebx                           
  10c80f:	5e                   	pop    %esi                           
  10c810:	5f                   	pop    %edi                           
  10c811:	c9                   	leave                                 
  10c812:	c3                   	ret                                   
                                                                      

0010c2dd <IMFS_evaluate_hard_link>: int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) {
  10c2dd:	55                   	push   %ebp                           
  10c2de:	89 e5                	mov    %esp,%ebp                      
  10c2e0:	53                   	push   %ebx                           
  10c2e1:	83 ec 04             	sub    $0x4,%esp                      
  10c2e4:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  IMFS_jnode_t                     *jnode  = node->node_access;       
  10c2e7:	8b 03                	mov    (%ebx),%eax                    
                                                                      
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_HARD_LINK )                                
  10c2e9:	83 78 4c 03          	cmpl   $0x3,0x4c(%eax)                
  10c2ed:	74 0d                	je     10c2fc <IMFS_evaluate_hard_link+0x1f>
    rtems_fatal_error_occurred (0xABCD0000);                          
  10c2ef:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10c2f2:	68 00 00 cd ab       	push   $0xabcd0000                    <== NOT EXECUTED
  10c2f7:	e8 98 d4 ff ff       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
                                                                      
  /*                                                                  
   * Set the hard link value and the handlers.                        
   */                                                                 
                                                                      
  node->node_access = jnode->info.hard_link.link_node;                
  10c2fc:	8b 40 50             	mov    0x50(%eax),%eax                
  10c2ff:	89 03                	mov    %eax,(%ebx)                    
                                                                      
  IMFS_Set_handlers( node );                                          
  10c301:	53                   	push   %ebx                           
  10c302:	e8 31 ff ff ff       	call   10c238 <IMFS_Set_handlers>     
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( node, flags ) )                     
  10c307:	50                   	push   %eax                           
  10c308:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c30b:	53                   	push   %ebx                           
  10c30c:	e8 66 ff ff ff       	call   10c277 <IMFS_evaluate_permission>
  10c311:	83 c4 10             	add    $0x10,%esp                     
  10c314:	31 d2                	xor    %edx,%edx                      
  10c316:	85 c0                	test   %eax,%eax                      
  10c318:	75 0e                	jne    10c328 <IMFS_evaluate_hard_link+0x4b><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EACCES );                   
  10c31a:	e8 09 2e 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10c31f:	c7 00 0d 00 00 00    	movl   $0xd,(%eax)                    <== NOT EXECUTED
  10c325:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
  10c328:	89 d0                	mov    %edx,%eax                      
  10c32a:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10c32d:	c9                   	leave                                 
  10c32e:	c3                   	ret                                   
                                                                      

0010c277 <IMFS_evaluate_permission>: int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) {
  10c277:	55                   	push   %ebp                           
  10c278:	89 e5                	mov    %esp,%ebp                      
  10c27a:	57                   	push   %edi                           
  10c27b:	56                   	push   %esi                           
  10c27c:	53                   	push   %ebx                           
  10c27d:	83 ec 0c             	sub    $0xc,%esp                      
  10c280:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  uid_t         st_uid;                                               
  gid_t         st_gid;                                               
  IMFS_jnode_t *jnode;                                                
  int           flags_to_test;                                        
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) )                         
  10c283:	f7 c7 f8 ff ff ff    	test   $0xfffffff8,%edi               
  10c289:	74 10                	je     10c29b <IMFS_evaluate_permission+0x24><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EPERM );                    
  10c28b:	e8 98 2e 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10c290:	c7 00 01 00 00 00    	movl   $0x1,(%eax)                    <== NOT EXECUTED
  10c296:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10c299:	eb 3a                	jmp    10c2d5 <IMFS_evaluate_permission+0x5e><== NOT EXECUTED
                                                                      
  jnode = node->node_access;                                          
  10c29b:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c29e:	8b 30                	mov    (%eax),%esi                    
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
  10c2a0:	e8 9f 0b 00 00       	call   10ce44 <geteuid>               
  10c2a5:	89 c3                	mov    %eax,%ebx                      
  st_gid = getegid();                                                 
  10c2a7:	e8 88 0b 00 00       	call   10ce34 <getegid>               
   * Check if I am owner or a group member or someone else.           
   */                                                                 
                                                                      
  flags_to_test = flags;                                              
                                                                      
  if ( st_uid == jnode->st_uid )                                      
  10c2ac:	66 3b 5e 3c          	cmp    0x3c(%esi),%bx                 
  10c2b0:	75 07                	jne    10c2b9 <IMFS_evaluate_permission+0x42>
    flags_to_test <<= 6;                                              
  10c2b2:	89 fa                	mov    %edi,%edx                      
  10c2b4:	c1 e2 06             	shl    $0x6,%edx                      
  10c2b7:	eb 0f                	jmp    10c2c8 <IMFS_evaluate_permission+0x51>
  else if ( st_gid == jnode->st_gid )                                 
  10c2b9:	89 fa                	mov    %edi,%edx                      
  10c2bb:	66 3b 46 3e          	cmp    0x3e(%esi),%ax                 
  10c2bf:	75 07                	jne    10c2c8 <IMFS_evaluate_permission+0x51><== NEVER TAKEN
    flags_to_test <<= 3;                                              
  10c2c1:	8d 14 fd 00 00 00 00 	lea    0x0(,%edi,8),%edx              
                                                                      
  /*                                                                  
   * If all of the flags are set we have permission                   
   * to do this.                                                      
   */                                                                 
  if ( ( flags_to_test & jnode->st_mode) == flags_to_test )           
  10c2c8:	89 d0                	mov    %edx,%eax                      
  10c2ca:	23 46 30             	and    0x30(%esi),%eax                
  10c2cd:	39 d0                	cmp    %edx,%eax                      
  10c2cf:	0f 94 c0             	sete   %al                            
  10c2d2:	0f b6 c0             	movzbl %al,%eax                       
    return 1;                                                         
                                                                      
  return 0;                                                           
}                                                                     
  10c2d5:	83 c4 0c             	add    $0xc,%esp                      
  10c2d8:	5b                   	pop    %ebx                           
  10c2d9:	5e                   	pop    %esi                           
  10c2da:	5f                   	pop    %edi                           
  10c2db:	c9                   	leave                                 
  10c2dc:	c3                   	ret                                   
                                                                      

0010c32f <IMFS_evaluate_sym_link>: int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) {
  10c32f:	55                   	push   %ebp                           
  10c330:	89 e5                	mov    %esp,%ebp                      
  10c332:	57                   	push   %edi                           
  10c333:	56                   	push   %esi                           
  10c334:	53                   	push   %ebx                           
  10c335:	83 ec 0c             	sub    $0xc,%esp                      
  IMFS_jnode_t                     *jnode  = node->node_access;       
  10c338:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10c33b:	8b 18                	mov    (%eax),%ebx                    
                                                                      
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_SYM_LINK )                                 
  10c33d:	83 7b 4c 04          	cmpl   $0x4,0x4c(%ebx)                
  10c341:	74 0a                	je     10c34d <IMFS_evaluate_sym_link+0x1e><== ALWAYS TAKEN
    rtems_fatal_error_occurred (0xABCD0000);                          
  10c343:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10c346:	68 00 00 cd ab       	push   $0xabcd0000                    <== NOT EXECUTED
  10c34b:	eb 0f                	jmp    10c35c <IMFS_evaluate_sym_link+0x2d><== NOT EXECUTED
                                                                      
  if ( !jnode->Parent )                                               
  10c34d:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10c350:	85 c0                	test   %eax,%eax                      
  10c352:	75 0d                	jne    10c361 <IMFS_evaluate_sym_link+0x32><== ALWAYS TAKEN
    rtems_fatal_error_occurred( 0xBAD00000 );                         
  10c354:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10c357:	68 00 00 d0 ba       	push   $0xbad00000                    <== NOT EXECUTED
  10c35c:	e8 33 d4 ff ff       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
  /*                                                                  
   * Move the node_access to either the symbolic links parent or      
   * root depending on the symbolic links path.                       
   */                                                                 
                                                                      
  node->node_access = jnode->Parent;                                  
  10c361:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10c364:	89 02                	mov    %eax,(%edx)                    
                                                                      
  rtems_filesystem_get_sym_start_loc(                                 
  10c366:	8b 43 50             	mov    0x50(%ebx),%eax                
  10c369:	8a 00                	mov    (%eax),%al                     
  10c36b:	3c 2f                	cmp    $0x2f,%al                      
  10c36d:	74 0a                	je     10c379 <IMFS_evaluate_sym_link+0x4a>
  10c36f:	3c 5c                	cmp    $0x5c,%al                      
  10c371:	74 06                	je     10c379 <IMFS_evaluate_sym_link+0x4a><== NEVER TAKEN
  10c373:	31 d2                	xor    %edx,%edx                      
  10c375:	84 c0                	test   %al,%al                        
  10c377:	75 17                	jne    10c390 <IMFS_evaluate_sym_link+0x61><== ALWAYS TAKEN
  10c379:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10c37e:	8d 70 14             	lea    0x14(%eax),%esi                
  10c381:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10c386:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10c389:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  10c38b:	ba 01 00 00 00       	mov    $0x1,%edx                      
                                                                      
  /*                                                                  
   * Use eval path to evaluate the path of the symbolic link.         
   */                                                                 
                                                                      
  result = IMFS_eval_path(                                            
  10c390:	51                   	push   %ecx                           
  10c391:	ff 75 08             	pushl  0x8(%ebp)                      
  10c394:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c397:	03 53 50             	add    0x50(%ebx),%edx                
  10c39a:	52                   	push   %edx                           
  10c39b:	e8 37 00 00 00       	call   10c3d7 <IMFS_eval_path>        
  10c3a0:	89 c3                	mov    %eax,%ebx                      
    &jnode->info.sym_link.name[i],                                    
    flags,                                                            
    node                                                              
  );                                                                  
                                                                      
  IMFS_Set_handlers( node );                                          
  10c3a2:	ff 75 08             	pushl  0x8(%ebp)                      
  10c3a5:	e8 8e fe ff ff       	call   10c238 <IMFS_Set_handlers>     
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( node, flags ) )                     
  10c3aa:	83 c4 0c             	add    $0xc,%esp                      
  10c3ad:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c3b0:	ff 75 08             	pushl  0x8(%ebp)                      
  10c3b3:	e8 bf fe ff ff       	call   10c277 <IMFS_evaluate_permission>
  10c3b8:	83 c4 10             	add    $0x10,%esp                     
  10c3bb:	85 c0                	test   %eax,%eax                      
  10c3bd:	75 0e                	jne    10c3cd <IMFS_evaluate_sym_link+0x9e><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EACCES );                   
  10c3bf:	e8 64 2d 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10c3c4:	c7 00 0d 00 00 00    	movl   $0xd,(%eax)                    <== NOT EXECUTED
  10c3ca:	83 cb ff             	or     $0xffffffff,%ebx               <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
  10c3cd:	89 d8                	mov    %ebx,%eax                      
  10c3cf:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10c3d2:	5b                   	pop    %ebx                           
  10c3d3:	5e                   	pop    %esi                           
  10c3d4:	5f                   	pop    %edi                           
  10c3d5:	c9                   	leave                                 
  10c3d6:	c3                   	ret                                   
                                                                      

0010e8ac <IMFS_fchmod>: int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) {
  10e8ac:	55                   	push   %ebp                           
  10e8ad:	89 e5                	mov    %esp,%ebp                      
  10e8af:	56                   	push   %esi                           
  10e8b0:	53                   	push   %ebx                           
  10e8b1:	83 ec 10             	sub    $0x10,%esp                     
  10e8b4:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  IMFS_jnode_t  *jnode;                                               
#if defined(RTEMS_POSIX_API)                                          
  uid_t          st_uid;                                              
#endif                                                                
                                                                      
  jnode = loc->node_access;                                           
  10e8b7:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10e8ba:	8b 30                	mov    (%eax),%esi                    
                                                                      
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
  10e8bc:	e8 83 e5 ff ff       	call   10ce44 <geteuid>               
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
  10e8c1:	66 3b 46 3c          	cmp    0x3c(%esi),%ax                 
  10e8c5:	74 05                	je     10e8cc <IMFS_fchmod+0x20>      <== ALWAYS TAKEN
  10e8c7:	66 85 c0             	test   %ax,%ax                        <== NOT EXECUTED
  10e8ca:	75 08                	jne    10e8d4 <IMFS_fchmod+0x28>      <== NOT EXECUTED
#endif                                                                
                                                                      
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
  if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )                   
  10e8cc:	f7 c3 00 fe ff ff    	test   $0xfffffe00,%ebx               
  10e8d2:	74 10                	je     10e8e4 <IMFS_fchmod+0x38>      
    rtems_set_errno_and_return_minus_one( EPERM );                    
  10e8d4:	e8 4f 08 00 00       	call   10f128 <__errno>               
  10e8d9:	c7 00 01 00 00 00    	movl   $0x1,(%eax)                    
  10e8df:	83 c8 ff             	or     $0xffffffff,%eax               
  10e8e2:	eb 25                	jmp    10e909 <IMFS_fchmod+0x5d>      
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);                   
  jnode->st_mode |= mode;                                             
  10e8e4:	8b 46 30             	mov    0x30(%esi),%eax                
  10e8e7:	25 00 fe ff ff       	and    $0xfffffe00,%eax               
  10e8ec:	09 c3                	or     %eax,%ebx                      
  10e8ee:	89 5e 30             	mov    %ebx,0x30(%esi)                
                                                                      
  IMFS_update_ctime( jnode );                                         
  10e8f1:	50                   	push   %eax                           
  10e8f2:	50                   	push   %eax                           
  10e8f3:	6a 00                	push   $0x0                           
  10e8f5:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10e8f8:	50                   	push   %eax                           
  10e8f9:	e8 56 e5 ff ff       	call   10ce54 <gettimeofday>          
  10e8fe:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10e901:	89 46 48             	mov    %eax,0x48(%esi)                
  10e904:	31 c0                	xor    %eax,%eax                      
  10e906:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return 0;                                                           
}                                                                     
  10e909:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10e90c:	5b                   	pop    %ebx                           
  10e90d:	5e                   	pop    %esi                           
  10e90e:	c9                   	leave                                 
  10e90f:	c3                   	ret                                   
                                                                      

0010c814 <IMFS_find_match_in_dir>: IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) {
  10c814:	55                   	push   %ebp                           
  10c815:	89 e5                	mov    %esp,%ebp                      
  10c817:	57                   	push   %edi                           
  10c818:	56                   	push   %esi                           
  10c819:	53                   	push   %ebx                           
  10c81a:	83 ec 0c             	sub    $0xc,%esp                      
  10c81d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10c820:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  /*                                                                  
   *  Check for fatal errors.  A NULL directory show a problem in the 
   *  the IMFS code.                                                  
   */                                                                 
                                                                      
  assert( directory );                                                
  10c823:	85 db                	test   %ebx,%ebx                      
  10c825:	75 16                	jne    10c83d <IMFS_find_match_in_dir+0x29><== ALWAYS TAKEN
  10c827:	68 39 76 11 00       	push   $0x117639                      <== NOT EXECUTED
  10c82c:	68 a0 76 11 00       	push   $0x1176a0                      <== NOT EXECUTED
  10c831:	6a 2a                	push   $0x2a                          <== NOT EXECUTED
  10c833:	68 43 76 11 00       	push   $0x117643                      <== NOT EXECUTED
  10c838:	e8 4b 9a ff ff       	call   106288 <__assert_func>         <== NOT EXECUTED
  if ( !name )                                                        
  10c83d:	85 ff                	test   %edi,%edi                      
  10c83f:	74 52                	je     10c893 <IMFS_find_match_in_dir+0x7f><== NEVER TAKEN
                                                                      
  /*                                                                  
   *  Check for "." and ".."                                          
   */                                                                 
                                                                      
  if ( !strcmp( name, dotname ) )                                     
  10c841:	51                   	push   %ecx                           
  10c842:	51                   	push   %ecx                           
  10c843:	68 98 76 11 00       	push   $0x117698                      
  10c848:	57                   	push   %edi                           
  10c849:	e8 d6 39 00 00       	call   110224 <strcmp>                
  10c84e:	83 c4 10             	add    $0x10,%esp                     
  10c851:	85 c0                	test   %eax,%eax                      
  10c853:	74 40                	je     10c895 <IMFS_find_match_in_dir+0x81><== NEVER TAKEN
    return directory;                                                 
                                                                      
  if ( !strcmp( name, dotdotname ) )                                  
  10c855:	52                   	push   %edx                           
  10c856:	52                   	push   %edx                           
  10c857:	68 9a 76 11 00       	push   $0x11769a                      
  10c85c:	57                   	push   %edi                           
  10c85d:	e8 c2 39 00 00       	call   110224 <strcmp>                
  10c862:	83 c4 10             	add    $0x10,%esp                     
  10c865:	85 c0                	test   %eax,%eax                      
  10c867:	75 05                	jne    10c86e <IMFS_find_match_in_dir+0x5a><== ALWAYS TAKEN
    return directory->Parent;                                         
  10c869:	8b 5b 08             	mov    0x8(%ebx),%ebx                 <== NOT EXECUTED
  10c86c:	eb 27                	jmp    10c895 <IMFS_find_match_in_dir+0x81><== NOT EXECUTED
                                                                      
  the_chain = &directory->info.directory.Entries;                     
                                                                      
  for ( the_node = the_chain->first;                                  
  10c86e:	8b 73 50             	mov    0x50(%ebx),%esi                
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  10c871:	83 c3 54             	add    $0x54,%ebx                     
  10c874:	eb 19                	jmp    10c88f <IMFS_find_match_in_dir+0x7b>
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    if ( !strcmp( name, the_jnode->name ) )                           
  10c876:	50                   	push   %eax                           
  10c877:	50                   	push   %eax                           
  10c878:	8d 46 0c             	lea    0xc(%esi),%eax                 
  10c87b:	50                   	push   %eax                           
  10c87c:	57                   	push   %edi                           
  10c87d:	e8 a2 39 00 00       	call   110224 <strcmp>                
  10c882:	83 c4 10             	add    $0x10,%esp                     
  10c885:	85 c0                	test   %eax,%eax                      
  10c887:	75 04                	jne    10c88d <IMFS_find_match_in_dir+0x79>
  10c889:	89 f3                	mov    %esi,%ebx                      
  10c88b:	eb 08                	jmp    10c895 <IMFS_find_match_in_dir+0x81>
                                                                      
  the_chain = &directory->info.directory.Entries;                     
                                                                      
  for ( the_node = the_chain->first;                                  
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
  10c88d:	8b 36                	mov    (%esi),%esi                    
    return directory->Parent;                                         
                                                                      
  the_chain = &directory->info.directory.Entries;                     
                                                                      
  for ( the_node = the_chain->first;                                  
        !rtems_chain_is_tail( the_chain, the_node );                  
  10c88f:	39 de                	cmp    %ebx,%esi                      
  10c891:	75 e3                	jne    10c876 <IMFS_find_match_in_dir+0x62>
  10c893:	31 db                	xor    %ebx,%ebx                      
    if ( !strcmp( name, the_jnode->name ) )                           
      return the_jnode;                                               
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  10c895:	89 d8                	mov    %ebx,%eax                      
  10c897:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10c89a:	5b                   	pop    %ebx                           
  10c89b:	5e                   	pop    %esi                           
  10c89c:	5f                   	pop    %edi                           
  10c89d:	c9                   	leave                                 
  10c89e:	c3                   	ret                                   
                                                                      

0010de94 <IMFS_fsunmount>: ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) {
  10de94:	55                   	push   %ebp                           
  10de95:	89 e5                	mov    %esp,%ebp                      
  10de97:	57                   	push   %edi                           
  10de98:	56                   	push   %esi                           
  10de99:	53                   	push   %ebx                           
  10de9a:	83 ec 1c             	sub    $0x1c,%esp                     
  10de9d:	8b 45 08             	mov    0x8(%ebp),%eax                 
   /*                                                                 
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;     
  10dea0:	8b 58 18             	mov    0x18(%eax),%ebx                
   loc = temp_mt_entry->mt_fs_root;                                   
  10dea3:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  10dea6:	8d 70 18             	lea    0x18(%eax),%esi                
  10dea9:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10deae:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
   /*                                                                 
    *  Set this to null to indicate that it is being unmounted.       
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
  10deb0:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)                
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
     loc.node_access = (void *)jnode;                                 
     IMFS_Set_handlers( &loc );                                       
  10deb7:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
  10deba:	8b 7b 08             	mov    0x8(%ebx),%edi                 
     loc.node_access = (void *)jnode;                                 
  10debd:	89 5d e4             	mov    %ebx,-0x1c(%ebp)               
     IMFS_Set_handlers( &loc );                                       
  10dec0:	83 ec 0c             	sub    $0xc,%esp                      
  10dec3:	56                   	push   %esi                           
  10dec4:	e8 e7 f9 ff ff       	call   10d8b0 <IMFS_Set_handlers>     
                                                                      
     if ( jnode->type != IMFS_DIRECTORY ) {                           
  10dec9:	83 c4 10             	add    $0x10,%esp                     
  10decc:	83 7b 4c 01          	cmpl   $0x1,0x4c(%ebx)                
  10ded0:	75 08                	jne    10deda <IMFS_fsunmount+0x46>   
        result = IMFS_unlink( &loc );                                 
        if (result != 0)                                              
          return -1;                                                  
        jnode = next;                                                 
     } else if ( jnode_has_no_children( jnode ) ) {                   
  10ded2:	8d 43 54             	lea    0x54(%ebx),%eax                
  10ded5:	39 43 50             	cmp    %eax,0x50(%ebx)                
  10ded8:	75 12                	jne    10deec <IMFS_fsunmount+0x58>   
        result = IMFS_unlink( &loc );                                 
  10deda:	83 ec 0c             	sub    $0xc,%esp                      
  10dedd:	56                   	push   %esi                           
  10dede:	e8 c1 8c ff ff       	call   106ba4 <IMFS_unlink>           
        if (result != 0)                                              
  10dee3:	83 c4 10             	add    $0x10,%esp                     
  10dee6:	85 c0                	test   %eax,%eax                      
  10dee8:	75 1d                	jne    10df07 <IMFS_fsunmount+0x73>   <== NEVER TAKEN
  10deea:	89 fb                	mov    %edi,%ebx                      
          return -1;                                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
  10deec:	85 db                	test   %ebx,%ebx                      
  10deee:	74 1c                	je     10df0c <IMFS_fsunmount+0x78>   
       if ( jnode->type == IMFS_DIRECTORY ) {                         
  10def0:	83 7b 4c 01          	cmpl   $0x1,0x4c(%ebx)                
  10def4:	75 c4                	jne    10deba <IMFS_fsunmount+0x26>   <== NEVER TAKEN
         if ( jnode_has_children( jnode ) )                           
  10def6:	8d 43 54             	lea    0x54(%ebx),%eax                
  10def9:	39 43 50             	cmp    %eax,0x50(%ebx)                
  10defc:	74 bc                	je     10deba <IMFS_fsunmount+0x26>   
           jnode = jnode_get_first_child( jnode );                    
  10defe:	8b 5b 50             	mov    0x50(%ebx),%ebx                
       }                                                              
     }                                                                
   } while (jnode != NULL);                                           
  10df01:	85 db                	test   %ebx,%ebx                      
  10df03:	75 b5                	jne    10deba <IMFS_fsunmount+0x26>   <== ALWAYS TAKEN
  10df05:	eb 05                	jmp    10df0c <IMFS_fsunmount+0x78>   <== NOT EXECUTED
  10df07:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10df0a:	eb 02                	jmp    10df0e <IMFS_fsunmount+0x7a>   <== NOT EXECUTED
  10df0c:	31 c0                	xor    %eax,%eax                      
                                                                      
   return 0;                                                          
}                                                                     
  10df0e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10df11:	5b                   	pop    %ebx                           
  10df12:	5e                   	pop    %esi                           
  10df13:	5f                   	pop    %edi                           
  10df14:	c9                   	leave                                 
  10df15:	c3                   	ret                                   
                                                                      

0010c8a0 <IMFS_get_token>: IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) {
  10c8a0:	55                   	push   %ebp                           
  10c8a1:	89 e5                	mov    %esp,%ebp                      
  10c8a3:	56                   	push   %esi                           
  10c8a4:	53                   	push   %ebx                           
  10c8a5:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10c8a8:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  register char c;                                                    
                                                                      
  /*                                                                  
   *  Copy a name into token.  (Remember NULL is a token.)            
   */                                                                 
  c = path[i];                                                        
  10c8ab:	8a 01                	mov    (%ecx),%al                     
  10c8ad:	31 d2                	xor    %edx,%edx                      
  10c8af:	eb 10                	jmp    10c8c1 <IMFS_get_token+0x21>   
  while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {         
                                                                      
     token[i] = c;                                                    
  10c8b1:	88 04 16             	mov    %al,(%esi,%edx,1)              
                                                                      
     if ( i == IMFS_NAME_MAX )                                        
  10c8b4:	75 07                	jne    10c8bd <IMFS_get_token+0x1d>   
  10c8b6:	bb 04 00 00 00       	mov    $0x4,%ebx                      
  10c8bb:	eb 77                	jmp    10c934 <IMFS_get_token+0x94>   
       return IMFS_INVALID_TOKEN;                                     
                                                                      
     if ( !IMFS_is_valid_name_char(c) )                               
       type = IMFS_INVALID_TOKEN;                                     
                                                                      
     c = path [++i];                                                  
  10c8bd:	42                   	inc    %edx                           
  10c8be:	8a 04 11             	mov    (%ecx,%edx,1),%al              
                                                                      
  /*                                                                  
   *  Copy a name into token.  (Remember NULL is a token.)            
   */                                                                 
  c = path[i];                                                        
  while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {         
  10c8c1:	3c 2f                	cmp    $0x2f,%al                      
  10c8c3:	74 0d                	je     10c8d2 <IMFS_get_token+0x32>   
  10c8c5:	3c 5c                	cmp    $0x5c,%al                      
  10c8c7:	74 09                	je     10c8d2 <IMFS_get_token+0x32>   
  10c8c9:	84 c0                	test   %al,%al                        
  10c8cb:	74 05                	je     10c8d2 <IMFS_get_token+0x32>   
  10c8cd:	83 fa 20             	cmp    $0x20,%edx                     
  10c8d0:	7e df                	jle    10c8b1 <IMFS_get_token+0x11>   <== ALWAYS TAKEN
                                                                      
  /*                                                                  
   *  Copy a seperator into token.                                    
   */                                                                 
                                                                      
  if ( i == 0 ) {                                                     
  10c8d2:	85 d2                	test   %edx,%edx                      
  10c8d4:	75 0e                	jne    10c8e4 <IMFS_get_token+0x44>   
    token[i] = c;                                                     
  10c8d6:	88 06                	mov    %al,(%esi)                     
                                                                      
    if ( token[i] != '\0' ) {                                         
  10c8d8:	31 db                	xor    %ebx,%ebx                      
  10c8da:	84 c0                	test   %al,%al                        
  10c8dc:	74 1b                	je     10c8f9 <IMFS_get_token+0x59>   
  10c8de:	b2 01                	mov    $0x1,%dl                       
  10c8e0:	b3 01                	mov    $0x1,%bl                       
  10c8e2:	eb 15                	jmp    10c8f9 <IMFS_get_token+0x59>   
      i++;                                                            
      type = IMFS_CURRENT_DIR;                                        
    } else {                                                          
      type = IMFS_NO_MORE_PATH;                                       
    }                                                                 
  } else if (token[ i-1 ] != '\0') {                                  
  10c8e4:	bb 03 00 00 00       	mov    $0x3,%ebx                      
  10c8e9:	80 7c 16 ff 00       	cmpb   $0x0,-0x1(%esi,%edx,1)         
  10c8ee:	74 09                	je     10c8f9 <IMFS_get_token+0x59>   <== NEVER TAKEN
    token[i] = '\0';                                                  
  10c8f0:	c6 04 16 00          	movb   $0x0,(%esi,%edx,1)             
  10c8f4:	bb 03 00 00 00       	mov    $0x3,%ebx                      
                                                                      
  /*                                                                  
   *  Set token_len to the number of characters copied.               
   */                                                                 
                                                                      
  *token_len = i;                                                     
  10c8f9:	8b 45 10             	mov    0x10(%ebp),%eax                
  10c8fc:	89 10                	mov    %edx,(%eax)                    
  /*                                                                  
   *  If we copied something that was not a seperator see if          
   *  it was a special name.                                          
   */                                                                 
                                                                      
  if ( type == IMFS_NAME ) {                                          
  10c8fe:	83 fb 03             	cmp    $0x3,%ebx                      
  10c901:	75 31                	jne    10c934 <IMFS_get_token+0x94>   
    if ( strcmp( token, "..") == 0 )                                  
  10c903:	52                   	push   %edx                           
  10c904:	52                   	push   %edx                           
  10c905:	68 f9 71 11 00       	push   $0x1171f9                      
  10c90a:	56                   	push   %esi                           
  10c90b:	e8 14 39 00 00       	call   110224 <strcmp>                
  10c910:	83 c4 10             	add    $0x10,%esp                     
  10c913:	85 c0                	test   %eax,%eax                      
  10c915:	75 04                	jne    10c91b <IMFS_get_token+0x7b>   
  10c917:	b3 02                	mov    $0x2,%bl                       
  10c919:	eb 19                	jmp    10c934 <IMFS_get_token+0x94>   
      type = IMFS_UP_DIR;                                             
    else if ( strcmp( token, "." ) == 0 )                             
  10c91b:	50                   	push   %eax                           
  10c91c:	50                   	push   %eax                           
  10c91d:	68 fa 71 11 00       	push   $0x1171fa                      
  10c922:	56                   	push   %esi                           
  10c923:	e8 fc 38 00 00       	call   110224 <strcmp>                
  10c928:	83 c4 10             	add    $0x10,%esp                     
  10c92b:	85 c0                	test   %eax,%eax                      
  10c92d:	75 05                	jne    10c934 <IMFS_get_token+0x94>   
  10c92f:	bb 01 00 00 00       	mov    $0x1,%ebx                      
      type = IMFS_CURRENT_DIR;                                        
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
  10c934:	89 d8                	mov    %ebx,%eax                      
  10c936:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10c939:	5b                   	pop    %ebx                           
  10c93a:	5e                   	pop    %esi                           
  10c93b:	c9                   	leave                                 
  10c93c:	c3                   	ret                                   
                                                                      

0010c940 <IMFS_initialize_support>: rtems_filesystem_mount_table_entry_t *temp_mt_entry, const rtems_filesystem_operations_table *op_table, const rtems_filesystem_file_handlers_r *memfile_handlers, const rtems_filesystem_file_handlers_r *directory_handlers ) {
  10c940:	55                   	push   %ebp                           
  10c941:	89 e5                	mov    %esp,%ebp                      
  10c943:	57                   	push   %edi                           
  10c944:	56                   	push   %esi                           
  10c945:	53                   	push   %ebx                           
  10c946:	83 ec 0c             	sub    $0xc,%esp                      
  10c949:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  IMFS_jnode_t                          *jnode;                       
                                                                      
  /*                                                                  
   * determine/check value for imfs_memfile_bytes_per_block           
   */                                                                 
  IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,       
  10c94c:	8b 0d dc 92 11 00    	mov    0x1192dc,%ecx                  
  10c952:	b8 10 00 00 00       	mov    $0x10,%eax                     
  10c957:	31 d2                	xor    %edx,%edx                      
  int bit_mask;                                                       
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16;                                                 
       !is_valid && (bit_mask <= 512);                                
  10c959:	39 c8                	cmp    %ecx,%eax                      
  10c95b:	74 0d                	je     10c96a <IMFS_initialize_support+0x2a>
       bit_mask <<= 1) {                                              
  10c95d:	d1 e0                	shl    %eax                           
  10c95f:	42                   	inc    %edx                           
  int bit_mask;                                                       
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16;                                                 
       !is_valid && (bit_mask <= 512);                                
  10c960:	83 fa 06             	cmp    $0x6,%edx                      
  10c963:	75 f4                	jne    10c959 <IMFS_initialize_support+0x19><== ALWAYS TAKEN
  10c965:	b8 80 00 00 00       	mov    $0x80,%eax                     <== NOT EXECUTED
       bit_mask <<= 1) {                                              
    if (bit_mask == requested_bytes_per_block) {                      
      is_valid = true;                                                
    }                                                                 
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
  10c96a:	a3 54 d5 11 00       	mov    %eax,0x11d554                  
   *  Create the root node                                            
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).            
   */                                                                 
                                                                      
  temp_mt_entry->mt_fs_root.node_access = IMFS_create_node(           
  10c96f:	83 ec 0c             	sub    $0xc,%esp                      
  10c972:	6a 00                	push   $0x0                           
  10c974:	68 ed 41 00 00       	push   $0x41ed                        
  10c979:	68 55 72 11 00       	push   $0x117255                      
  10c97e:	6a 01                	push   $0x1                           
  10c980:	6a 00                	push   $0x0                           
  10c982:	e8 e9 1d 00 00       	call   10e770 <IMFS_create_node>      
  10c987:	89 43 18             	mov    %eax,0x18(%ebx)                
    "",                                                               
    ( S_IFDIR | 0755 ),                                               
    NULL                                                              
  );                                                                  
                                                                      
  temp_mt_entry->mt_fs_root.handlers         = directory_handlers;    
  10c98a:	8b 45 14             	mov    0x14(%ebp),%eax                
  10c98d:	89 43 1c             	mov    %eax,0x1c(%ebx)                
  temp_mt_entry->mt_fs_root.ops              = op_table;              
  10c990:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10c993:	89 43 20             	mov    %eax,0x20(%ebx)                
  temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
  10c996:	8d 7b 30             	lea    0x30(%ebx),%edi                
  10c999:	be 60 7a 11 00       	mov    $0x117a60,%esi                 
  10c99e:	b9 0c 00 00 00       	mov    $0xc,%ecx                      
  10c9a3:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  /*                                                                  
   * Create custom file system data.                                  
   */                                                                 
  fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );                    
  10c9a5:	83 c4 18             	add    $0x18,%esp                     
  10c9a8:	6a 0c                	push   $0xc                           
  10c9aa:	6a 01                	push   $0x1                           
  10c9ac:	e8 1f 03 00 00       	call   10ccd0 <calloc>                
  10c9b1:	89 c2                	mov    %eax,%edx                      
  if ( !fs_info ){                                                    
  10c9b3:	83 c4 10             	add    $0x10,%esp                     
  10c9b6:	85 c0                	test   %eax,%eax                      
  10c9b8:	75 1e                	jne    10c9d8 <IMFS_initialize_support+0x98><== ALWAYS TAKEN
    free(temp_mt_entry->mt_fs_root.node_access);                      
  10c9ba:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10c9bd:	ff 73 18             	pushl  0x18(%ebx)                     <== NOT EXECUTED
  10c9c0:	e8 b3 9a ff ff       	call   106478 <free>                  <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
  10c9c5:	e8 5e 27 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10c9ca:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  10c9d0:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10c9d3:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10c9d6:	eb 21                	jmp    10c9f9 <IMFS_initialize_support+0xb9><== NOT EXECUTED
  }                                                                   
  temp_mt_entry->fs_info = fs_info;                                   
  10c9d8:	89 43 2c             	mov    %eax,0x2c(%ebx)                
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->ino_count             = 1;                                 
  10c9db:	c7 00 01 00 00 00    	movl   $0x1,(%eax)                    
  fs_info->memfile_handlers      = memfile_handlers;                  
  10c9e1:	8b 45 10             	mov    0x10(%ebp),%eax                
  10c9e4:	89 42 04             	mov    %eax,0x4(%edx)                 
  fs_info->directory_handlers    = directory_handlers;                
  10c9e7:	8b 45 14             	mov    0x14(%ebp),%eax                
  10c9ea:	89 42 08             	mov    %eax,0x8(%edx)                 
                                                                      
  jnode = temp_mt_entry->mt_fs_root.node_access;                      
  jnode->st_ino = fs_info->ino_count;                                 
  10c9ed:	8b 43 18             	mov    0x18(%ebx),%eax                
  10c9f0:	c7 40 38 01 00 00 00 	movl   $0x1,0x38(%eax)                
  10c9f7:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  10c9f9:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10c9fc:	5b                   	pop    %ebx                           
  10c9fd:	5e                   	pop    %esi                           
  10c9fe:	5f                   	pop    %edi                           
  10c9ff:	c9                   	leave                                 
  10ca00:	c3                   	ret                                   
                                                                      

0010697c <IMFS_link>: int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) {
  10697c:	55                   	push   %ebp                           
  10697d:	89 e5                	mov    %esp,%ebp                      
  10697f:	53                   	push   %ebx                           
  106980:	83 ec 44             	sub    $0x44,%esp                     
                                                                      
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
                                                                      
  info.hard_link.link_node = to_loc->node_access;                     
  106983:	8b 45 08             	mov    0x8(%ebp),%eax                 
  106986:	8b 00                	mov    (%eax),%eax                    
  106988:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  if ( info.hard_link.link_node->st_nlink >= LINK_MAX )               
  10698b:	66 83 78 34 07       	cmpw   $0x7,0x34(%eax)                
  106990:	76 0d                	jbe    10699f <IMFS_link+0x23>        
    rtems_set_errno_and_return_minus_one( EMLINK );                   
  106992:	e8 49 a6 00 00       	call   110fe0 <__errno>               
  106997:	c7 00 1f 00 00 00    	movl   $0x1f,(%eax)                   
  10699d:	eb 39                	jmp    1069d8 <IMFS_link+0x5c>        
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
                                                                      
  IMFS_get_token( token, new_name, &i );                              
  10699f:	52                   	push   %edx                           
  1069a0:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  1069a3:	50                   	push   %eax                           
  1069a4:	8d 5d bf             	lea    -0x41(%ebp),%ebx               
  1069a7:	53                   	push   %ebx                           
  1069a8:	ff 75 10             	pushl  0x10(%ebp)                     
  1069ab:	e8 f4 75 00 00       	call   10dfa4 <IMFS_get_token>        
                                                                      
  /*                                                                  
   *  Create a new link node.                                         
   */                                                                 
                                                                      
  new_node = IMFS_create_node(                                        
  1069b0:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  1069b3:	89 04 24             	mov    %eax,(%esp)                    
  1069b6:	68 ff a1 00 00       	push   $0xa1ff                        
  1069bb:	53                   	push   %ebx                           
  1069bc:	6a 03                	push   $0x3                           
  1069be:	ff 75 0c             	pushl  0xc(%ebp)                      
  1069c1:	e8 ae 6d 00 00       	call   10d774 <IMFS_create_node>      
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if ( !new_node )                                                    
  1069c6:	83 c4 20             	add    $0x20,%esp                     
  1069c9:	85 c0                	test   %eax,%eax                      
  1069cb:	75 10                	jne    1069dd <IMFS_link+0x61>        <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
  1069cd:	e8 0e a6 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  1069d2:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  1069d8:	83 c8 ff             	or     $0xffffffff,%eax               
  1069db:	eb 22                	jmp    1069ff <IMFS_link+0x83>        
                                                                      
  /*                                                                  
   * Increment the link count of the node being pointed to.           
   */                                                                 
                                                                      
  info.hard_link.link_node->st_nlink++;                               
  1069dd:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  1069e0:	66 ff 40 34          	incw   0x34(%eax)                     
  IMFS_update_ctime( info.hard_link.link_node );                      
  1069e4:	50                   	push   %eax                           
  1069e5:	50                   	push   %eax                           
  1069e6:	6a 00                	push   $0x0                           
  1069e8:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  1069eb:	50                   	push   %eax                           
  1069ec:	e8 77 0a 00 00       	call   107468 <gettimeofday>          
  1069f1:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  1069f4:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  1069f7:	89 50 48             	mov    %edx,0x48(%eax)                
  1069fa:	31 c0                	xor    %eax,%eax                      
  1069fc:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return 0;                                                           
}                                                                     
  1069ff:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  106a02:	c9                   	leave                                 
  106a03:	c3                   	ret                                   
                                                                      

0010fd2f <IMFS_memfile_addblock>: MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) {
  10fd2f:	55                   	push   %ebp                           
  10fd30:	89 e5                	mov    %esp,%ebp                      
  10fd32:	53                   	push   %ebx                           
  10fd33:	83 ec 04             	sub    $0x4,%esp                      
  10fd36:	8b 45 08             	mov    0x8(%ebp),%eax                 
  block_p  memory;                                                    
  block_p *block_entry_ptr;                                           
                                                                      
  assert( the_jnode );                                                
  10fd39:	85 c0                	test   %eax,%eax                      
  10fd3b:	75 11                	jne    10fd4e <IMFS_memfile_addblock+0x1f><== ALWAYS TAKEN
  10fd3d:	68 bc b5 11 00       	push   $0x11b5bc                      <== NOT EXECUTED
  10fd42:	68 48 b7 11 00       	push   $0x11b748                      <== NOT EXECUTED
  10fd47:	68 69 01 00 00       	push   $0x169                         <== NOT EXECUTED
  10fd4c:	eb 15                	jmp    10fd63 <IMFS_memfile_addblock+0x34><== NOT EXECUTED
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
  10fd4e:	83 78 4c 05          	cmpl   $0x5,0x4c(%eax)                
  10fd52:	74 19                	je     10fd6d <IMFS_memfile_addblock+0x3e><== ALWAYS TAKEN
  10fd54:	68 12 b6 11 00       	push   $0x11b612                      <== NOT EXECUTED
  10fd59:	68 48 b7 11 00       	push   $0x11b748                      <== NOT EXECUTED
  10fd5e:	68 6d 01 00 00       	push   $0x16d                         <== NOT EXECUTED
  10fd63:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  10fd68:	e8 37 70 ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
  if ( the_jnode->type != IMFS_MEMORY_FILE )                          
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
  10fd6d:	52                   	push   %edx                           
  10fd6e:	6a 01                	push   $0x1                           
  10fd70:	ff 75 0c             	pushl  0xc(%ebp)                      
  10fd73:	50                   	push   %eax                           
  10fd74:	e8 95 fb ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
  10fd79:	89 c3                	mov    %eax,%ebx                      
  if ( *block_entry_ptr )                                             
  10fd7b:	83 c4 10             	add    $0x10,%esp                     
  10fd7e:	31 c0                	xor    %eax,%eax                      
  10fd80:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10fd83:	75 14                	jne    10fd99 <IMFS_memfile_addblock+0x6a>
#if 0                                                                 
  fprintf(stdout, "%d %p", block, block_entry_ptr );                  
    fflush(stdout);                                                   
#endif                                                                
                                                                      
  memory = memfile_alloc_block();                                     
  10fd85:	e8 62 fb ff ff       	call   10f8ec <memfile_alloc_block>   
  10fd8a:	89 c2                	mov    %eax,%edx                      
  if ( !memory )                                                      
  10fd8c:	b8 01 00 00 00       	mov    $0x1,%eax                      
  10fd91:	85 d2                	test   %edx,%edx                      
  10fd93:	74 04                	je     10fd99 <IMFS_memfile_addblock+0x6a><== NEVER TAKEN
    return 1;                                                         
  *block_entry_ptr = memory;                                          
  10fd95:	89 13                	mov    %edx,(%ebx)                    
  10fd97:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  10fd99:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10fd9c:	c9                   	leave                                 
  10fd9d:	c3                   	ret                                   
                                                                      

0010fd9e <IMFS_memfile_extend>: MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) {
  10fd9e:	55                   	push   %ebp                           
  10fd9f:	89 e5                	mov    %esp,%ebp                      
  10fda1:	57                   	push   %edi                           
  10fda2:	56                   	push   %esi                           
  10fda3:	53                   	push   %ebx                           
  10fda4:	83 ec 0c             	sub    $0xc,%esp                      
  10fda7:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10fdaa:	8b 75 0c             	mov    0xc(%ebp),%esi                 
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
  10fdad:	85 ff                	test   %edi,%edi                      
  10fdaf:	75 11                	jne    10fdc2 <IMFS_memfile_extend+0x24><== ALWAYS TAKEN
  10fdb1:	68 bc b5 11 00       	push   $0x11b5bc                      <== NOT EXECUTED
  10fdb6:	68 60 b7 11 00       	push   $0x11b760                      <== NOT EXECUTED
  10fdbb:	68 31 01 00 00       	push   $0x131                         <== NOT EXECUTED
  10fdc0:	eb 15                	jmp    10fdd7 <IMFS_memfile_extend+0x39><== NOT EXECUTED
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
  10fdc2:	83 7f 4c 05          	cmpl   $0x5,0x4c(%edi)                
  10fdc6:	74 19                	je     10fde1 <IMFS_memfile_extend+0x43><== ALWAYS TAKEN
  10fdc8:	68 12 b6 11 00       	push   $0x11b612                      <== NOT EXECUTED
  10fdcd:	68 60 b7 11 00       	push   $0x11b760                      <== NOT EXECUTED
  10fdd2:	68 35 01 00 00       	push   $0x135                         <== NOT EXECUTED
  10fdd7:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  10fddc:	e8 c3 6f ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
  if ( the_jnode->type != IMFS_MEMORY_FILE )                          
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
  10fde1:	8b 0d ac 11 12 00    	mov    0x1211ac,%ecx                  
  10fde7:	89 ca                	mov    %ecx,%edx                      
  10fde9:	c1 ea 02             	shr    $0x2,%edx                      
  10fdec:	8d 42 01             	lea    0x1(%edx),%eax                 
  10fdef:	0f af c2             	imul   %edx,%eax                      
  10fdf2:	40                   	inc    %eax                           
  10fdf3:	0f af c2             	imul   %edx,%eax                      
  10fdf6:	48                   	dec    %eax                           
  10fdf7:	0f af c1             	imul   %ecx,%eax                      
  10fdfa:	39 c6                	cmp    %eax,%esi                      
  10fdfc:	72 0d                	jb     10fe0b <IMFS_memfile_extend+0x6d><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10fdfe:	e8 dd 11 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  10fe03:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  10fe09:	eb 4c                	jmp    10fe57 <IMFS_memfile_extend+0xb9><== NOT EXECUTED
                                                                      
  if ( new_length <= the_jnode->info.file.size )                      
  10fe0b:	8b 5f 50             	mov    0x50(%edi),%ebx                
  10fe0e:	31 d2                	xor    %edx,%edx                      
  10fe10:	39 de                	cmp    %ebx,%esi                      
  10fe12:	7e 53                	jle    10fe67 <IMFS_memfile_extend+0xc9>
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
                                                                      
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
  10fe14:	89 f0                	mov    %esi,%eax                      
  10fe16:	99                   	cltd                                  
  10fe17:	f7 f9                	idiv   %ecx                           
  10fe19:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
  10fe1c:	89 d8                	mov    %ebx,%eax                      
  10fe1e:	99                   	cltd                                  
  10fe1f:	f7 f9                	idiv   %ecx                           
  10fe21:	89 45 ec             	mov    %eax,-0x14(%ebp)               
  10fe24:	89 c3                	mov    %eax,%ebx                      
  10fe26:	eb 35                	jmp    10fe5d <IMFS_memfile_extend+0xbf>
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
                                                                      
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    if ( IMFS_memfile_addblock( the_jnode, block ) ) {                
  10fe28:	50                   	push   %eax                           
  10fe29:	50                   	push   %eax                           
  10fe2a:	53                   	push   %ebx                           
  10fe2b:	57                   	push   %edi                           
  10fe2c:	e8 fe fe ff ff       	call   10fd2f <IMFS_memfile_addblock> 
  10fe31:	83 c4 10             	add    $0x10,%esp                     
  10fe34:	85 c0                	test   %eax,%eax                      
  10fe36:	74 24                	je     10fe5c <IMFS_memfile_extend+0xbe><== ALWAYS TAKEN
  10fe38:	eb 0d                	jmp    10fe47 <IMFS_memfile_extend+0xa9><== NOT EXECUTED
       for ( ; block>=old_blocks ; block-- ) {                        
          IMFS_memfile_remove_block( the_jnode, block );              
  10fe3a:	51                   	push   %ecx                           <== NOT EXECUTED
  10fe3b:	51                   	push   %ecx                           <== NOT EXECUTED
  10fe3c:	53                   	push   %ebx                           <== NOT EXECUTED
  10fe3d:	57                   	push   %edi                           <== NOT EXECUTED
  10fe3e:	e8 4f fc ff ff       	call   10fa92 <IMFS_memfile_remove_block><== NOT EXECUTED
   *  Now allocate each of those blocks.                              
   */                                                                 
                                                                      
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    if ( IMFS_memfile_addblock( the_jnode, block ) ) {                
       for ( ; block>=old_blocks ; block-- ) {                        
  10fe43:	4b                   	dec    %ebx                           <== NOT EXECUTED
  10fe44:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10fe47:	3b 5d ec             	cmp    -0x14(%ebp),%ebx               <== NOT EXECUTED
  10fe4a:	73 ee                	jae    10fe3a <IMFS_memfile_extend+0x9c><== NOT EXECUTED
          IMFS_memfile_remove_block( the_jnode, block );              
       }                                                              
       rtems_set_errno_and_return_minus_one( ENOSPC );                
  10fe4c:	e8 8f 11 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  10fe51:	c7 00 1c 00 00 00    	movl   $0x1c,(%eax)                   <== NOT EXECUTED
  10fe57:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  10fe5a:	eb 0b                	jmp    10fe67 <IMFS_memfile_extend+0xc9><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
                                                                      
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
  10fe5c:	43                   	inc    %ebx                           
  10fe5d:	3b 5d f0             	cmp    -0x10(%ebp),%ebx               
  10fe60:	76 c6                	jbe    10fe28 <IMFS_memfile_extend+0x8a>
                                                                      
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
                                                                      
  the_jnode->info.file.size = new_length;                             
  10fe62:	89 77 50             	mov    %esi,0x50(%edi)                
  10fe65:	31 d2                	xor    %edx,%edx                      
  return 0;                                                           
}                                                                     
  10fe67:	89 d0                	mov    %edx,%eax                      
  10fe69:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10fe6c:	5b                   	pop    %ebx                           
  10fe6d:	5e                   	pop    %esi                           
  10fe6e:	5f                   	pop    %edi                           
  10fe6f:	c9                   	leave                                 
  10fe70:	c3                   	ret                                   
                                                                      

0010f90e <IMFS_memfile_get_block_pointer>: #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) {
  10f90e:	55                   	push   %ebp                           
  10f90f:	89 e5                	mov    %esp,%ebp                      
  10f911:	57                   	push   %edi                           
  10f912:	56                   	push   %esi                           
  10f913:	53                   	push   %ebx                           
  10f914:	83 ec 1c             	sub    $0x1c,%esp                     
  10f917:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10f91a:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10f91d:	8b 7d 10             	mov    0x10(%ebp),%edi                
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
  10f920:	85 f6                	test   %esi,%esi                      
  10f922:	75 11                	jne    10f935 <IMFS_memfile_get_block_pointer+0x27><== ALWAYS TAKEN
  10f924:	68 bc b5 11 00       	push   $0x11b5bc                      <== NOT EXECUTED
  10f929:	68 cc b6 11 00       	push   $0x11b6cc                      <== NOT EXECUTED
  10f92e:	68 86 03 00 00       	push   $0x386                         <== NOT EXECUTED
  10f933:	eb 15                	jmp    10f94a <IMFS_memfile_get_block_pointer+0x3c><== NOT EXECUTED
  if ( !the_jnode )                                                   
    return NULL;                                                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
  10f935:	83 7e 4c 05          	cmpl   $0x5,0x4c(%esi)                
  10f939:	74 19                	je     10f954 <IMFS_memfile_get_block_pointer+0x46><== ALWAYS TAKEN
  10f93b:	68 12 b6 11 00       	push   $0x11b612                      <== NOT EXECUTED
  10f940:	68 cc b6 11 00       	push   $0x11b6cc                      <== NOT EXECUTED
  10f945:	68 8a 03 00 00       	push   $0x38a                         <== NOT EXECUTED
  10f94a:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  10f94f:	e8 50 74 ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_INDIRECT ) {                                  
  10f954:	a1 ac 11 12 00       	mov    0x1211ac,%eax                  
  10f959:	c1 e8 02             	shr    $0x2,%eax                      
  10f95c:	89 45 e4             	mov    %eax,-0x1c(%ebp)               
  10f95f:	48                   	dec    %eax                           
  10f960:	39 c3                	cmp    %eax,%ebx                      
  10f962:	77 32                	ja     10f996 <IMFS_memfile_get_block_pointer+0x88><== NEVER TAKEN
#if 0                                                                 
fprintf(stdout, "(s %d) ", block );                                   
fflush(stdout);                                                       
#endif                                                                
    p = info->indirect;                                               
  10f964:	8b 46 54             	mov    0x54(%esi),%eax                
                                                                      
    if ( malloc_it ) {                                                
  10f967:	85 ff                	test   %edi,%edi                      
  10f969:	74 23                	je     10f98e <IMFS_memfile_get_block_pointer+0x80>
                                                                      
      if ( !p ) {                                                     
  10f96b:	85 c0                	test   %eax,%eax                      
  10f96d:	75 10                	jne    10f97f <IMFS_memfile_get_block_pointer+0x71>
        p = memfile_alloc_block();                                    
  10f96f:	e8 78 ff ff ff       	call   10f8ec <memfile_alloc_block>   
        if ( !p )                                                     
  10f974:	85 c0                	test   %eax,%eax                      
  10f976:	0f 84 0a 01 00 00    	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NEVER TAKEN
           return 0;                                                  
        info->indirect = p;                                           
  10f97c:	89 46 54             	mov    %eax,0x54(%esi)                
      }                                                               
      return &info->indirect[ my_block ];                             
  10f97f:	8d 14 9d 00 00 00 00 	lea    0x0(,%ebx,4),%edx              
  10f986:	03 56 54             	add    0x54(%esi),%edx                
  10f989:	e9 fa 00 00 00       	jmp    10fa88 <IMFS_memfile_get_block_pointer+0x17a>
    }                                                                 
                                                                      
    if ( !p )                                                         
      return 0;                                                       
                                                                      
    return &info->indirect[ my_block ];                               
  10f98e:	8d 14 98             	lea    (%eax,%ebx,4),%edx             
  10f991:	e9 ec 00 00 00       	jmp    10fa82 <IMFS_memfile_get_block_pointer+0x174>
                                                                      
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
  10f996:	8b 4d e4             	mov    -0x1c(%ebp),%ecx               <== NOT EXECUTED
  10f999:	41                   	inc    %ecx                           <== NOT EXECUTED
  10f99a:	0f af 4d e4          	imul   -0x1c(%ebp),%ecx               <== NOT EXECUTED
  10f99e:	8d 41 ff             	lea    -0x1(%ecx),%eax                <== NOT EXECUTED
  10f9a1:	39 c3                	cmp    %eax,%ebx                      <== NOT EXECUTED
  10f9a3:	77 5a                	ja     10f9ff <IMFS_memfile_get_block_pointer+0xf1><== NOT EXECUTED
#if 0                                                                 
fprintf(stdout, "(d %d) ", block );                                   
fflush(stdout);                                                       
#endif                                                                
                                                                      
    my_block -= FIRST_DOUBLY_INDIRECT;                                
  10f9a5:	2b 5d e4             	sub    -0x1c(%ebp),%ebx               <== NOT EXECUTED
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
  10f9a8:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  10f9aa:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  10f9ac:	f7 75 e4             	divl   -0x1c(%ebp)                    <== NOT EXECUTED
  10f9af:	89 55 f0             	mov    %edx,-0x10(%ebp)               <== NOT EXECUTED
  10f9b2:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
                                                                      
    p = info->doubly_indirect;                                        
  10f9b4:	8b 46 58             	mov    0x58(%esi),%eax                <== NOT EXECUTED
    if ( malloc_it ) {                                                
  10f9b7:	85 ff                	test   %edi,%edi                      <== NOT EXECUTED
  10f9b9:	74 31                	je     10f9ec <IMFS_memfile_get_block_pointer+0xde><== NOT EXECUTED
                                                                      
      if ( !p ) {                                                     
  10f9bb:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10f9bd:	75 10                	jne    10f9cf <IMFS_memfile_get_block_pointer+0xc1><== NOT EXECUTED
        p = memfile_alloc_block();                                    
  10f9bf:	e8 28 ff ff ff       	call   10f8ec <memfile_alloc_block>   <== NOT EXECUTED
        if ( !p )                                                     
  10f9c4:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10f9c6:	0f 84 ba 00 00 00    	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
           return 0;                                                  
        info->doubly_indirect = p;                                    
  10f9cc:	89 46 58             	mov    %eax,0x58(%esi)                <== NOT EXECUTED
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
  10f9cf:	8d 1c 98             	lea    (%eax,%ebx,4),%ebx             <== NOT EXECUTED
  10f9d2:	8b 03                	mov    (%ebx),%eax                    <== NOT EXECUTED
      if ( !p1 ) {                                                    
  10f9d4:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10f9d6:	75 0f                	jne    10f9e7 <IMFS_memfile_get_block_pointer+0xd9><== NOT EXECUTED
        p1 = memfile_alloc_block();                                   
  10f9d8:	e8 0f ff ff ff       	call   10f8ec <memfile_alloc_block>   <== NOT EXECUTED
        if ( !p1 )                                                    
  10f9dd:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10f9df:	0f 84 a1 00 00 00    	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
  10f9e5:	89 03                	mov    %eax,(%ebx)                    <== NOT EXECUTED
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
  10f9e7:	8b 4d f0             	mov    -0x10(%ebp),%ecx               <== NOT EXECUTED
  10f9ea:	eb 7a                	jmp    10fa66 <IMFS_memfile_get_block_pointer+0x158><== NOT EXECUTED
    }                                                                 
                                                                      
    if ( !p )                                                         
  10f9ec:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10f9ee:	0f 84 92 00 00 00    	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
      return 0;                                                       
                                                                      
    p = (block_p *)p[ doubly ];                                       
  10f9f4:	8b 04 98             	mov    (%eax,%ebx,4),%eax             <== NOT EXECUTED
#if 0                                                                 
fprintf(stdout, "(d %d %d %d %d %p %p) ", block, my_block, doubly,    
                                       singly, p, &p[singly] );       
fflush(stdout);                                                       
#endif                                                                
    return (block_p *)&p[ singly ];                                   
  10f9f7:	8b 4d f0             	mov    -0x10(%ebp),%ecx               <== NOT EXECUTED
  10f9fa:	e9 80 00 00 00       	jmp    10fa7f <IMFS_memfile_get_block_pointer+0x171><== NOT EXECUTED
#endif                                                                
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
  10f9ff:	8d 41 01             	lea    0x1(%ecx),%eax                 <== NOT EXECUTED
  10fa02:	0f af 45 e4          	imul   -0x1c(%ebp),%eax               <== NOT EXECUTED
  10fa06:	48                   	dec    %eax                           <== NOT EXECUTED
  10fa07:	39 c3                	cmp    %eax,%ebx                      <== NOT EXECUTED
  10fa09:	77 7b                	ja     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
    my_block -= FIRST_TRIPLY_INDIRECT;                                
  10fa0b:	29 cb                	sub    %ecx,%ebx                      <== NOT EXECUTED
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
  10fa0d:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  10fa0f:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  10fa11:	f7 75 e4             	divl   -0x1c(%ebp)                    <== NOT EXECUTED
  10fa14:	89 55 ec             	mov    %edx,-0x14(%ebp)               <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
  10fa17:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  10fa19:	f7 75 e4             	divl   -0x1c(%ebp)                    <== NOT EXECUTED
  10fa1c:	89 55 e8             	mov    %edx,-0x18(%ebp)               <== NOT EXECUTED
  10fa1f:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
                                                                      
    p = info->triply_indirect;                                        
  10fa21:	8b 46 5c             	mov    0x5c(%esi),%eax                <== NOT EXECUTED
                                                                      
    if ( malloc_it ) {                                                
  10fa24:	85 ff                	test   %edi,%edi                      <== NOT EXECUTED
  10fa26:	74 43                	je     10fa6b <IMFS_memfile_get_block_pointer+0x15d><== NOT EXECUTED
      if ( !p ) {                                                     
  10fa28:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa2a:	75 0c                	jne    10fa38 <IMFS_memfile_get_block_pointer+0x12a><== NOT EXECUTED
        p = memfile_alloc_block();                                    
  10fa2c:	e8 bb fe ff ff       	call   10f8ec <memfile_alloc_block>   <== NOT EXECUTED
        if ( !p )                                                     
  10fa31:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa33:	74 51                	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
           return 0;                                                  
        info->triply_indirect = p;                                    
  10fa35:	89 46 5c             	mov    %eax,0x5c(%esi)                <== NOT EXECUTED
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
  10fa38:	8d 1c 98             	lea    (%eax,%ebx,4),%ebx             <== NOT EXECUTED
  10fa3b:	8b 03                	mov    (%ebx),%eax                    <== NOT EXECUTED
      if ( !p1 ) {                                                    
  10fa3d:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa3f:	75 0b                	jne    10fa4c <IMFS_memfile_get_block_pointer+0x13e><== NOT EXECUTED
        p1 = memfile_alloc_block();                                   
  10fa41:	e8 a6 fe ff ff       	call   10f8ec <memfile_alloc_block>   <== NOT EXECUTED
        if ( !p1 )                                                    
  10fa46:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa48:	74 3c                	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
  10fa4a:	89 03                	mov    %eax,(%ebx)                    <== NOT EXECUTED
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
  10fa4c:	8b 4d e8             	mov    -0x18(%ebp),%ecx               <== NOT EXECUTED
  10fa4f:	8d 1c 88             	lea    (%eax,%ecx,4),%ebx             <== NOT EXECUTED
  10fa52:	8b 03                	mov    (%ebx),%eax                    <== NOT EXECUTED
      if ( !p2 ) {                                                    
  10fa54:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa56:	75 0b                	jne    10fa63 <IMFS_memfile_get_block_pointer+0x155><== NOT EXECUTED
        p2 = memfile_alloc_block();                                   
  10fa58:	e8 8f fe ff ff       	call   10f8ec <memfile_alloc_block>   <== NOT EXECUTED
        if ( !p2 )                                                    
  10fa5d:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa5f:	74 25                	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
  10fa61:	89 03                	mov    %eax,(%ebx)                    <== NOT EXECUTED
      }                                                               
      return (block_p *)&p2[ singly ];                                
  10fa63:	8b 4d ec             	mov    -0x14(%ebp),%ecx               <== NOT EXECUTED
  10fa66:	8d 14 88             	lea    (%eax,%ecx,4),%edx             <== NOT EXECUTED
  10fa69:	eb 1d                	jmp    10fa88 <IMFS_memfile_get_block_pointer+0x17a><== NOT EXECUTED
    }                                                                 
                                                                      
    if ( !p )                                                         
  10fa6b:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa6d:	74 17                	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
                                                                      
#if 0                                                                 
fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly );
fflush(stdout);                                                       
#endif                                                                
    p1 = (block_p *) p[ triply ];                                     
  10fa6f:	8b 04 98             	mov    (%eax,%ebx,4),%eax             <== NOT EXECUTED
    if ( !p1 )                                                        
  10fa72:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fa74:	74 10                	je     10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
  10fa76:	8b 55 e8             	mov    -0x18(%ebp),%edx               <== NOT EXECUTED
  10fa79:	8b 04 90             	mov    (%eax,%edx,4),%eax             <== NOT EXECUTED
    if ( !p2 )                                                        
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
  10fa7c:	8b 4d ec             	mov    -0x14(%ebp),%ecx               <== NOT EXECUTED
  10fa7f:	8d 14 88             	lea    (%eax,%ecx,4),%edx             <== NOT EXECUTED
    p1 = (block_p *) p[ triply ];                                     
    if ( !p1 )                                                        
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
    if ( !p2 )                                                        
  10fa82:	85 c0                	test   %eax,%eax                      
  10fa84:	75 02                	jne    10fa88 <IMFS_memfile_get_block_pointer+0x17a><== ALWAYS TAKEN
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
  10fa86:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
                                                                      
  return 0;                                                           
}                                                                     
  10fa88:	89 d0                	mov    %edx,%eax                      
  10fa8a:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10fa8d:	5b                   	pop    %ebx                           
  10fa8e:	5e                   	pop    %esi                           
  10fa8f:	5f                   	pop    %edi                           
  10fa90:	c9                   	leave                                 
  10fa91:	c3                   	ret                                   
                                                                      

00110172 <IMFS_memfile_read>: IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) {
  110172:	55                   	push   %ebp                           
  110173:	89 e5                	mov    %esp,%ebp                      
  110175:	57                   	push   %edi                           
  110176:	56                   	push   %esi                           
  110177:	53                   	push   %ebx                           
  110178:	83 ec 3c             	sub    $0x3c,%esp                     
  11017b:	8b 5d 14             	mov    0x14(%ebp),%ebx                
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
  11017e:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  110182:	75 11                	jne    110195 <IMFS_memfile_read+0x23><== ALWAYS TAKEN
  110184:	68 bc b5 11 00       	push   $0x11b5bc                      <== NOT EXECUTED
  110189:	68 00 b7 11 00       	push   $0x11b700                      <== NOT EXECUTED
  11018e:	68 4a 02 00 00       	push   $0x24a                         <== NOT EXECUTED
  110193:	eb 1d                	jmp    1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE ||                      
  110195:	8b 45 08             	mov    0x8(%ebp),%eax                 
  110198:	8b 48 4c             	mov    0x4c(%eax),%ecx                
  11019b:	8d 41 fb             	lea    -0x5(%ecx),%eax                
  11019e:	83 f8 01             	cmp    $0x1,%eax                      
  1101a1:	76 19                	jbe    1101bc <IMFS_memfile_read+0x4a><== ALWAYS TAKEN
  1101a3:	68 7c b6 11 00       	push   $0x11b67c                      <== NOT EXECUTED
  1101a8:	68 00 b7 11 00       	push   $0x11b700                      <== NOT EXECUTED
  1101ad:	68 4f 02 00 00       	push   $0x24f                         <== NOT EXECUTED
  1101b2:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  1101b7:	e8 e8 6b ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Error checks on arguments                                       
   */                                                                 
                                                                      
  assert( dest );                                                     
  1101bc:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  1101c0:	75 11                	jne    1101d3 <IMFS_memfile_read+0x61><== ALWAYS TAKEN
  1101c2:	68 c7 b6 11 00       	push   $0x11b6c7                      <== NOT EXECUTED
  1101c7:	68 00 b7 11 00       	push   $0x11b700                      <== NOT EXECUTED
  1101cc:	68 58 02 00 00       	push   $0x258                         <== NOT EXECUTED
  1101d1:	eb df                	jmp    1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
  /*                                                                  
   *  If there is nothing to read, then quick exit.                   
   */                                                                 
                                                                      
  my_length = length;                                                 
  if ( !my_length )                                                   
  1101d3:	85 db                	test   %ebx,%ebx                      
  1101d5:	75 13                	jne    1101ea <IMFS_memfile_read+0x78><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  1101d7:	e8 04 0e 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  1101dc:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  1101e2:	83 c9 ff             	or     $0xffffffff,%ecx               <== NOT EXECUTED
  1101e5:	e9 86 01 00 00       	jmp    110370 <IMFS_memfile_read+0x1fe><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
  1101ea:	83 f9 06             	cmp    $0x6,%ecx                      
  1101ed:	75 47                	jne    110236 <IMFS_memfile_read+0xc4><== ALWAYS TAKEN
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
  1101ef:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  1101f2:	8b 52 50             	mov    0x50(%edx),%edx                <== NOT EXECUTED
  1101f5:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 <== NOT EXECUTED
  1101f8:	29 ca                	sub    %ecx,%edx                      <== NOT EXECUTED
  1101fa:	89 55 c4             	mov    %edx,-0x3c(%ebp)               <== NOT EXECUTED
  1101fd:	39 da                	cmp    %ebx,%edx                      <== NOT EXECUTED
  1101ff:	76 03                	jbe    110204 <IMFS_memfile_read+0x92><== NOT EXECUTED
  110201:	89 5d c4             	mov    %ebx,-0x3c(%ebp)               <== NOT EXECUTED
      my_length = the_jnode->info.linearfile.size - start;            
                                                                      
    memcpy(dest, &file_ptr[start], my_length);                        
  110204:	8b 75 08             	mov    0x8(%ebp),%esi                 <== NOT EXECUTED
  110207:	8b 76 54             	mov    0x54(%esi),%esi                <== NOT EXECUTED
  11020a:	01 75 0c             	add    %esi,0xc(%ebp)                 <== NOT EXECUTED
  11020d:	8b 7d 10             	mov    0x10(%ebp),%edi                <== NOT EXECUTED
  110210:	8b 75 0c             	mov    0xc(%ebp),%esi                 <== NOT EXECUTED
  110213:	8b 4d c4             	mov    -0x3c(%ebp),%ecx               <== NOT EXECUTED
  110216:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       <== NOT EXECUTED
                                                                      
    IMFS_update_atime( the_jnode );                                   
  110218:	50                   	push   %eax                           <== NOT EXECUTED
  110219:	50                   	push   %eax                           <== NOT EXECUTED
  11021a:	6a 00                	push   $0x0                           <== NOT EXECUTED
  11021c:	8d 45 ec             	lea    -0x14(%ebp),%eax               <== NOT EXECUTED
  11021f:	50                   	push   %eax                           <== NOT EXECUTED
  110220:	e8 43 72 ff ff       	call   107468 <gettimeofday>          <== NOT EXECUTED
  110225:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  110228:	8b 7d 08             	mov    0x8(%ebp),%edi                 <== NOT EXECUTED
  11022b:	89 47 40             	mov    %eax,0x40(%edi)                <== NOT EXECUTED
                                                                      
    return my_length;                                                 
  11022e:	8b 4d c4             	mov    -0x3c(%ebp),%ecx               <== NOT EXECUTED
  110231:	e9 37 01 00 00       	jmp    11036d <IMFS_memfile_read+0x1fb><== NOT EXECUTED
   *  If the last byte we are supposed to read is past the end of this
   *  in memory file, then shorten the length to read.                
   */                                                                 
                                                                      
  last_byte = start + length;                                         
  if ( last_byte > the_jnode->info.file.size )                        
  110236:	8b 45 08             	mov    0x8(%ebp),%eax                 
  110239:	8b 48 50             	mov    0x50(%eax),%ecx                
  11023c:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  11023f:	8d 04 13             	lea    (%ebx,%edx,1),%eax             
  110242:	39 c8                	cmp    %ecx,%eax                      
  110244:	76 05                	jbe    11024b <IMFS_memfile_read+0xd9><== NEVER TAKEN
    my_length = the_jnode->info.file.size - start;                    
  110246:	89 cb                	mov    %ecx,%ebx                      
  110248:	2b 5d 0c             	sub    0xc(%ebp),%ebx                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  11024b:	8b 3d ac 11 12 00    	mov    0x1211ac,%edi                  
  110251:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  110254:	99                   	cltd                                  
  110255:	f7 ff                	idiv   %edi                           
  110257:	89 d6                	mov    %edx,%esi                      
  110259:	89 45 cc             	mov    %eax,-0x34(%ebp)               
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  11025c:	89 45 d4             	mov    %eax,-0x2c(%ebp)               
  if ( start_offset )  {                                              
  11025f:	85 d2                	test   %edx,%edx                      
  110261:	75 0f                	jne    110272 <IMFS_memfile_read+0x100>
  110263:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  110266:	89 4d dc             	mov    %ecx,-0x24(%ebp)               
  110269:	c7 45 d8 00 00 00 00 	movl   $0x0,-0x28(%ebp)               
  110270:	eb 54                	jmp    1102c6 <IMFS_memfile_read+0x154>
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  110272:	50                   	push   %eax                           
  110273:	6a 00                	push   $0x0                           
  110275:	ff 75 cc             	pushl  -0x34(%ebp)                    
  110278:	ff 75 08             	pushl  0x8(%ebp)                      
  11027b:	e8 8e f6 ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
    assert( block_ptr );                                              
  110280:	83 c4 10             	add    $0x10,%esp                     
  110283:	85 c0                	test   %eax,%eax                      
  110285:	75 14                	jne    11029b <IMFS_memfile_read+0x129><== ALWAYS TAKEN
  110287:	68 49 b6 11 00       	push   $0x11b649                      <== NOT EXECUTED
  11028c:	68 00 b7 11 00       	push   $0x11b700                      <== NOT EXECUTED
  110291:	68 94 02 00 00       	push   $0x294                         <== NOT EXECUTED
  110296:	e9 17 ff ff ff       	jmp    1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
   */                                                                 
                                                                      
  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;            
  11029b:	89 fa                	mov    %edi,%edx                      
  11029d:	29 f2                	sub    %esi,%edx                      
  11029f:	89 5d c0             	mov    %ebx,-0x40(%ebp)               
  1102a2:	39 d3                	cmp    %edx,%ebx                      
  1102a4:	76 03                	jbe    1102a9 <IMFS_memfile_read+0x137>
  1102a6:	89 55 c0             	mov    %edx,-0x40(%ebp)               
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    assert( block_ptr );                                              
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
  1102a9:	03 30                	add    (%eax),%esi                    
    dest += to_copy;                                                  
  1102ab:	8b 7d 10             	mov    0x10(%ebp),%edi                
  1102ae:	8b 4d c0             	mov    -0x40(%ebp),%ecx               
  1102b1:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
  1102b3:	89 7d dc             	mov    %edi,-0x24(%ebp)               
    block++;                                                          
  1102b6:	8b 45 cc             	mov    -0x34(%ebp),%eax               
  1102b9:	40                   	inc    %eax                           
  1102ba:	89 45 d4             	mov    %eax,-0x2c(%ebp)               
    my_length -= to_copy;                                             
  1102bd:	2b 5d c0             	sub    -0x40(%ebp),%ebx               
  1102c0:	8b 55 c0             	mov    -0x40(%ebp),%edx               
  1102c3:	89 55 d8             	mov    %edx,-0x28(%ebp)               
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  1102c6:	8b 0d ac 11 12 00    	mov    0x1211ac,%ecx                  
  1102cc:	89 4d e0             	mov    %ecx,-0x20(%ebp)               
  1102cf:	eb 42                	jmp    110313 <IMFS_memfile_read+0x1a1>
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  1102d1:	57                   	push   %edi                           
  1102d2:	6a 00                	push   $0x0                           
  1102d4:	ff 75 d4             	pushl  -0x2c(%ebp)                    
  1102d7:	ff 75 08             	pushl  0x8(%ebp)                      
  1102da:	e8 2f f6 ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
    assert( block_ptr );                                              
  1102df:	83 c4 10             	add    $0x10,%esp                     
  1102e2:	85 c0                	test   %eax,%eax                      
  1102e4:	75 14                	jne    1102fa <IMFS_memfile_read+0x188><== ALWAYS TAKEN
  1102e6:	68 49 b6 11 00       	push   $0x11b649                      <== NOT EXECUTED
  1102eb:	68 00 b7 11 00       	push   $0x11b700                      <== NOT EXECUTED
  1102f0:	68 a5 02 00 00       	push   $0x2a5                         <== NOT EXECUTED
  1102f5:	e9 b8 fe ff ff       	jmp    1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
  1102fa:	8b 30                	mov    (%eax),%esi                    
  1102fc:	8b 7d dc             	mov    -0x24(%ebp),%edi               
  1102ff:	8b 4d e0             	mov    -0x20(%ebp),%ecx               
  110302:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
    dest += to_copy;                                                  
  110304:	89 7d dc             	mov    %edi,-0x24(%ebp)               
    block++;                                                          
  110307:	ff 45 d4             	incl   -0x2c(%ebp)                    
    my_length -= to_copy;                                             
  11030a:	2b 5d e0             	sub    -0x20(%ebp),%ebx               
    copied += to_copy;                                                
  11030d:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  110310:	01 75 d8             	add    %esi,-0x28(%ebp)               
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
  110313:	3b 1d ac 11 12 00    	cmp    0x1211ac,%ebx                  
  110319:	73 b6                	jae    1102d1 <IMFS_memfile_read+0x15f>
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
                                                                      
  assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );                 
                                                                      
  if ( my_length ) {                                                  
  11031b:	85 db                	test   %ebx,%ebx                      
  11031d:	74 35                	je     110354 <IMFS_memfile_read+0x1e2>
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  11031f:	56                   	push   %esi                           
  110320:	6a 00                	push   $0x0                           
  110322:	ff 75 d4             	pushl  -0x2c(%ebp)                    
  110325:	ff 75 08             	pushl  0x8(%ebp)                      
  110328:	e8 e1 f5 ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
    assert( block_ptr );                                              
  11032d:	83 c4 10             	add    $0x10,%esp                     
  110330:	85 c0                	test   %eax,%eax                      
  110332:	75 14                	jne    110348 <IMFS_memfile_read+0x1d6><== ALWAYS TAKEN
  110334:	68 49 b6 11 00       	push   $0x11b649                      <== NOT EXECUTED
  110339:	68 00 b7 11 00       	push   $0x11b700                      <== NOT EXECUTED
  11033e:	68 b7 02 00 00       	push   $0x2b7                         <== NOT EXECUTED
  110343:	e9 6a fe ff ff       	jmp    1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
  110348:	8b 30                	mov    (%eax),%esi                    
  11034a:	8b 7d dc             	mov    -0x24(%ebp),%edi               
  11034d:	89 d9                	mov    %ebx,%ecx                      
  11034f:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
    copied += my_length;                                              
  110351:	01 5d d8             	add    %ebx,-0x28(%ebp)               
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
  110354:	53                   	push   %ebx                           
  110355:	53                   	push   %ebx                           
  110356:	6a 00                	push   $0x0                           
  110358:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  11035b:	50                   	push   %eax                           
  11035c:	e8 07 71 ff ff       	call   107468 <gettimeofday>          
  110361:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  110364:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  110367:	89 47 40             	mov    %eax,0x40(%edi)                
                                                                      
  return copied;                                                      
  11036a:	8b 4d d8             	mov    -0x28(%ebp),%ecx               
  11036d:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  110370:	89 c8                	mov    %ecx,%eax                      
  110372:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  110375:	5b                   	pop    %ebx                           
  110376:	5e                   	pop    %esi                           
  110377:	5f                   	pop    %edi                           
  110378:	c9                   	leave                                 
  110379:	c3                   	ret                                   
                                                                      

0010fb26 <IMFS_memfile_remove>: */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) {
  10fb26:	55                   	push   %ebp                           
  10fb27:	89 e5                	mov    %esp,%ebp                      
  10fb29:	57                   	push   %edi                           
  10fb2a:	56                   	push   %esi                           
  10fb2b:	53                   	push   %ebx                           
  10fb2c:	83 ec 0c             	sub    $0xc,%esp                      
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
  10fb2f:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  10fb33:	75 11                	jne    10fb46 <IMFS_memfile_remove+0x20><== ALWAYS TAKEN
  10fb35:	68 bc b5 11 00       	push   $0x11b5bc                      <== NOT EXECUTED
  10fb3a:	68 14 b7 11 00       	push   $0x11b714                      <== NOT EXECUTED
  10fb3f:	68 ec 01 00 00       	push   $0x1ec                         <== NOT EXECUTED
  10fb44:	eb 18                	jmp    10fb5e <IMFS_memfile_remove+0x38><== NOT EXECUTED
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
  10fb46:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10fb49:	83 78 4c 05          	cmpl   $0x5,0x4c(%eax)                
  10fb4d:	74 19                	je     10fb68 <IMFS_memfile_remove+0x42><== ALWAYS TAKEN
  10fb4f:	68 12 b6 11 00       	push   $0x11b612                      <== NOT EXECUTED
  10fb54:	68 14 b7 11 00       	push   $0x11b714                      <== NOT EXECUTED
  10fb59:	68 f0 01 00 00       	push   $0x1f0                         <== NOT EXECUTED
  10fb5e:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  10fb63:	e8 3c 72 ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
  /*                                                                  
   *  Eventually this could be set smarter at each call to            
   *  memfile_free_blocks_in_table to greatly speed this up.          
   */                                                                 
                                                                      
  to_free = IMFS_MEMFILE_BLOCK_SLOTS;                                 
  10fb68:	8b 3d ac 11 12 00    	mov    0x1211ac,%edi                  
  10fb6e:	c1 ef 02             	shr    $0x2,%edi                      
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
  10fb71:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10fb74:	83 7a 54 00          	cmpl   $0x0,0x54(%edx)                
  10fb78:	74 11                	je     10fb8b <IMFS_memfile_remove+0x65>
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  10fb7a:	50                   	push   %eax                           
  10fb7b:	50                   	push   %eax                           
  10fb7c:	57                   	push   %edi                           
  10fb7d:	89 d0                	mov    %edx,%eax                      
  10fb7f:	83 c0 54             	add    $0x54,%eax                     
  10fb82:	50                   	push   %eax                           
  10fb83:	e8 34 ff ff ff       	call   10fabc <memfile_free_blocks_in_table>
  10fb88:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
  10fb8b:	31 db                	xor    %ebx,%ebx                      
  10fb8d:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10fb90:	83 78 58 00          	cmpl   $0x0,0x58(%eax)                
  10fb94:	75 24                	jne    10fbba <IMFS_memfile_remove+0x94><== NEVER TAKEN
  10fb96:	eb 40                	jmp    10fbd8 <IMFS_memfile_remove+0xb2>
                                                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      if ( info->doubly_indirect[i] ) {                               
  10fb98:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  10fb9b:	8b 42 58             	mov    0x58(%edx),%eax                <== NOT EXECUTED
  10fb9e:	8d 14 9d 00 00 00 00 	lea    0x0(,%ebx,4),%edx              <== NOT EXECUTED
  10fba5:	83 3c 98 00          	cmpl   $0x0,(%eax,%ebx,4)             <== NOT EXECUTED
  10fba9:	74 0e                	je     10fbb9 <IMFS_memfile_remove+0x93><== NOT EXECUTED
        memfile_free_blocks_in_table(                                 
  10fbab:	56                   	push   %esi                           <== NOT EXECUTED
  10fbac:	56                   	push   %esi                           <== NOT EXECUTED
  10fbad:	57                   	push   %edi                           <== NOT EXECUTED
  10fbae:	01 d0                	add    %edx,%eax                      <== NOT EXECUTED
  10fbb0:	50                   	push   %eax                           <== NOT EXECUTED
  10fbb1:	e8 06 ff ff ff       	call   10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
  10fbb6:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
                                                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
  10fbb9:	43                   	inc    %ebx                           <== NOT EXECUTED
  10fbba:	a1 ac 11 12 00       	mov    0x1211ac,%eax                  <== NOT EXECUTED
  10fbbf:	c1 e8 02             	shr    $0x2,%eax                      <== NOT EXECUTED
  10fbc2:	39 c3                	cmp    %eax,%ebx                      <== NOT EXECUTED
  10fbc4:	72 d2                	jb     10fb98 <IMFS_memfile_remove+0x72><== NOT EXECUTED
      if ( info->doubly_indirect[i] ) {                               
        memfile_free_blocks_in_table(                                 
         (block_p **)&info->doubly_indirect[i], to_free );            
      }                                                               
    }                                                                 
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
  10fbc6:	53                   	push   %ebx                           <== NOT EXECUTED
  10fbc7:	53                   	push   %ebx                           <== NOT EXECUTED
  10fbc8:	57                   	push   %edi                           <== NOT EXECUTED
  10fbc9:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10fbcc:	83 c0 58             	add    $0x58,%eax                     <== NOT EXECUTED
  10fbcf:	50                   	push   %eax                           <== NOT EXECUTED
  10fbd0:	e8 e7 fe ff ff       	call   10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
  10fbd5:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
  10fbd8:	c7 45 ec 00 00 00 00 	movl   $0x0,-0x14(%ebp)               
  10fbdf:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10fbe2:	83 78 5c 00          	cmpl   $0x0,0x5c(%eax)                
  10fbe6:	75 5c                	jne    10fc44 <IMFS_memfile_remove+0x11e><== NEVER TAKEN
  10fbe8:	eb 79                	jmp    10fc63 <IMFS_memfile_remove+0x13d>
  10fbea:	8b 55 ec             	mov    -0x14(%ebp),%edx               <== NOT EXECUTED
  10fbed:	c1 e2 02             	shl    $0x2,%edx                      <== NOT EXECUTED
  10fbf0:	89 55 f0             	mov    %edx,-0x10(%ebp)               <== NOT EXECUTED
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
  10fbf3:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  10fbf6:	8b 42 5c             	mov    0x5c(%edx),%eax                <== NOT EXECUTED
  10fbf9:	8b 55 ec             	mov    -0x14(%ebp),%edx               <== NOT EXECUTED
  10fbfc:	8b 04 90             	mov    (%eax,%edx,4),%eax             <== NOT EXECUTED
      if ( !p )  /* ensure we have a valid pointer */                 
  10fbff:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10fc01:	74 4e                	je     10fc51 <IMFS_memfile_remove+0x12b><== NOT EXECUTED
         break;                                                       
  10fc03:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
  10fc05:	31 f6                	xor    %esi,%esi                      <== NOT EXECUTED
  10fc07:	eb 15                	jmp    10fc1e <IMFS_memfile_remove+0xf8><== NOT EXECUTED
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
        if ( p[j] ) {                                                 
  10fc09:	83 3b 00             	cmpl   $0x0,(%ebx)                    <== NOT EXECUTED
  10fc0c:	74 0c                	je     10fc1a <IMFS_memfile_remove+0xf4><== NOT EXECUTED
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
  10fc0e:	51                   	push   %ecx                           <== NOT EXECUTED
  10fc0f:	51                   	push   %ecx                           <== NOT EXECUTED
  10fc10:	57                   	push   %edi                           <== NOT EXECUTED
  10fc11:	53                   	push   %ebx                           <== NOT EXECUTED
  10fc12:	e8 a5 fe ff ff       	call   10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
  10fc17:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
      if ( !p )  /* ensure we have a valid pointer */                 
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
  10fc1a:	46                   	inc    %esi                           <== NOT EXECUTED
  10fc1b:	83 c3 04             	add    $0x4,%ebx                      <== NOT EXECUTED
  10fc1e:	a1 ac 11 12 00       	mov    0x1211ac,%eax                  <== NOT EXECUTED
  10fc23:	c1 e8 02             	shr    $0x2,%eax                      <== NOT EXECUTED
  10fc26:	39 c6                	cmp    %eax,%esi                      <== NOT EXECUTED
  10fc28:	72 df                	jb     10fc09 <IMFS_memfile_remove+0xe3><== NOT EXECUTED
        if ( p[j] ) {                                                 
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
  10fc2a:	52                   	push   %edx                           <== NOT EXECUTED
  10fc2b:	52                   	push   %edx                           <== NOT EXECUTED
  10fc2c:	57                   	push   %edi                           <== NOT EXECUTED
  10fc2d:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10fc30:	8b 40 5c             	mov    0x5c(%eax),%eax                <== NOT EXECUTED
  10fc33:	01 45 f0             	add    %eax,-0x10(%ebp)               <== NOT EXECUTED
  10fc36:	ff 75 f0             	pushl  -0x10(%ebp)                    <== NOT EXECUTED
  10fc39:	e8 7e fe ff ff       	call   10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
  10fc3e:	ff 45 ec             	incl   -0x14(%ebp)                    <== NOT EXECUTED
  10fc41:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10fc44:	a1 ac 11 12 00       	mov    0x1211ac,%eax                  <== NOT EXECUTED
  10fc49:	c1 e8 02             	shr    $0x2,%eax                      <== NOT EXECUTED
  10fc4c:	39 45 ec             	cmp    %eax,-0x14(%ebp)               <== NOT EXECUTED
  10fc4f:	72 99                	jb     10fbea <IMFS_memfile_remove+0xc4><== NOT EXECUTED
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
        (block_p **)&info->triply_indirect[i], to_free );             
    }                                                                 
    memfile_free_blocks_in_table(                                     
  10fc51:	50                   	push   %eax                           <== NOT EXECUTED
  10fc52:	50                   	push   %eax                           <== NOT EXECUTED
  10fc53:	57                   	push   %edi                           <== NOT EXECUTED
  10fc54:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10fc57:	83 c0 5c             	add    $0x5c,%eax                     <== NOT EXECUTED
  10fc5a:	50                   	push   %eax                           <== NOT EXECUTED
  10fc5b:	e8 5c fe ff ff       	call   10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
  10fc60:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
        (block_p **)&info->triply_indirect, to_free );                
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  10fc63:	31 c0                	xor    %eax,%eax                      
  10fc65:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10fc68:	5b                   	pop    %ebx                           
  10fc69:	5e                   	pop    %esi                           
  10fc6a:	5f                   	pop    %edi                           
  10fc6b:	c9                   	leave                                 
  10fc6c:	c3                   	ret                                   
                                                                      

0010fa92 <IMFS_memfile_remove_block>: MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) {
  10fa92:	55                   	push   %ebp                           <== NOT EXECUTED
  10fa93:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10fa95:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  block_p *block_entry_ptr;                                           
  block_p  ptr;                                                       
                                                                      
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  10fa98:	6a 00                	push   $0x0                           <== NOT EXECUTED
  10fa9a:	ff 75 0c             	pushl  0xc(%ebp)                      <== NOT EXECUTED
  10fa9d:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  10faa0:	e8 69 fe ff ff       	call   10f90e <IMFS_memfile_get_block_pointer><== NOT EXECUTED
  ptr = *block_entry_ptr;                                             
  10faa5:	8b 10                	mov    (%eax),%edx                    <== NOT EXECUTED
  *block_entry_ptr = 0;                                               
  10faa7:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    <== NOT EXECUTED
                                                                      
  memfile_free_block( ptr );                                          
  10faad:	89 14 24             	mov    %edx,(%esp)                    <== NOT EXECUTED
  10fab0:	e8 1e fe ff ff       	call   10f8d3 <memfile_free_block>    <== NOT EXECUTED
                                                                      
  return 1;                                                           
}                                                                     
  10fab5:	b8 01 00 00 00       	mov    $0x1,%eax                      <== NOT EXECUTED
  10faba:	c9                   	leave                                 <== NOT EXECUTED
  10fabb:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010ff04 <IMFS_memfile_write>: IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) {
  10ff04:	55                   	push   %ebp                           
  10ff05:	89 e5                	mov    %esp,%ebp                      
  10ff07:	57                   	push   %edi                           
  10ff08:	56                   	push   %esi                           
  10ff09:	53                   	push   %ebx                           
  10ff0a:	83 ec 3c             	sub    $0x3c,%esp                     
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
  10ff0d:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  10ff11:	75 11                	jne    10ff24 <IMFS_memfile_write+0x20><== ALWAYS TAKEN
  10ff13:	68 bc b5 11 00       	push   $0x11b5bc                      <== NOT EXECUTED
  10ff18:	68 ec b6 11 00       	push   $0x11b6ec                      <== NOT EXECUTED
  10ff1d:	68 e1 02 00 00       	push   $0x2e1                         <== NOT EXECUTED
  10ff22:	eb 18                	jmp    10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
  10ff24:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10ff27:	83 78 4c 05          	cmpl   $0x5,0x4c(%eax)                
  10ff2b:	74 19                	je     10ff46 <IMFS_memfile_write+0x42><== ALWAYS TAKEN
  10ff2d:	68 12 b6 11 00       	push   $0x11b612                      <== NOT EXECUTED
  10ff32:	68 ec b6 11 00       	push   $0x11b6ec                      <== NOT EXECUTED
  10ff37:	68 e5 02 00 00       	push   $0x2e5                         <== NOT EXECUTED
  10ff3c:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  10ff41:	e8 5e 6e ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Error check arguments                                           
   */                                                                 
                                                                      
  assert( source );                                                   
  10ff46:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  10ff4a:	75 11                	jne    10ff5d <IMFS_memfile_write+0x59><== ALWAYS TAKEN
  10ff4c:	68 42 b6 11 00       	push   $0x11b642                      <== NOT EXECUTED
  10ff51:	68 ec b6 11 00       	push   $0x11b6ec                      <== NOT EXECUTED
  10ff56:	68 ed 02 00 00       	push   $0x2ed                         <== NOT EXECUTED
  10ff5b:	eb df                	jmp    10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
  /*                                                                  
   *  If there is nothing to write, then quick exit.                  
   */                                                                 
                                                                      
  my_length = length;                                                 
  if ( !my_length )                                                   
  10ff5d:	83 7d 14 00          	cmpl   $0x0,0x14(%ebp)                
  10ff61:	75 0d                	jne    10ff70 <IMFS_memfile_write+0x6c><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10ff63:	e8 78 10 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  10ff68:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  10ff6e:	eb 29                	jmp    10ff99 <IMFS_memfile_write+0x95><== NOT EXECUTED
  /*                                                                  
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + length;                                         
  10ff70:	8b 45 14             	mov    0x14(%ebp),%eax                
  10ff73:	03 45 0c             	add    0xc(%ebp),%eax                 
  if ( last_byte > the_jnode->info.file.size ) {                      
  10ff76:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10ff79:	3b 42 50             	cmp    0x50(%edx),%eax                
  10ff7c:	76 27                	jbe    10ffa5 <IMFS_memfile_write+0xa1><== NEVER TAKEN
    status = IMFS_memfile_extend( the_jnode, last_byte );             
  10ff7e:	51                   	push   %ecx                           
  10ff7f:	51                   	push   %ecx                           
  10ff80:	50                   	push   %eax                           
  10ff81:	52                   	push   %edx                           
  10ff82:	e8 17 fe ff ff       	call   10fd9e <IMFS_memfile_extend>   
    if ( status )                                                     
  10ff87:	83 c4 10             	add    $0x10,%esp                     
  10ff8a:	85 c0                	test   %eax,%eax                      
  10ff8c:	74 17                	je     10ffa5 <IMFS_memfile_write+0xa1><== ALWAYS TAKEN
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
  10ff8e:	e8 4d 10 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  10ff93:	c7 00 1c 00 00 00    	movl   $0x1c,(%eax)                   <== NOT EXECUTED
  10ff99:	c7 45 dc ff ff ff ff 	movl   $0xffffffff,-0x24(%ebp)        <== NOT EXECUTED
  10ffa0:	e9 24 01 00 00       	jmp    1100c9 <IMFS_memfile_write+0x1c5><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  10ffa5:	8b 1d ac 11 12 00    	mov    0x1211ac,%ebx                  
  10ffab:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10ffae:	99                   	cltd                                  
  10ffaf:	f7 fb                	idiv   %ebx                           
  10ffb1:	89 d7                	mov    %edx,%edi                      
  10ffb3:	89 45 c4             	mov    %eax,-0x3c(%ebp)               
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  10ffb6:	89 45 d8             	mov    %eax,-0x28(%ebp)               
  if ( start_offset )  {                                              
  10ffb9:	85 d2                	test   %edx,%edx                      
  10ffbb:	75 12                	jne    10ffcf <IMFS_memfile_write+0xcb>
  10ffbd:	8b 5d 14             	mov    0x14(%ebp),%ebx                
  10ffc0:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  10ffc3:	89 4d e0             	mov    %ecx,-0x20(%ebp)               
  10ffc6:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               
  10ffcd:	eb 50                	jmp    11001f <IMFS_memfile_write+0x11b>
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  10ffcf:	50                   	push   %eax                           
  10ffd0:	6a 00                	push   $0x0                           
  10ffd2:	ff 75 c4             	pushl  -0x3c(%ebp)                    
  10ffd5:	ff 75 08             	pushl  0x8(%ebp)                      
  10ffd8:	e8 31 f9 ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
    assert( block_ptr );                                              
  10ffdd:	83 c4 10             	add    $0x10,%esp                     
  10ffe0:	85 c0                	test   %eax,%eax                      
  10ffe2:	75 14                	jne    10fff8 <IMFS_memfile_write+0xf4><== ALWAYS TAKEN
  10ffe4:	68 49 b6 11 00       	push   $0x11b649                      <== NOT EXECUTED
  10ffe9:	68 ec b6 11 00       	push   $0x11b6ec                      <== NOT EXECUTED
  10ffee:	68 1a 03 00 00       	push   $0x31a                         <== NOT EXECUTED
  10fff3:	e9 44 ff ff ff       	jmp    10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
   */                                                                 
                                                                      
  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;            
  10fff8:	89 da                	mov    %ebx,%edx                      
  10fffa:	29 fa                	sub    %edi,%edx                      
  10fffc:	3b 55 14             	cmp    0x14(%ebp),%edx                
  10ffff:	76 03                	jbe    110004 <IMFS_memfile_write+0x100><== NEVER TAKEN
  110001:	8b 55 14             	mov    0x14(%ebp),%edx                
    if ( !block_ptr )                                                 
      return copied;                                                  
#if 0                                                                 
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif                                                                
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
  110004:	03 38                	add    (%eax),%edi                    
    src += to_copy;                                                   
  110006:	8b 75 10             	mov    0x10(%ebp),%esi                
  110009:	89 d1                	mov    %edx,%ecx                      
  11000b:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
  11000d:	89 75 e0             	mov    %esi,-0x20(%ebp)               
    block++;                                                          
  110010:	8b 45 c4             	mov    -0x3c(%ebp),%eax               
  110013:	40                   	inc    %eax                           
  110014:	89 45 d8             	mov    %eax,-0x28(%ebp)               
    my_length -= to_copy;                                             
  110017:	8b 5d 14             	mov    0x14(%ebp),%ebx                
  11001a:	29 d3                	sub    %edx,%ebx                      
    copied += to_copy;                                                
  11001c:	89 55 dc             	mov    %edx,-0x24(%ebp)               
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  11001f:	8b 15 ac 11 12 00    	mov    0x1211ac,%edx                  
  110025:	89 55 c4             	mov    %edx,-0x3c(%ebp)               
  110028:	eb 42                	jmp    11006c <IMFS_memfile_write+0x168>
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  11002a:	57                   	push   %edi                           
  11002b:	6a 00                	push   $0x0                           
  11002d:	ff 75 d8             	pushl  -0x28(%ebp)                    
  110030:	ff 75 08             	pushl  0x8(%ebp)                      
  110033:	e8 d6 f8 ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
    assert( block_ptr );                                              
  110038:	83 c4 10             	add    $0x10,%esp                     
  11003b:	85 c0                	test   %eax,%eax                      
  11003d:	75 14                	jne    110053 <IMFS_memfile_write+0x14f><== ALWAYS TAKEN
  11003f:	68 49 b6 11 00       	push   $0x11b649                      <== NOT EXECUTED
  110044:	68 ec b6 11 00       	push   $0x11b6ec                      <== NOT EXECUTED
  110049:	68 2e 03 00 00       	push   $0x32e                         <== NOT EXECUTED
  11004e:	e9 e9 fe ff ff       	jmp    10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
    if ( !block_ptr )                                                 
      return copied;                                                  
#if 0                                                                 
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif                                                                
    memcpy( &(*block_ptr)[ 0 ], src, to_copy );                       
  110053:	8b 38                	mov    (%eax),%edi                    
    src += to_copy;                                                   
  110055:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  110058:	8b 4d c4             	mov    -0x3c(%ebp),%ecx               
  11005b:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
  11005d:	89 75 e0             	mov    %esi,-0x20(%ebp)               
    block++;                                                          
  110060:	ff 45 d8             	incl   -0x28(%ebp)                    
    my_length -= to_copy;                                             
  110063:	2b 5d c4             	sub    -0x3c(%ebp),%ebx               
   IMFS_jnode_t          *the_jnode,                                  
   off_t                  start,                                      
   const unsigned char   *source,                                     
   unsigned int           length                                      
)                                                                     
{                                                                     
  110066:	8b 45 c4             	mov    -0x3c(%ebp),%eax               
  110069:	01 45 dc             	add    %eax,-0x24(%ebp)               
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
  11006c:	3b 1d ac 11 12 00    	cmp    0x1211ac,%ebx                  
  110072:	73 b6                	jae    11002a <IMFS_memfile_write+0x126>
   */                                                                 
                                                                      
  assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );                 
                                                                      
  to_copy = my_length;                                                
  if ( my_length ) {                                                  
  110074:	85 db                	test   %ebx,%ebx                      
  110076:	74 35                	je     1100ad <IMFS_memfile_write+0x1a9>
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
  110078:	56                   	push   %esi                           
  110079:	6a 00                	push   $0x0                           
  11007b:	ff 75 d8             	pushl  -0x28(%ebp)                    
  11007e:	ff 75 08             	pushl  0x8(%ebp)                      
  110081:	e8 88 f8 ff ff       	call   10f90e <IMFS_memfile_get_block_pointer>
    assert( block_ptr );                                              
  110086:	83 c4 10             	add    $0x10,%esp                     
  110089:	85 c0                	test   %eax,%eax                      
  11008b:	75 14                	jne    1100a1 <IMFS_memfile_write+0x19d><== ALWAYS TAKEN
  11008d:	68 49 b6 11 00       	push   $0x11b649                      <== NOT EXECUTED
  110092:	68 ec b6 11 00       	push   $0x11b6ec                      <== NOT EXECUTED
  110097:	68 44 03 00 00       	push   $0x344                         <== NOT EXECUTED
  11009c:	e9 9b fe ff ff       	jmp    10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
    if ( !block_ptr )                                                 
      return copied;                                                  
#if 0                                                                 
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif                                                                
    memcpy( &(*block_ptr)[ 0 ], src, my_length );                     
  1100a1:	8b 38                	mov    (%eax),%edi                    
  1100a3:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  1100a6:	89 d9                	mov    %ebx,%ecx                      
  1100a8:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
    my_length = 0;                                                    
    copied += to_copy;                                                
  1100aa:	01 5d dc             	add    %ebx,-0x24(%ebp)               
  }                                                                   
                                                                      
  IMFS_atime_mtime_update( the_jnode );                               
  1100ad:	53                   	push   %ebx                           
  1100ae:	53                   	push   %ebx                           
  1100af:	6a 00                	push   $0x0                           
  1100b1:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  1100b4:	50                   	push   %eax                           
  1100b5:	e8 ae 73 ff ff       	call   107468 <gettimeofday>          
  1100ba:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  1100bd:	8b 55 08             	mov    0x8(%ebp),%edx                 
  1100c0:	89 42 44             	mov    %eax,0x44(%edx)                
  1100c3:	89 42 40             	mov    %eax,0x40(%edx)                
  1100c6:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return copied;                                                      
}                                                                     
  1100c9:	8b 45 dc             	mov    -0x24(%ebp),%eax               
  1100cc:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1100cf:	5b                   	pop    %ebx                           
  1100d0:	5e                   	pop    %esi                           
  1100d1:	5f                   	pop    %edi                           
  1100d2:	c9                   	leave                                 
  1100d3:	c3                   	ret                                   
                                                                      

0010ca04 <IMFS_mknod>: const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) {
  10ca04:	55                   	push   %ebp                           
  10ca05:	89 e5                	mov    %esp,%ebp                      
  10ca07:	57                   	push   %edi                           
  10ca08:	56                   	push   %esi                           
  10ca09:	53                   	push   %ebx                           
  10ca0a:	83 ec 50             	sub    $0x50,%esp                     
  10ca0d:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  10ca10:	8b 5d 10             	mov    0x10(%ebp),%ebx                
  10ca13:	8b 75 14             	mov    0x14(%ebp),%esi                
  IMFS_jnode_t      *new_node;                                        
  int                result;                                          
  char               new_name[ IMFS_NAME_MAX + 1 ];                   
  IMFS_types_union   info;                                            
                                                                      
  IMFS_get_token( token, new_name, &result );                         
  10ca16:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10ca19:	50                   	push   %eax                           
  10ca1a:	8d 45 bf             	lea    -0x41(%ebp),%eax               
  10ca1d:	50                   	push   %eax                           
  10ca1e:	ff 75 08             	pushl  0x8(%ebp)                      
  10ca21:	e8 7a fe ff ff       	call   10c8a0 <IMFS_get_token>        
                                                                      
  /*                                                                  
   *  Figure out what type of IMFS node this is.                      
   */                                                                 
                                                                      
  if ( S_ISDIR(mode) )                                                
  10ca26:	89 f8                	mov    %edi,%eax                      
  10ca28:	25 00 f0 00 00       	and    $0xf000,%eax                   
  10ca2d:	83 c4 10             	add    $0x10,%esp                     
  10ca30:	3d 00 40 00 00       	cmp    $0x4000,%eax                   
  10ca35:	74 34                	je     10ca6b <IMFS_mknod+0x67>       
    type = IMFS_DIRECTORY;                                            
  else if ( S_ISREG(mode) )                                           
  10ca37:	ba 05 00 00 00       	mov    $0x5,%edx                      
  10ca3c:	3d 00 80 00 00       	cmp    $0x8000,%eax                   
  10ca41:	74 2d                	je     10ca70 <IMFS_mknod+0x6c>       
    type = IMFS_MEMORY_FILE;                                          
  else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {                        
  10ca43:	3d 00 60 00 00       	cmp    $0x6000,%eax                   
  10ca48:	74 07                	je     10ca51 <IMFS_mknod+0x4d>       <== NEVER TAKEN
  10ca4a:	3d 00 20 00 00       	cmp    $0x2000,%eax                   
  10ca4f:	75 0d                	jne    10ca5e <IMFS_mknod+0x5a>       <== NEVER TAKEN
    type = IMFS_DEVICE;                                               
    rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
  10ca51:	89 5d e0             	mov    %ebx,-0x20(%ebp)               
  10ca54:	89 75 e4             	mov    %esi,-0x1c(%ebp)               
  10ca57:	ba 02 00 00 00       	mov    $0x2,%edx                      
  10ca5c:	eb 12                	jmp    10ca70 <IMFS_mknod+0x6c>       
  } else  {                                                           
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10ca5e:	e8 c5 26 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10ca63:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  10ca69:	eb 2e                	jmp    10ca99 <IMFS_mknod+0x95>       <== NOT EXECUTED
  10ca6b:	ba 01 00 00 00       	mov    $0x1,%edx                      
                                                                      
  /*                                                                  
   *  Allocate and fill in an IMFS jnode                              
   */                                                                 
                                                                      
  new_node = IMFS_create_node(                                        
  10ca70:	83 ec 0c             	sub    $0xc,%esp                      
  10ca73:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  10ca76:	50                   	push   %eax                           
  10ca77:	57                   	push   %edi                           
  10ca78:	8d 45 bf             	lea    -0x41(%ebp),%eax               
  10ca7b:	50                   	push   %eax                           
  10ca7c:	52                   	push   %edx                           
  10ca7d:	ff 75 18             	pushl  0x18(%ebp)                     
  10ca80:	e8 eb 1c 00 00       	call   10e770 <IMFS_create_node>      
    new_name,                                                         
    mode,                                                             
    &info                                                             
  );                                                                  
                                                                      
  if ( !new_node )                                                    
  10ca85:	83 c4 20             	add    $0x20,%esp                     
  10ca88:	31 d2                	xor    %edx,%edx                      
  10ca8a:	85 c0                	test   %eax,%eax                      
  10ca8c:	75 0e                	jne    10ca9c <IMFS_mknod+0x98>       <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
  10ca8e:	e8 95 26 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10ca93:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  10ca99:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
  10ca9c:	89 d0                	mov    %edx,%eax                      
  10ca9e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10caa1:	5b                   	pop    %ebx                           
  10caa2:	5e                   	pop    %esi                           
  10caa3:	5f                   	pop    %edi                           
  10caa4:	c9                   	leave                                 
  10caa5:	c3                   	ret                                   
                                                                      

00106aa8 <IMFS_mount>: #include <rtems/seterr.h> int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
  106aa8:	55                   	push   %ebp                           
  106aa9:	89 e5                	mov    %esp,%ebp                      
  106aab:	83 ec 08             	sub    $0x8,%esp                      
  106aae:	8b 55 08             	mov    0x8(%ebp),%edx                 
  IMFS_jnode_t  *node;                                                
                                                                      
  node = mt_entry->mt_point_node.node_access;                         
  106ab1:	8b 42 08             	mov    0x8(%edx),%eax                 
                                                                      
  /*                                                                  
   *  Is the node that we are mounting onto a directory node ?        
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
  106ab4:	83 78 4c 01          	cmpl   $0x1,0x4c(%eax)                
  106ab8:	74 10                	je     106aca <IMFS_mount+0x22>       <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  106aba:	e8 21 a5 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106abf:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   <== NOT EXECUTED
  106ac5:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  106ac8:	eb 05                	jmp    106acf <IMFS_mount+0x27>       <== NOT EXECUTED
  /*                                                                  
   *  Set mt_fs pointer to point to the mount table entry for         
   *  the mounted file system.                                        
   */                                                                 
                                                                      
  node->info.directory.mt_fs = mt_entry;                              
  106aca:	89 50 5c             	mov    %edx,0x5c(%eax)                
  106acd:	31 c0                	xor    %eax,%eax                      
  return 0;                                                           
}                                                                     
  106acf:	c9                   	leave                                 
  106ad0:	c3                   	ret                                   
                                                                      

00107836 <IMFS_print_jnode>: */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) {
  107836:	55                   	push   %ebp                           
  107837:	89 e5                	mov    %esp,%ebp                      
  107839:	53                   	push   %ebx                           
  10783a:	83 ec 04             	sub    $0x4,%esp                      
  10783d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  assert( the_jnode );                                                
  107840:	85 db                	test   %ebx,%ebx                      
  107842:	75 11                	jne    107855 <IMFS_print_jnode+0x1f> <== ALWAYS TAKEN
  107844:	68 82 cb 11 00       	push   $0x11cb82                      <== NOT EXECUTED
  107849:	68 28 cd 11 00       	push   $0x11cd28                      <== NOT EXECUTED
  10784e:	6a 38                	push   $0x38                          <== NOT EXECUTED
  107850:	e9 98 00 00 00       	jmp    1078ed <IMFS_print_jnode+0xb7> <== NOT EXECUTED
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
  107855:	50                   	push   %eax                           
  107856:	50                   	push   %eax                           
  107857:	a1 80 14 12 00       	mov    0x121480,%eax                  
  10785c:	ff 70 08             	pushl  0x8(%eax)                      
  10785f:	8d 43 0c             	lea    0xc(%ebx),%eax                 
  107862:	50                   	push   %eax                           
  107863:	e8 ec b3 00 00       	call   112c54 <fputs>                 
  switch( the_jnode->type ) {                                         
  107868:	8b 43 4c             	mov    0x4c(%ebx),%eax                
  10786b:	83 c4 10             	add    $0x10,%esp                     
  10786e:	8d 50 ff             	lea    -0x1(%eax),%edx                
  107871:	83 fa 05             	cmp    $0x5,%edx                      
  107874:	0f 87 9a 00 00 00    	ja     107914 <IMFS_print_jnode+0xde> <== NEVER TAKEN
  10787a:	a1 80 14 12 00       	mov    0x121480,%eax                  
  10787f:	ff 24 95 fc cc 11 00 	jmp    *0x11ccfc(,%edx,4)             
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
  107886:	51                   	push   %ecx                           
  107887:	51                   	push   %ecx                           
  107888:	ff 70 08             	pushl  0x8(%eax)                      
  10788b:	6a 2f                	push   $0x2f                          
  10788d:	e8 f2 b2 00 00       	call   112b84 <fputc>                 
  107892:	eb 2b                	jmp    1078bf <IMFS_print_jnode+0x89> 
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
  107894:	ff 73 54             	pushl  0x54(%ebx)                     
  107897:	ff 73 50             	pushl  0x50(%ebx)                     
  10789a:	68 db cb 11 00       	push   $0x11cbdb                      
  10789f:	eb 16                	jmp    1078b7 <IMFS_print_jnode+0x81> 
        the_jnode->info.device.major, the_jnode->info.device.minor ); 
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      fprintf(stdout, " (file %" PRId32 " %p)",                       
  1078a1:	ff 73 54             	pushl  0x54(%ebx)                     <== NOT EXECUTED
  1078a4:	ff 73 50             	pushl  0x50(%ebx)                     <== NOT EXECUTED
  1078a7:	68 ee cb 11 00       	push   $0x11cbee                      <== NOT EXECUTED
  1078ac:	eb 09                	jmp    1078b7 <IMFS_print_jnode+0x81> <== NOT EXECUTED
        the_jnode->info.file.indirect,                                
        the_jnode->info.file.doubly_indirect,                         
        the_jnode->info.file.triply_indirect                          
      );                                                              
#else                                                                 
      fprintf(stdout, " (file %" PRId32 ")",                          
  1078ae:	52                   	push   %edx                           
  1078af:	ff 73 50             	pushl  0x50(%ebx)                     
  1078b2:	68 fd cb 11 00       	push   $0x11cbfd                      
  1078b7:	ff 70 08             	pushl  0x8(%eax)                      
  1078ba:	e8 89 b2 00 00       	call   112b48 <fprintf>               
  1078bf:	83 c4 10             	add    $0x10,%esp                     
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      assert(0);                                                      
      break;                                                          
  }                                                                   
  puts("");                                                           
  1078c2:	c7 45 08 99 ce 11 00 	movl   $0x11ce99,0x8(%ebp)            
}                                                                     
  1078c9:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  1078cc:	c9                   	leave                                 
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      assert(0);                                                      
      break;                                                          
  }                                                                   
  puts("");                                                           
  1078cd:	e9 5e c9 00 00       	jmp    114230 <puts>                  
        (uint32_t)the_jnode->info.file.size );                        
#endif                                                                
      break;                                                          
                                                                      
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
  1078d2:	53                   	push   %ebx                           <== NOT EXECUTED
  1078d3:	53                   	push   %ebx                           <== NOT EXECUTED
  1078d4:	ff 70 08             	pushl  0x8(%eax)                      <== NOT EXECUTED
  1078d7:	68 09 cc 11 00       	push   $0x11cc09                      <== NOT EXECUTED
  1078dc:	e8 73 b3 00 00       	call   112c54 <fputs>                 <== NOT EXECUTED
      assert(0);                                                      
  1078e1:	68 6f c5 11 00       	push   $0x11c56f                      <== NOT EXECUTED
  1078e6:	68 28 cd 11 00       	push   $0x11cd28                      <== NOT EXECUTED
  1078eb:	6a 5d                	push   $0x5d                          <== NOT EXECUTED
  1078ed:	68 8c cb 11 00       	push   $0x11cb8c                      <== NOT EXECUTED
  1078f2:	e8 55 06 00 00       	call   107f4c <__assert_func>         <== NOT EXECUTED
      break;                                                          
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
  1078f7:	51                   	push   %ecx                           <== NOT EXECUTED
  1078f8:	51                   	push   %ecx                           <== NOT EXECUTED
  1078f9:	ff 70 08             	pushl  0x8(%eax)                      <== NOT EXECUTED
  1078fc:	68 09 cc 11 00       	push   $0x11cc09                      <== NOT EXECUTED
  107901:	e8 4e b3 00 00       	call   112c54 <fputs>                 <== NOT EXECUTED
      assert(0);                                                      
  107906:	68 6f c5 11 00       	push   $0x11c56f                      <== NOT EXECUTED
  10790b:	68 28 cd 11 00       	push   $0x11cd28                      <== NOT EXECUTED
  107910:	6a 62                	push   $0x62                          <== NOT EXECUTED
  107912:	eb d9                	jmp    1078ed <IMFS_print_jnode+0xb7> <== NOT EXECUTED
      break;                                                          
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
  107914:	52                   	push   %edx                           <== NOT EXECUTED
  107915:	50                   	push   %eax                           <== NOT EXECUTED
  107916:	68 1d cc 11 00       	push   $0x11cc1d                      <== NOT EXECUTED
  10791b:	a1 80 14 12 00       	mov    0x121480,%eax                  <== NOT EXECUTED
  107920:	ff 70 08             	pushl  0x8(%eax)                      <== NOT EXECUTED
  107923:	e8 20 b2 00 00       	call   112b48 <fprintf>               <== NOT EXECUTED
      assert(0);                                                      
  107928:	68 6f c5 11 00       	push   $0x11c56f                      <== NOT EXECUTED
  10792d:	68 28 cd 11 00       	push   $0x11cd28                      <== NOT EXECUTED
  107932:	6a 67                	push   $0x67                          <== NOT EXECUTED
  107934:	eb b7                	jmp    1078ed <IMFS_print_jnode+0xb7> <== NOT EXECUTED
                                                                      

00106ae4 <IMFS_readlink>: int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) {
  106ae4:	55                   	push   %ebp                           
  106ae5:	89 e5                	mov    %esp,%ebp                      
  106ae7:	53                   	push   %ebx                           
  106ae8:	83 ec 04             	sub    $0x4,%esp                      
  106aeb:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  IMFS_jnode_t      *node;                                            
  int                i;                                               
                                                                      
  node = loc->node_access;                                            
  106aee:	8b 45 08             	mov    0x8(%ebp),%eax                 
  106af1:	8b 08                	mov    (%eax),%ecx                    
                                                                      
  if ( node->type != IMFS_SYM_LINK )                                  
  106af3:	31 d2                	xor    %edx,%edx                      
  106af5:	83 79 4c 04          	cmpl   $0x4,0x4c(%ecx)                
  106af9:	74 14                	je     106b0f <IMFS_readlink+0x2b>    <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  106afb:	e8 e0 a4 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106b00:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  106b06:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  106b09:	eb 13                	jmp    106b1e <IMFS_readlink+0x3a>    <== NOT EXECUTED
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
    buf[i] = node->info.sym_link.name[i];                             
  106b0b:	88 04 13             	mov    %al,(%ebx,%edx,1)              
  node = loc->node_access;                                            
                                                                      
  if ( node->type != IMFS_SYM_LINK )                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
  106b0e:	42                   	inc    %edx                           
  106b0f:	3b 55 10             	cmp    0x10(%ebp),%edx                
  106b12:	73 0a                	jae    106b1e <IMFS_readlink+0x3a>    
  106b14:	8b 41 50             	mov    0x50(%ecx),%eax                
  106b17:	8a 04 10             	mov    (%eax,%edx,1),%al              
  106b1a:	84 c0                	test   %al,%al                        
  106b1c:	75 ed                	jne    106b0b <IMFS_readlink+0x27>    
    buf[i] = node->info.sym_link.name[i];                             
                                                                      
  return i;                                                           
}                                                                     
  106b1e:	89 d0                	mov    %edx,%eax                      
  106b20:	5a                   	pop    %edx                           
  106b21:	5b                   	pop    %ebx                           
  106b22:	c9                   	leave                                 
  106b23:	c3                   	ret                                   
                                                                      

0010cab8 <IMFS_rmnod>: */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) {
  10cab8:	55                   	push   %ebp                           
  10cab9:	89 e5                	mov    %esp,%ebp                      
  10cabb:	56                   	push   %esi                           
  10cabc:	53                   	push   %ebx                           
  10cabd:	83 ec 10             	sub    $0x10,%esp                     
  10cac0:	8b 75 08             	mov    0x8(%ebp),%esi                 
  IMFS_jnode_t *the_jnode;                                            
                                                                      
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;                  
  10cac3:	8b 1e                	mov    (%esi),%ebx                    
                                                                      
  /*                                                                  
   * Take the node out of the parent's chain that contains this node  
   */                                                                 
                                                                      
  if ( the_jnode->Parent != NULL ) {                                  
  10cac5:	83 7b 08 00          	cmpl   $0x0,0x8(%ebx)                 
  10cac9:	74 13                	je     10cade <IMFS_rmnod+0x26>       <== NEVER TAKEN
  10cacb:	83 ec 0c             	sub    $0xc,%esp                      
  10cace:	53                   	push   %ebx                           
  10cacf:	e8 70 12 00 00       	call   10dd44 <_Chain_Extract>        
    rtems_chain_extract( (rtems_chain_node *) the_jnode );            
    the_jnode->Parent = NULL;                                         
  10cad4:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)                 
  10cadb:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   * Decrement the link counter and see if we can free the space.     
   */                                                                 
                                                                      
  the_jnode->st_nlink--;                                              
  10cade:	66 ff 4b 34          	decw   0x34(%ebx)                     
  IMFS_update_ctime( the_jnode );                                     
  10cae2:	50                   	push   %eax                           
  10cae3:	50                   	push   %eax                           
  10cae4:	6a 00                	push   $0x0                           
  10cae6:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10cae9:	50                   	push   %eax                           
  10caea:	e8 65 03 00 00       	call   10ce54 <gettimeofday>          
  10caef:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10caf2:	89 43 48             	mov    %eax,0x48(%ebx)                
                                                                      
  /*                                                                  
   * The file cannot be open and the link must be less than 1 to free.
   */                                                                 
                                                                      
  if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
  10caf5:	89 1c 24             	mov    %ebx,(%esp)                    
  10caf8:	e8 07 04 00 00       	call   10cf04 <rtems_libio_is_file_open>
  10cafd:	83 c4 10             	add    $0x10,%esp                     
  10cb00:	85 c0                	test   %eax,%eax                      
  10cb02:	75 40                	jne    10cb44 <IMFS_rmnod+0x8c>       <== NEVER TAKEN
  10cb04:	66 83 7b 34 00       	cmpw   $0x0,0x34(%ebx)                
  10cb09:	75 39                	jne    10cb44 <IMFS_rmnod+0x8c>       <== NEVER TAKEN
                                                                      
    /*                                                                
     * Is rtems_filesystem_current this node?                         
     */                                                               
                                                                      
    if ( rtems_filesystem_current.node_access == pathloc->node_access )
  10cb0b:	8b 15 6c b6 11 00    	mov    0x11b66c,%edx                  
  10cb11:	8b 42 04             	mov    0x4(%edx),%eax                 
  10cb14:	3b 06                	cmp    (%esi),%eax                    
  10cb16:	75 07                	jne    10cb1f <IMFS_rmnod+0x67>       <== ALWAYS TAKEN
       rtems_filesystem_current.node_access = NULL;                   
  10cb18:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * Free memory associated with a memory file.                     
     */                                                               
                                                                      
    if ( the_jnode->type == IMFS_SYM_LINK ) {                         
  10cb1f:	83 7b 4c 04          	cmpl   $0x4,0x4c(%ebx)                
  10cb23:	75 13                	jne    10cb38 <IMFS_rmnod+0x80>       
      if ( the_jnode->info.sym_link.name )                            
  10cb25:	8b 43 50             	mov    0x50(%ebx),%eax                
  10cb28:	85 c0                	test   %eax,%eax                      
  10cb2a:	74 0c                	je     10cb38 <IMFS_rmnod+0x80>       <== NEVER TAKEN
        free( (void*) the_jnode->info.sym_link.name );                
  10cb2c:	83 ec 0c             	sub    $0xc,%esp                      
  10cb2f:	50                   	push   %eax                           
  10cb30:	e8 43 99 ff ff       	call   106478 <free>                  
  10cb35:	83 c4 10             	add    $0x10,%esp                     
    }                                                                 
    free( the_jnode );                                                
  10cb38:	83 ec 0c             	sub    $0xc,%esp                      
  10cb3b:	53                   	push   %ebx                           
  10cb3c:	e8 37 99 ff ff       	call   106478 <free>                  
  10cb41:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  return 0;                                                           
                                                                      
}                                                                     
  10cb44:	31 c0                	xor    %eax,%eax                      
  10cb46:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10cb49:	5b                   	pop    %ebx                           
  10cb4a:	5e                   	pop    %esi                           
  10cb4b:	c9                   	leave                                 
  10cb4c:	c3                   	ret                                   
                                                                      

0010cb50 <IMFS_stat>: int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) {
  10cb50:	55                   	push   %ebp                           
  10cb51:	89 e5                	mov    %esp,%ebp                      
  10cb53:	53                   	push   %ebx                           
  10cb54:	83 ec 04             	sub    $0x4,%esp                      
  10cb57:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  IMFS_jnode_t   *the_jnode;                                          
  IMFS_device_t  *io;                                                 
                                                                      
  the_jnode = loc->node_access;                                       
  10cb5a:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10cb5d:	8b 08                	mov    (%eax),%ecx                    
                                                                      
                                                                      
  switch ( the_jnode->type ) {                                        
  10cb5f:	8b 41 4c             	mov    0x4c(%ecx),%eax                
  10cb62:	83 f8 04             	cmp    $0x4,%eax                      
  10cb65:	74 25                	je     10cb8c <IMFS_stat+0x3c>        <== NEVER TAKEN
  10cb67:	7f 07                	jg     10cb70 <IMFS_stat+0x20>        
  10cb69:	83 f8 02             	cmp    $0x2,%eax                      
  10cb6c:	75 27                	jne    10cb95 <IMFS_stat+0x45>        <== NEVER TAKEN
  10cb6e:	eb 07                	jmp    10cb77 <IMFS_stat+0x27>        
  10cb70:	83 f8 06             	cmp    $0x6,%eax                      
  10cb73:	7f 20                	jg     10cb95 <IMFS_stat+0x45>        <== NEVER TAKEN
  10cb75:	eb 0d                	jmp    10cb84 <IMFS_stat+0x34>        
                                                                      
    case IMFS_DEVICE:                                                 
      io          = &the_jnode->info.device;                          
      buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
  10cb77:	8b 51 54             	mov    0x54(%ecx),%edx                
  10cb7a:	8b 41 50             	mov    0x50(%ecx),%eax                
  10cb7d:	89 03                	mov    %eax,(%ebx)                    
  10cb7f:	89 53 04             	mov    %edx,0x4(%ebx)                 
  10cb82:	eb 21                	jmp    10cba5 <IMFS_stat+0x55>        
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
    case IMFS_MEMORY_FILE:                                            
      buf->st_size = the_jnode->info.file.size;                       
  10cb84:	8b 41 50             	mov    0x50(%ecx),%eax                
  10cb87:	89 43 20             	mov    %eax,0x20(%ebx)                
  10cb8a:	eb 19                	jmp    10cba5 <IMFS_stat+0x55>        
      break;                                                          
                                                                      
    case IMFS_SYM_LINK:                                               
      buf->st_size = 0;                                               
  10cb8c:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)                <== NOT EXECUTED
  10cb93:	eb 10                	jmp    10cba5 <IMFS_stat+0x55>        <== NOT EXECUTED
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( ENOTSUP );                
  10cb95:	e8 8e 25 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10cb9a:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10cba0:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10cba3:	eb 3e                	jmp    10cbe3 <IMFS_stat+0x93>        <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  10cba5:	8b 41 30             	mov    0x30(%ecx),%eax                
  10cba8:	89 43 0c             	mov    %eax,0xc(%ebx)                 
  buf->st_nlink = the_jnode->st_nlink;                                
  10cbab:	8b 41 34             	mov    0x34(%ecx),%eax                
  10cbae:	66 89 43 10          	mov    %ax,0x10(%ebx)                 
  buf->st_ino   = the_jnode->st_ino;                                  
  10cbb2:	8b 41 38             	mov    0x38(%ecx),%eax                
  10cbb5:	89 43 08             	mov    %eax,0x8(%ebx)                 
  buf->st_uid   = the_jnode->st_uid;                                  
  10cbb8:	8b 41 3c             	mov    0x3c(%ecx),%eax                
  10cbbb:	66 89 43 12          	mov    %ax,0x12(%ebx)                 
  buf->st_gid   = the_jnode->st_gid;                                  
  10cbbf:	66 8b 41 3e          	mov    0x3e(%ecx),%ax                 
  10cbc3:	66 89 43 14          	mov    %ax,0x14(%ebx)                 
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  10cbc7:	8b 41 40             	mov    0x40(%ecx),%eax                
  10cbca:	89 43 24             	mov    %eax,0x24(%ebx)                
  buf->st_mtime = the_jnode->stat_mtime;                              
  10cbcd:	8b 41 44             	mov    0x44(%ecx),%eax                
  10cbd0:	89 43 2c             	mov    %eax,0x2c(%ebx)                
  buf->st_ctime = the_jnode->stat_ctime;                              
  10cbd3:	8b 41 48             	mov    0x48(%ecx),%eax                
  10cbd6:	89 43 34             	mov    %eax,0x34(%ebx)                
                                                                      
  buf->st_blksize = imfs_rq_memfile_bytes_per_block;                  
  10cbd9:	a1 dc 92 11 00       	mov    0x1192dc,%eax                  
  10cbde:	89 43 3c             	mov    %eax,0x3c(%ebx)                
  10cbe1:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  10cbe3:	5a                   	pop    %edx                           
  10cbe4:	5b                   	pop    %ebx                           
  10cbe5:	c9                   	leave                                 
  10cbe6:	c3                   	ret                                   
                                                                      

00106b24 <IMFS_symlink>: int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) {
  106b24:	55                   	push   %ebp                           
  106b25:	89 e5                	mov    %esp,%ebp                      
  106b27:	53                   	push   %ebx                           
  106b28:	83 ec 48             	sub    $0x48,%esp                     
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
                                                                      
  IMFS_get_token( node_name, new_name, &i );                          
  106b2b:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  106b2e:	50                   	push   %eax                           
  106b2f:	8d 5d c7             	lea    -0x39(%ebp),%ebx               
  106b32:	53                   	push   %ebx                           
  106b33:	ff 75 10             	pushl  0x10(%ebp)                     
  106b36:	e8 69 74 00 00       	call   10dfa4 <IMFS_get_token>        
                                                                      
  /*                                                                  
   * Duplicate link name                                              
   */                                                                 
                                                                      
  info.sym_link.name = strdup( link_name);                            
  106b3b:	58                   	pop    %eax                           
  106b3c:	ff 75 0c             	pushl  0xc(%ebp)                      
  106b3f:	e8 fc bf 00 00       	call   112b40 <strdup>                
  106b44:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  if (info.sym_link.name == NULL) {                                   
  106b47:	83 c4 10             	add    $0x10,%esp                     
  106b4a:	85 c0                	test   %eax,%eax                      
  106b4c:	75 10                	jne    106b5e <IMFS_symlink+0x3a>     <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOMEM);                    
  106b4e:	e8 8d a4 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106b53:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  106b59:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  106b5c:	eb 3c                	jmp    106b9a <IMFS_symlink+0x76>     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Create a new link node.                                         
   */                                                                 
                                                                      
  new_node = IMFS_create_node(                                        
  106b5e:	83 ec 0c             	sub    $0xc,%esp                      
  106b61:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  106b64:	50                   	push   %eax                           
  106b65:	68 ff a1 00 00       	push   $0xa1ff                        
  106b6a:	53                   	push   %ebx                           
  106b6b:	6a 04                	push   $0x4                           
  106b6d:	ff 75 08             	pushl  0x8(%ebp)                      
  106b70:	e8 ff 6b 00 00       	call   10d774 <IMFS_create_node>      
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if (new_node == NULL) {                                             
  106b75:	83 c4 20             	add    $0x20,%esp                     
  106b78:	31 d2                	xor    %edx,%edx                      
  106b7a:	85 c0                	test   %eax,%eax                      
  106b7c:	75 1c                	jne    106b9a <IMFS_symlink+0x76>     <== ALWAYS TAKEN
    free( info.sym_link.name);                                        
  106b7e:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106b81:	ff 75 e8             	pushl  -0x18(%ebp)                    <== NOT EXECUTED
  106b84:	e8 6f 07 00 00       	call   1072f8 <free>                  <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOMEM);                    
  106b89:	e8 52 a4 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106b8e:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  106b94:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  106b97:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  106b9a:	89 d0                	mov    %edx,%eax                      
  106b9c:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  106b9f:	c9                   	leave                                 
  106ba0:	c3                   	ret                                   
                                                                      

00106ba4 <IMFS_unlink>: #include <rtems/seterr.h> int IMFS_unlink( rtems_filesystem_location_info_t *loc /* IN */ ) {
  106ba4:	55                   	push   %ebp                           
  106ba5:	89 e5                	mov    %esp,%ebp                      
  106ba7:	57                   	push   %edi                           
  106ba8:	56                   	push   %esi                           
  106ba9:	53                   	push   %ebx                           
  106baa:	83 ec 2c             	sub    $0x2c,%esp                     
  IMFS_jnode_t                      *node;                            
  rtems_filesystem_location_info_t   the_link;                        
  int                                result = 0;                      
                                                                      
  node = loc->node_access;                                            
  106bad:	8b 45 08             	mov    0x8(%ebp),%eax                 
  106bb0:	8b 18                	mov    (%eax),%ebx                    
  /*                                                                  
   * If this is the last last pointer to the node                     
   * free the node.                                                   
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
  106bb2:	83 7b 4c 03          	cmpl   $0x3,0x4c(%ebx)                
  106bb6:	75 76                	jne    106c2e <IMFS_unlink+0x8a>      
                                                                      
    if ( !node->info.hard_link.link_node )                            
  106bb8:	8b 43 50             	mov    0x50(%ebx),%eax                
  106bbb:	85 c0                	test   %eax,%eax                      
  106bbd:	75 10                	jne    106bcf <IMFS_unlink+0x2b>      <== ALWAYS TAKEN
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  106bbf:	e8 1c a4 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106bc4:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  106bca:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  106bcd:	eb 71                	jmp    106c40 <IMFS_unlink+0x9c>      <== NOT EXECUTED
                                                                      
    the_link = *loc;                                                  
  106bcf:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  106bd2:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  106bd7:	8b 75 08             	mov    0x8(%ebp),%esi                 
  106bda:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
    the_link.node_access = node->info.hard_link.link_node;            
  106bdc:	89 45 dc             	mov    %eax,-0x24(%ebp)               
    IMFS_Set_handlers( &the_link );                                   
  106bdf:	83 ec 0c             	sub    $0xc,%esp                      
  106be2:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  106be5:	57                   	push   %edi                           
  106be6:	e8 c5 6c 00 00       	call   10d8b0 <IMFS_Set_handlers>     
    /*                                                                
     *  If removing the last hard link to a node, then we need        
     *  to remove the node that is a link and the node itself.        
     */                                                               
                                                                      
    if ( node->info.hard_link.link_node->st_nlink == 1)               
  106beb:	8b 53 50             	mov    0x50(%ebx),%edx                
  106bee:	8b 42 34             	mov    0x34(%edx),%eax                
  106bf1:	83 c4 10             	add    $0x10,%esp                     
  106bf4:	66 83 f8 01          	cmp    $0x1,%ax                       
  106bf8:	75 16                	jne    106c10 <IMFS_unlink+0x6c>      
    {                                                                 
        result = (*the_link.handlers->rmnod_h)( &the_link );          
  106bfa:	83 ec 0c             	sub    $0xc,%esp                      
  106bfd:	57                   	push   %edi                           
  106bfe:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  106c01:	ff 50 34             	call   *0x34(%eax)                    
        if ( result != 0 )                                            
  106c04:	83 c4 10             	add    $0x10,%esp                     
  106c07:	83 ca ff             	or     $0xffffffff,%edx               
  106c0a:	85 c0                	test   %eax,%eax                      
  106c0c:	74 20                	je     106c2e <IMFS_unlink+0x8a>      
  106c0e:	eb 30                	jmp    106c40 <IMFS_unlink+0x9c>      
            return -1;                                                
    }                                                                 
    else                                                              
    {                                                                 
        node->info.hard_link.link_node->st_nlink --;                  
  106c10:	48                   	dec    %eax                           
  106c11:	66 89 42 34          	mov    %ax,0x34(%edx)                 
        IMFS_update_ctime( node->info.hard_link.link_node );          
  106c15:	50                   	push   %eax                           
  106c16:	50                   	push   %eax                           
  106c17:	6a 00                	push   $0x0                           
  106c19:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  106c1c:	50                   	push   %eax                           
  106c1d:	e8 46 08 00 00       	call   107468 <gettimeofday>          
  106c22:	8b 53 50             	mov    0x50(%ebx),%edx                
  106c25:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  106c28:	89 42 48             	mov    %eax,0x48(%edx)                
  106c2b:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Now actually free the node we were asked to free.               
   */                                                                 
                                                                      
  result = (*loc->handlers->rmnod_h)( loc );                          
  106c2e:	83 ec 0c             	sub    $0xc,%esp                      
  106c31:	8b 55 08             	mov    0x8(%ebp),%edx                 
  106c34:	8b 42 04             	mov    0x4(%edx),%eax                 
  106c37:	52                   	push   %edx                           
  106c38:	ff 50 34             	call   *0x34(%eax)                    
  106c3b:	89 c2                	mov    %eax,%edx                      
  106c3d:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  106c40:	89 d0                	mov    %edx,%eax                      
  106c42:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106c45:	5b                   	pop    %ebx                           
  106c46:	5e                   	pop    %esi                           
  106c47:	5f                   	pop    %edi                           
  106c48:	c9                   	leave                                 
  106c49:	c3                   	ret                                   
                                                                      

00106c4c <IMFS_unmount>: #include <rtems/seterr.h> int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
  106c4c:	55                   	push   %ebp                           
  106c4d:	89 e5                	mov    %esp,%ebp                      
  106c4f:	83 ec 08             	sub    $0x8,%esp                      
  IMFS_jnode_t  *node;                                                
                                                                      
  node = mt_entry->mt_point_node.node_access;                         
  106c52:	8b 45 08             	mov    0x8(%ebp),%eax                 
  106c55:	8b 40 08             	mov    0x8(%eax),%eax                 
                                                                      
  /*                                                                  
   * Is the node that we are mounting onto a directory node ?         
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
  106c58:	83 78 4c 01          	cmpl   $0x1,0x4c(%eax)                
  106c5c:	74 0d                	je     106c6b <IMFS_unmount+0x1f>     <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  106c5e:	e8 7d a3 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106c63:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   <== NOT EXECUTED
  106c69:	eb 11                	jmp    106c7c <IMFS_unmount+0x30>     <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Did the node indicate that there was a directory mounted here?   
   */                                                                 
                                                                      
  if ( node->info.directory.mt_fs == NULL )                           
  106c6b:	83 78 5c 00          	cmpl   $0x0,0x5c(%eax)                
  106c6f:	75 10                	jne    106c81 <IMFS_unmount+0x35>     <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );  /* XXX */        
  106c71:	e8 6a a3 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  106c76:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  106c7c:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  106c7f:	eb 09                	jmp    106c8a <IMFS_unmount+0x3e>     <== NOT EXECUTED
  /*                                                                  
   * Set the mt_fs pointer to indicate that there is no longer        
   * a file system mounted to this point.                             
   */                                                                 
                                                                      
  node->info.directory.mt_fs = NULL;                                  
  106c81:	c7 40 5c 00 00 00 00 	movl   $0x0,0x5c(%eax)                
  106c88:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  106c8a:	c9                   	leave                                 
  106c8b:	c3                   	ret                                   
                                                                      

001065fc <RTEMS_Malloc_Initialize>: void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) {
  1065fc:	55                   	push   %ebp                           
  1065fd:	89 e5                	mov    %esp,%ebp                      
  1065ff:	57                   	push   %edi                           
  106600:	56                   	push   %esi                           
  106601:	53                   	push   %ebx                           
  106602:	83 ec 0c             	sub    $0xc,%esp                      
  106605:	8b 75 08             	mov    0x8(%ebp),%esi                 
  106608:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  #endif                                                              
                                                                      
  /*                                                                  
   *  If configured, initialize the statistics support                
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
  10660b:	a1 d4 bb 11 00       	mov    0x11bbd4,%eax                  
  106610:	85 c0                	test   %eax,%eax                      
  106612:	74 02                	je     106616 <RTEMS_Malloc_Initialize+0x1a><== ALWAYS TAKEN
    (*rtems_malloc_statistics_helpers->initialize)();                 
  106614:	ff 10                	call   *(%eax)                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize the garbage collection list to start with nothing on it.
   */                                                                 
  malloc_deferred_frees_initialize();                                 
  106616:	e8 79 ff ff ff       	call   106594 <malloc_deferred_frees_initialize>
  starting_address = start;                                           
                                                                      
  /*                                                                  
   *  Initialize the optional sbrk support for extending the heap     
   */                                                                 
  if (rtems_malloc_sbrk_helpers) {                                    
  10661b:	a1 d8 bb 11 00       	mov    0x11bbd8,%eax                  
  106620:	89 f2                	mov    %esi,%edx                      
  106622:	85 c0                	test   %eax,%eax                      
  106624:	74 0d                	je     106633 <RTEMS_Malloc_Initialize+0x37><== ALWAYS TAKEN
    starting_address = (*rtems_malloc_sbrk_helpers->initialize)(      
  106626:	52                   	push   %edx                           <== NOT EXECUTED
  106627:	52                   	push   %edx                           <== NOT EXECUTED
  106628:	ff 75 10             	pushl  0x10(%ebp)                     <== NOT EXECUTED
  10662b:	56                   	push   %esi                           <== NOT EXECUTED
  10662c:	ff 10                	call   *(%eax)                        <== NOT EXECUTED
  10662e:	89 c2                	mov    %eax,%edx                      <== NOT EXECUTED
  106630:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
   *  of the time under UNIX because zero'ing memory when it is first 
   *  given to a process eliminates the chance of a process seeing data
   *  left over from another process.  This would be a security violation.
   */                                                                 
                                                                      
  if ( rtems_configuration_get_do_zero_of_workspace() )               
  106633:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  106638:	80 78 28 00          	cmpb   $0x0,0x28(%eax)                
  10663c:	74 08                	je     106646 <RTEMS_Malloc_Initialize+0x4a><== ALWAYS TAKEN
     memset( starting_address, 0, length );                           
  10663e:	31 c0                	xor    %eax,%eax                      
  106640:	89 d7                	mov    %edx,%edi                      <== NOT EXECUTED
  106642:	89 d9                	mov    %ebx,%ecx                      <== NOT EXECUTED
  106644:	f3 aa                	rep stos %al,%es:(%edi)               <== NOT EXECUTED
  void         *starting_address,                                     
  size_t        size,                                                 
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
  106646:	6a 04                	push   $0x4                           
  106648:	53                   	push   %ebx                           
  106649:	52                   	push   %edx                           
  10664a:	68 50 d6 11 00       	push   $0x11d650                      
  10664f:	e8 d8 39 00 00       	call   10a02c <_Heap_Initialize>      
    &RTEMS_Malloc_Heap,                                               
    starting_address,                                                 
    length,                                                           
    CPU_HEAP_ALIGNMENT                                                
  );                                                                  
  if ( !status )                                                      
  106654:	83 c4 10             	add    $0x10,%esp                     
  106657:	85 c0                	test   %eax,%eax                      
  106659:	75 0a                	jne    106665 <RTEMS_Malloc_Initialize+0x69><== ALWAYS TAKEN
    rtems_fatal_error_occurred( status );                             
  10665b:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10665e:	6a 00                	push   $0x0                           <== NOT EXECUTED
  106660:	e8 2f 31 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
      rtems_print_buffer( (start + length) - 48, 48 );                
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
    }                                                                 
  #endif                                                              
                                                                      
  MSBUMP(space_available, length);                                    
  106665:	01 1d a8 d6 11 00    	add    %ebx,0x11d6a8                  
}                                                                     
  10666b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10666e:	5b                   	pop    %ebx                           
  10666f:	5e                   	pop    %esi                           
  106670:	5f                   	pop    %edi                           
  106671:	c9                   	leave                                 
  106672:	c3                   	ret                                   
                                                                      

0010674a <Stack_check_Dump_threads_usage>: static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) {
  10674a:	55                   	push   %ebp                           <== NOT EXECUTED
  10674b:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10674d:	57                   	push   %edi                           <== NOT EXECUTED
  10674e:	56                   	push   %esi                           <== NOT EXECUTED
  10674f:	53                   	push   %ebx                           <== NOT EXECUTED
  106750:	83 ec 2c             	sub    $0x2c,%esp                     <== NOT EXECUTED
  106753:	8b 5d 08             	mov    0x8(%ebp),%ebx                 <== NOT EXECUTED
  void           *high_water_mark;                                    
  void           *current;                                            
  Stack_Control  *stack;                                              
  char            name[5];                                            
                                                                      
  if ( !the_thread )                                                  
  106756:	85 db                	test   %ebx,%ebx                      <== NOT EXECUTED
  106758:	0f 84 fc 00 00 00    	je     10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
    return;                                                           
                                                                      
  if ( !print_handler )                                               
  10675e:	a1 f4 0d 12 00       	mov    0x120df4,%eax                  <== NOT EXECUTED
  106763:	89 45 d4             	mov    %eax,-0x2c(%ebp)               <== NOT EXECUTED
  106766:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  106768:	0f 84 ec 00 00 00    	je     10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Obtain interrupt stack information                              
   */                                                                 
                                                                      
  if (the_thread == (Thread_Control *) -1) {                          
  10676e:	83 fb ff             	cmp    $0xffffffff,%ebx               <== NOT EXECUTED
  106771:	75 1d                	jne    106790 <Stack_check_Dump_threads_usage+0x46><== NOT EXECUTED
    if (Stack_check_Interrupt_stack.area) {                           
  106773:	83 3d 1c 10 12 00 00 	cmpl   $0x0,0x12101c                  <== NOT EXECUTED
  10677a:	0f 84 da 00 00 00    	je     10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
      stack = &Stack_check_Interrupt_stack;                           
      the_thread = 0;                                                 
      current = 0;                                                    
    }                                                                 
    else                                                              
      return;                                                         
  106780:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  106782:	c7 45 e0 00 00 00 00 	movl   $0x0,-0x20(%ebp)               <== NOT EXECUTED
  106789:	be 18 10 12 00       	mov    $0x121018,%esi                 <== NOT EXECUTED
  10678e:	eb 0f                	jmp    10679f <Stack_check_Dump_threads_usage+0x55><== NOT EXECUTED
  } else {                                                            
    stack  = &the_thread->Start.Initial_stack;                        
  106790:	8d b3 c4 00 00 00    	lea    0xc4(%ebx),%esi                <== NOT EXECUTED
    current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );  
  106796:	8b 83 d8 00 00 00    	mov    0xd8(%ebx),%eax                <== NOT EXECUTED
  10679c:	89 45 e0             	mov    %eax,-0x20(%ebp)               <== NOT EXECUTED
  }                                                                   
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
  10679f:	8b 46 04             	mov    0x4(%esi),%eax                 <== NOT EXECUTED
  1067a2:	8d 78 10             	lea    0x10(%eax),%edi                <== NOT EXECUTED
  size = Stack_check_usable_stack_size(stack);                        
  1067a5:	8b 06                	mov    (%esi),%eax                    <== NOT EXECUTED
  1067a7:	83 e8 10             	sub    $0x10,%eax                     <== NOT EXECUTED
  1067aa:	89 45 d8             	mov    %eax,-0x28(%ebp)               <== NOT EXECUTED
                                                                      
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
  1067ad:	50                   	push   %eax                           <== NOT EXECUTED
  1067ae:	57                   	push   %edi                           <== NOT EXECUTED
  1067af:	e8 6b ff ff ff       	call   10671f <Stack_check_find_high_water_mark><== NOT EXECUTED
                                                                      
  if ( high_water_mark )                                              
  1067b4:	5a                   	pop    %edx                           <== NOT EXECUTED
  1067b5:	59                   	pop    %ecx                           <== NOT EXECUTED
  1067b6:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               <== NOT EXECUTED
  1067bd:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1067bf:	74 09                	je     1067ca <Stack_check_Dump_threads_usage+0x80><== NOT EXECUTED
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
  1067c1:	03 7d d8             	add    -0x28(%ebp),%edi               <== NOT EXECUTED
  1067c4:	89 7d dc             	mov    %edi,-0x24(%ebp)               <== NOT EXECUTED
  1067c7:	29 45 dc             	sub    %eax,-0x24(%ebp)               <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
  if ( the_thread ) {                                                 
  1067ca:	85 db                	test   %ebx,%ebx                      <== NOT EXECUTED
  1067cc:	74 26                	je     1067f4 <Stack_check_Dump_threads_usage+0xaa><== NOT EXECUTED
    (*print_handler)(                                                 
  1067ce:	50                   	push   %eax                           <== NOT EXECUTED
  1067cf:	8d 45 ef             	lea    -0x11(%ebp),%eax               <== NOT EXECUTED
  1067d2:	50                   	push   %eax                           <== NOT EXECUTED
  1067d3:	6a 05                	push   $0x5                           <== NOT EXECUTED
  1067d5:	ff 73 08             	pushl  0x8(%ebx)                      <== NOT EXECUTED
  1067d8:	e8 1f 34 00 00       	call   109bfc <rtems_object_get_name> <== NOT EXECUTED
  1067dd:	50                   	push   %eax                           <== NOT EXECUTED
  1067de:	ff 73 08             	pushl  0x8(%ebx)                      <== NOT EXECUTED
  1067e1:	68 d9 99 11 00       	push   $0x1199d9                      <== NOT EXECUTED
  1067e6:	ff 35 f0 0d 12 00    	pushl  0x120df0                       <== NOT EXECUTED
  1067ec:	ff 55 d4             	call   *-0x2c(%ebp)                   <== NOT EXECUTED
  1067ef:	83 c4 20             	add    $0x20,%esp                     <== NOT EXECUTED
  1067f2:	eb 14                	jmp    106808 <Stack_check_Dump_threads_usage+0xbe><== NOT EXECUTED
      "0x%08" PRIx32 "  %4s",                                         
      the_thread->Object.id,                                          
      rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
    );                                                                
  } else {                                                            
    (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );   
  1067f4:	57                   	push   %edi                           <== NOT EXECUTED
  1067f5:	6a ff                	push   $0xffffffff                    <== NOT EXECUTED
  1067f7:	68 e6 99 11 00       	push   $0x1199e6                      <== NOT EXECUTED
  1067fc:	ff 35 f0 0d 12 00    	pushl  0x120df0                       <== NOT EXECUTED
  106802:	ff 55 d4             	call   *-0x2c(%ebp)                   <== NOT EXECUTED
  106805:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  }                                                                   
                                                                      
  (*print_handler)(                                                   
  106808:	8b 46 04             	mov    0x4(%esi),%eax                 <== NOT EXECUTED
  10680b:	53                   	push   %ebx                           <== NOT EXECUTED
  10680c:	53                   	push   %ebx                           <== NOT EXECUTED
  10680d:	ff 75 d8             	pushl  -0x28(%ebp)                    <== NOT EXECUTED
  106810:	ff 75 e0             	pushl  -0x20(%ebp)                    <== NOT EXECUTED
  106813:	8b 16                	mov    (%esi),%edx                    <== NOT EXECUTED
  106815:	8d 54 10 ff          	lea    -0x1(%eax,%edx,1),%edx         <== NOT EXECUTED
  106819:	52                   	push   %edx                           <== NOT EXECUTED
  10681a:	50                   	push   %eax                           <== NOT EXECUTED
  10681b:	68 f4 99 11 00       	push   $0x1199f4                      <== NOT EXECUTED
  106820:	ff 35 f0 0d 12 00    	pushl  0x120df0                       <== NOT EXECUTED
  106826:	ff 15 f4 0d 12 00    	call   *0x120df4                      <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
  10682c:	83 c4 20             	add    $0x20,%esp                     <== NOT EXECUTED
  10682f:	83 3d ec 0d 12 00 00 	cmpl   $0x0,0x120dec                  <== NOT EXECUTED
  106836:	a1 f4 0d 12 00       	mov    0x120df4,%eax                  <== NOT EXECUTED
  10683b:	75 09                	jne    106846 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
  10683d:	51                   	push   %ecx                           <== NOT EXECUTED
  10683e:	51                   	push   %ecx                           <== NOT EXECUTED
  10683f:	68 12 9a 11 00       	push   $0x119a12                      <== NOT EXECUTED
  106844:	eb 09                	jmp    10684f <Stack_check_Dump_threads_usage+0x105><== NOT EXECUTED
  } else {                                                            
    (*print_handler)( print_context, "%8" PRId32 "\n", used );        
  106846:	52                   	push   %edx                           <== NOT EXECUTED
  106847:	ff 75 dc             	pushl  -0x24(%ebp)                    <== NOT EXECUTED
  10684a:	68 1f 9a 11 00       	push   $0x119a1f                      <== NOT EXECUTED
  10684f:	ff 35 f0 0d 12 00    	pushl  0x120df0                       <== NOT EXECUTED
  106855:	ff d0                	call   *%eax                          <== NOT EXECUTED
  106857:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  }                                                                   
                                                                      
                                                                      
}                                                                     
  10685a:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  10685d:	5b                   	pop    %ebx                           <== NOT EXECUTED
  10685e:	5e                   	pop    %esi                           <== NOT EXECUTED
  10685f:	5f                   	pop    %edi                           <== NOT EXECUTED
  106860:	c9                   	leave                                 <== NOT EXECUTED
  106861:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00106a13 <Stack_check_Initialize>: /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) {
  106a13:	55                   	push   %ebp                           
  106a14:	89 e5                	mov    %esp,%ebp                      
  106a16:	57                   	push   %edi                           
  106a17:	83 ec 04             	sub    $0x4,%esp                      
  uint32_t *p;                                                        
                                                                      
  if (Stack_check_Initialized)                                        
  106a1a:	83 3d ec 0d 12 00 00 	cmpl   $0x0,0x120dec                  
  106a21:	75 59                	jne    106a7c <Stack_check_Initialize+0x69>
                                                                      
  for ( p = Stack_check_Pattern.pattern;                              
        p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];         
        p += 4                                                        
      ) {                                                             
      p[0] = 0xFEEDF00D;          /* FEED FOOD to BAD DOG */          
  106a23:	c7 05 08 10 12 00 0d 	movl   $0xfeedf00d,0x121008           
  106a2a:	f0 ed fe                                                    
      p[1] = 0x0BAD0D06;                                              
  106a2d:	c7 05 0c 10 12 00 06 	movl   $0xbad0d06,0x12100c            
  106a34:	0d ad 0b                                                    
      p[2] = 0xDEADF00D;          /* DEAD FOOD GOOD DOG */            
  106a37:	c7 05 10 10 12 00 0d 	movl   $0xdeadf00d,0x121010           
  106a3e:	f0 ad de                                                    
      p[3] = 0x600D0D06;                                              
  106a41:	c7 05 14 10 12 00 06 	movl   $0x600d0d06,0x121014           
  106a48:	0d 0d 60                                                    
  /*                                                                  
   * 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) {      
  106a4b:	8b 3d 94 11 12 00    	mov    0x121194,%edi                  
  106a51:	85 ff                	test   %edi,%edi                      
  106a53:	74 1d                	je     106a72 <Stack_check_Initialize+0x5f><== NEVER TAKEN
  106a55:	a1 54 11 12 00       	mov    0x121154,%eax                  
  106a5a:	85 c0                	test   %eax,%eax                      
  106a5c:	74 14                	je     106a72 <Stack_check_Initialize+0x5f><== NEVER TAKEN
      Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;    
  106a5e:	89 3d 1c 10 12 00    	mov    %edi,0x12101c                  
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
  106a64:	89 c1                	mov    %eax,%ecx                      
  106a66:	29 f9                	sub    %edi,%ecx                      
  106a68:	89 0d 18 10 12 00    	mov    %ecx,0x121018                  
                                  (char *) _CPU_Interrupt_stack_low;  
      Stack_check_Dope_stack(&Stack_check_Interrupt_stack);           
  106a6e:	b0 a5                	mov    $0xa5,%al                      
  106a70:	f3 aa                	rep stos %al,%es:(%edi)               
  }                                                                   
  #endif                                                              
                                                                      
  Stack_check_Initialized = 1;                                        
  106a72:	c7 05 ec 0d 12 00 01 	movl   $0x1,0x120dec                  
  106a79:	00 00 00                                                    
}                                                                     
  106a7c:	58                   	pop    %eax                           
  106a7d:	5f                   	pop    %edi                           
  106a7e:	c9                   	leave                                 
  106a7f:	c3                   	ret                                   
                                                                      

0010671f <Stack_check_find_high_water_mark>: */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) {
  10671f:	55                   	push   %ebp                           <== NOT EXECUTED
  106720:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  106722:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
    /*                                                                
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
  106725:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  106728:	83 c2 10             	add    $0x10,%edx                     <== NOT EXECUTED
    for (ebase = base + length; base < ebase; base++)                 
  10672b:	83 e0 fc             	and    $0xfffffffc,%eax               <== NOT EXECUTED
  10672e:	8d 04 02             	lea    (%edx,%eax,1),%eax             <== NOT EXECUTED
  106731:	eb 0f                	jmp    106742 <Stack_check_find_high_water_mark+0x23><== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
  106733:	81 3a a5 a5 a5 a5    	cmpl   $0xa5a5a5a5,(%edx)             <== NOT EXECUTED
  106739:	74 04                	je     10673f <Stack_check_find_high_water_mark+0x20><== NOT EXECUTED
        return (void *) base;                                         
  10673b:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  10673d:	eb 09                	jmp    106748 <Stack_check_find_high_water_mark+0x29><== NOT EXECUTED
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
  10673f:	83 c2 04             	add    $0x4,%edx                      <== NOT EXECUTED
  106742:	39 c2                	cmp    %eax,%edx                      <== NOT EXECUTED
  106744:	72 ed                	jb     106733 <Stack_check_find_high_water_mark+0x14><== NOT EXECUTED
  106746:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
        return (void *) base;                                         
  #endif                                                              
                                                                      
  return (void *)0;                                                   
}                                                                     
  106748:	c9                   	leave                                 <== NOT EXECUTED
  106749:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001068da <Stack_check_report_blown_task>: */ void Stack_check_report_blown_task( Thread_Control *running, bool pattern_ok ) {
  1068da:	55                   	push   %ebp                           
  1068db:	89 e5                	mov    %esp,%ebp                      
  1068dd:	56                   	push   %esi                           
  1068de:	53                   	push   %ebx                           
  1068df:	8b 75 08             	mov    0x8(%ebp),%esi                 
  1068e2:	8a 5d 0c             	mov    0xc(%ebp),%bl                  
  Stack_Control *stack = &running->Start.Initial_stack;               
                                                                      
  printk(                                                             
  1068e5:	ff 76 0c             	pushl  0xc(%esi)                      
  1068e8:	ff 76 08             	pushl  0x8(%esi)                      
  1068eb:	56                   	push   %esi                           
  1068ec:	68 86 9a 11 00       	push   $0x119a86                      
  1068f1:	e8 c0 12 00 00       	call   107bb6 <printk>                
        rtems_configuration_get_user_multiprocessing_table()->node    
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  printk(                                                             
  1068f6:	8b 96 c8 00 00 00    	mov    0xc8(%esi),%edx                
  1068fc:	8b 86 c4 00 00 00    	mov    0xc4(%esi),%eax                
  106902:	50                   	push   %eax                           
  106903:	8d 44 02 ff          	lea    -0x1(%edx,%eax,1),%eax         
  106907:	50                   	push   %eax                           
  106908:	52                   	push   %edx                           
  106909:	68 c4 9a 11 00       	push   $0x119ac4                      
  10690e:	e8 a3 12 00 00       	call   107bb6 <printk>                
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
    stack->size                                                       
  );                                                                  
                                                                      
  if ( !pattern_ok ) {                                                
  106913:	83 c4 20             	add    $0x20,%esp                     
  106916:	84 db                	test   %bl,%bl                        
  106918:	75 1a                	jne    106934 <Stack_check_report_blown_task+0x5a><== NEVER TAKEN
    printk(                                                           
  10691a:	53                   	push   %ebx                           
  10691b:	6a 10                	push   $0x10                          
  10691d:	8b 86 c8 00 00 00    	mov    0xc8(%esi),%eax                
  106923:	83 c0 08             	add    $0x8,%eax                      
  106926:	50                   	push   %eax                           
  106927:	68 f2 9a 11 00       	push   $0x119af2                      
  10692c:	e8 85 12 00 00       	call   107bb6 <printk>                
  106931:	83 c4 10             	add    $0x10,%esp                     
      "  Damaged pattern begins at 0x%08lx and is %d bytes long\n",   
      (unsigned long) Stack_check_Get_pattern_area(stack),            
      PATTERN_SIZE_BYTES);                                            
  }                                                                   
                                                                      
  rtems_fatal_error_occurred( 0x81 );                                 
  106934:	83 ec 0c             	sub    $0xc,%esp                      
  106937:	68 81 00 00 00       	push   $0x81                          
  10693c:	e8 4b 3b 00 00       	call   10a48c <rtems_fatal_error_occurred>
                                                                      

001099a9 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) {
  1099a9:	55                   	push   %ebp                           
  1099aa:	89 e5                	mov    %esp,%ebp                      
  1099ac:	53                   	push   %ebx                           
  1099ad:	83 ec 04             	sub    $0x4,%esp                      
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
  1099b0:	8b 1d bc d9 11 00    	mov    0x11d9bc,%ebx                  
  1099b6:	eb 0b                	jmp    1099c3 <_API_extensions_Run_postdriver+0x1a>
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    if ( the_extension->postdriver_hook )                             
  1099b8:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  1099bb:	85 c0                	test   %eax,%eax                      
  1099bd:	74 02                	je     1099c1 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN
      (*the_extension->postdriver_hook)();                            
  1099bf:	ff d0                	call   *%eax                          
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
  1099c1:	8b 1b                	mov    (%ebx),%ebx                    
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
  1099c3:	81 fb c0 d9 11 00    	cmp    $0x11d9c0,%ebx                 
  1099c9:	75 ed                	jne    1099b8 <_API_extensions_Run_postdriver+0xf>
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    if ( the_extension->postdriver_hook )                             
      (*the_extension->postdriver_hook)();                            
  }                                                                   
}                                                                     
  1099cb:	5a                   	pop    %edx                           
  1099cc:	5b                   	pop    %ebx                           
  1099cd:	c9                   	leave                                 
  1099ce:	c3                   	ret                                   
                                                                      

001099cf <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) {
  1099cf:	55                   	push   %ebp                           
  1099d0:	89 e5                	mov    %esp,%ebp                      
  1099d2:	53                   	push   %ebx                           
  1099d3:	83 ec 04             	sub    $0x4,%esp                      
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
  1099d6:	8b 1d bc d9 11 00    	mov    0x11d9bc,%ebx                  
  1099dc:	eb 17                	jmp    1099f5 <_API_extensions_Run_postswitch+0x26>
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    if ( the_extension->postswitch_hook )                             
  1099de:	8b 43 10             	mov    0x10(%ebx),%eax                
  1099e1:	85 c0                	test   %eax,%eax                      
  1099e3:	74 0e                	je     1099f3 <_API_extensions_Run_postswitch+0x24><== NEVER TAKEN
      (*the_extension->postswitch_hook)( _Thread_Executing );         
  1099e5:	83 ec 0c             	sub    $0xc,%esp                      
  1099e8:	ff 35 58 d8 11 00    	pushl  0x11d858                       
  1099ee:	ff d0                	call   *%eax                          
  1099f0:	83 c4 10             	add    $0x10,%esp                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
  1099f3:	8b 1b                	mov    (%ebx),%ebx                    
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
  1099f5:	81 fb c0 d9 11 00    	cmp    $0x11d9c0,%ebx                 
  1099fb:	75 e1                	jne    1099de <_API_extensions_Run_postswitch+0xf>
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    if ( the_extension->postswitch_hook )                             
      (*the_extension->postswitch_hook)( _Thread_Executing );         
  }                                                                   
}                                                                     
  1099fd:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109a00:	c9                   	leave                                 
  109a01:	c3                   	ret                                   
                                                                      

00109983 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) {
  109983:	55                   	push   %ebp                           
  109984:	89 e5                	mov    %esp,%ebp                      
  109986:	53                   	push   %ebx                           
  109987:	83 ec 04             	sub    $0x4,%esp                      
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
  10998a:	8b 1d bc d9 11 00    	mov    0x11d9bc,%ebx                  
  109990:	eb 0b                	jmp    10999d <_API_extensions_Run_predriver+0x1a>
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    if ( the_extension->predriver_hook )                              
  109992:	8b 43 08             	mov    0x8(%ebx),%eax                 
  109995:	85 c0                	test   %eax,%eax                      
  109997:	74 02                	je     10999b <_API_extensions_Run_predriver+0x18><== ALWAYS TAKEN
      (*the_extension->predriver_hook)();                             
  109999:	ff d0                	call   *%eax                          <== NOT EXECUTED
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
  10999b:	8b 1b                	mov    (%ebx),%ebx                    
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _API_extensions_List.first ;                       
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
  10999d:	81 fb c0 d9 11 00    	cmp    $0x11d9c0,%ebx                 
  1099a3:	75 ed                	jne    109992 <_API_extensions_Run_predriver+0xf>
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    if ( the_extension->predriver_hook )                              
      (*the_extension->predriver_hook)();                             
  }                                                                   
}                                                                     
  1099a5:	58                   	pop    %eax                           
  1099a6:	5b                   	pop    %ebx                           
  1099a7:	c9                   	leave                                 
  1099a8:	c3                   	ret                                   
                                                                      

0010b720 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) {
  10b720:	55                   	push   %ebp                           
  10b721:	89 e5                	mov    %esp,%ebp                      
  10b723:	57                   	push   %edi                           
  10b724:	56                   	push   %esi                           
  10b725:	53                   	push   %ebx                           
  10b726:	83 ec 0c             	sub    $0xc,%esp                      
  10b729:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10b72c:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10b72f:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  10b732:	8b 45 14             	mov    0x14(%ebp),%eax                
  10b735:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  10b738:	8a 45 10             	mov    0x10(%ebp),%al                 
  10b73b:	88 45 ef             	mov    %al,-0x11(%ebp)                
  ISR_Level       level;                                              
  Thread_Control *executing = _Thread_Executing;                      
  10b73e:	8b 35 90 fc 11 00    	mov    0x11fc90,%esi                  
   *  If unlocked, then OK to read.                                   
   *  If locked for reading and no waiters, then OK to read.          
   *  If any thread is waiting, then we wait.                         
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
  10b744:	9c                   	pushf                                 
  10b745:	fa                   	cli                                   
  10b746:	5f                   	pop    %edi                           
    switch ( the_rwlock->current_state ) {                            
  10b747:	8b 43 44             	mov    0x44(%ebx),%eax                
  10b74a:	85 c0                	test   %eax,%eax                      
  10b74c:	74 05                	je     10b753 <_CORE_RWLock_Obtain_for_reading+0x33>
  10b74e:	48                   	dec    %eax                           
  10b74f:	75 2e                	jne    10b77f <_CORE_RWLock_Obtain_for_reading+0x5f>
  10b751:	eb 0e                	jmp    10b761 <_CORE_RWLock_Obtain_for_reading+0x41>
      case CORE_RWLOCK_UNLOCKED:                                      
	the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;          
  10b753:	c7 43 44 01 00 00 00 	movl   $0x1,0x44(%ebx)                
	the_rwlock->number_of_readers += 1;                                  
  10b75a:	ff 43 48             	incl   0x48(%ebx)                     
	_ISR_Enable( level );                                                
  10b75d:	57                   	push   %edi                           
  10b75e:	9d                   	popf                                  
  10b75f:	eb 15                	jmp    10b776 <_CORE_RWLock_Obtain_for_reading+0x56>
	executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;                
	return;                                                              
                                                                      
      case CORE_RWLOCK_LOCKED_FOR_READING: {                          
        Thread_Control *waiter;                                       
        waiter = _Thread_queue_First( &the_rwlock->Wait_queue );      
  10b761:	83 ec 0c             	sub    $0xc,%esp                      
  10b764:	53                   	push   %ebx                           
  10b765:	e8 2e 19 00 00       	call   10d098 <_Thread_queue_First>   
        if ( !waiter ) {                                              
  10b76a:	83 c4 10             	add    $0x10,%esp                     
  10b76d:	85 c0                	test   %eax,%eax                      
  10b76f:	75 0e                	jne    10b77f <_CORE_RWLock_Obtain_for_reading+0x5f><== NEVER TAKEN
	  the_rwlock->number_of_readers += 1;                                
  10b771:	ff 43 48             	incl   0x48(%ebx)                     
	  _ISR_Enable( level );                                              
  10b774:	57                   	push   %edi                           
  10b775:	9d                   	popf                                  
	  executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;              
  10b776:	c7 46 34 00 00 00 00 	movl   $0x0,0x34(%esi)                
  10b77d:	eb 4d                	jmp    10b7cc <_CORE_RWLock_Obtain_for_reading+0xac>
                                                                      
    /*                                                                
     *  If the thread is not willing to wait, then return immediately.
     */                                                               
                                                                      
    if ( !wait ) {                                                    
  10b77f:	80 7d ef 00          	cmpb   $0x0,-0x11(%ebp)               
  10b783:	75 0b                	jne    10b790 <_CORE_RWLock_Obtain_for_reading+0x70>
      _ISR_Enable( level );                                           
  10b785:	57                   	push   %edi                           
  10b786:	9d                   	popf                                  
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
  10b787:	c7 46 34 02 00 00 00 	movl   $0x2,0x34(%esi)                
  10b78e:	eb 3c                	jmp    10b7cc <_CORE_RWLock_Obtain_for_reading+0xac>
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  10b790:	c7 43 30 01 00 00 00 	movl   $0x1,0x30(%ebx)                
    /*                                                                
     *  We need to wait to enter this critical section                
     */                                                               
                                                                      
    _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );  
    executing->Wait.queue       = &the_rwlock->Wait_queue;            
  10b797:	89 5e 44             	mov    %ebx,0x44(%esi)                
    executing->Wait.id          = id;                                 
  10b79a:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10b79d:	89 46 20             	mov    %eax,0x20(%esi)                
    executing->Wait.option      = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
  10b7a0:	c7 46 30 00 00 00 00 	movl   $0x0,0x30(%esi)                
    executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;             
  10b7a7:	c7 46 34 00 00 00 00 	movl   $0x0,0x34(%esi)                
    _ISR_Enable( level );                                             
  10b7ae:	57                   	push   %edi                           
  10b7af:	9d                   	popf                                  
                                                                      
    _Thread_queue_Enqueue_with_handler(                               
  10b7b0:	c7 45 10 f0 b8 10 00 	movl   $0x10b8f0,0x10(%ebp)           
  10b7b7:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10b7ba:	89 45 0c             	mov    %eax,0xc(%ebp)                 
  10b7bd:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
       timeout,                                                       
       _CORE_RWLock_Timeout                                           
    );                                                                
                                                                      
    /* return to API level so it can dispatch and we block */         
}                                                                     
  10b7c0:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b7c3:	5b                   	pop    %ebx                           
  10b7c4:	5e                   	pop    %esi                           
  10b7c5:	5f                   	pop    %edi                           
  10b7c6:	c9                   	leave                                 
    executing->Wait.id          = id;                                 
    executing->Wait.option      = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
    executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;             
    _ISR_Enable( level );                                             
                                                                      
    _Thread_queue_Enqueue_with_handler(                               
  10b7c7:	e9 d0 15 00 00       	jmp    10cd9c <_Thread_queue_Enqueue_with_handler>
       timeout,                                                       
       _CORE_RWLock_Timeout                                           
    );                                                                
                                                                      
    /* return to API level so it can dispatch and we block */         
}                                                                     
  10b7cc:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b7cf:	5b                   	pop    %ebx                           
  10b7d0:	5e                   	pop    %esi                           
  10b7d1:	5f                   	pop    %edi                           
  10b7d2:	c9                   	leave                                 
  10b7d3:	c3                   	ret                                   
                                                                      

0010b850 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) {
  10b850:	55                   	push   %ebp                           
  10b851:	89 e5                	mov    %esp,%ebp                      
  10b853:	53                   	push   %ebx                           
  10b854:	83 ec 04             	sub    $0x4,%esp                      
  10b857:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  ISR_Level       level;                                              
  Thread_Control *executing = _Thread_Executing;                      
  10b85a:	8b 0d 90 fc 11 00    	mov    0x11fc90,%ecx                  
   *  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 );                                              
  10b860:	9c                   	pushf                                 
  10b861:	fa                   	cli                                   
  10b862:	5a                   	pop    %edx                           
    if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){          
  10b863:	8b 43 44             	mov    0x44(%ebx),%eax                
  10b866:	85 c0                	test   %eax,%eax                      
  10b868:	75 0b                	jne    10b875 <_CORE_RWLock_Release+0x25><== ALWAYS TAKEN
      _ISR_Enable( level );                                           
  10b86a:	52                   	push   %edx                           <== NOT EXECUTED
  10b86b:	9d                   	popf                                  <== NOT EXECUTED
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
  10b86c:	c7 41 34 02 00 00 00 	movl   $0x2,0x34(%ecx)                <== NOT EXECUTED
  10b873:	eb 72                	jmp    10b8e7 <_CORE_RWLock_Release+0x97><== NOT EXECUTED
      return CORE_RWLOCK_SUCCESSFUL;                                  
    }                                                                 
    if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
  10b875:	48                   	dec    %eax                           
  10b876:	75 0f                	jne    10b887 <_CORE_RWLock_Release+0x37>
	the_rwlock->number_of_readers -= 1;                                  
  10b878:	8b 43 48             	mov    0x48(%ebx),%eax                
  10b87b:	48                   	dec    %eax                           
  10b87c:	89 43 48             	mov    %eax,0x48(%ebx)                
	if ( the_rwlock->number_of_readers != 0 ) {                          
  10b87f:	85 c0                	test   %eax,%eax                      
  10b881:	74 04                	je     10b887 <_CORE_RWLock_Release+0x37>
          /* must be unlocked again */                                
	  _ISR_Enable( level );                                              
  10b883:	52                   	push   %edx                           
  10b884:	9d                   	popf                                  
  10b885:	eb 60                	jmp    10b8e7 <_CORE_RWLock_Release+0x97>
          return CORE_RWLOCK_SUCCESSFUL;                              
        }                                                             
    }                                                                 
                                                                      
    /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */      
    executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;             
  10b887:	c7 41 34 00 00 00 00 	movl   $0x0,0x34(%ecx)                
                                                                      
    /*                                                                
     * Implicitly transition to "unlocked" and find another thread interested
     * in obtaining this rwlock.                                      
     */                                                               
    the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;                 
  10b88e:	c7 43 44 00 00 00 00 	movl   $0x0,0x44(%ebx)                
  _ISR_Enable( level );                                               
  10b895:	52                   	push   %edx                           
  10b896:	9d                   	popf                                  
                                                                      
  next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );            
  10b897:	83 ec 0c             	sub    $0xc,%esp                      
  10b89a:	53                   	push   %ebx                           
  10b89b:	e8 e4 13 00 00       	call   10cc84 <_Thread_queue_Dequeue> 
                                                                      
  if ( next ) {                                                       
  10b8a0:	83 c4 10             	add    $0x10,%esp                     
  10b8a3:	85 c0                	test   %eax,%eax                      
  10b8a5:	74 40                	je     10b8e7 <_CORE_RWLock_Release+0x97>
    if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
  10b8a7:	83 78 30 01          	cmpl   $0x1,0x30(%eax)                
  10b8ab:	75 09                	jne    10b8b6 <_CORE_RWLock_Release+0x66>
      the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;     
  10b8ad:	c7 43 44 02 00 00 00 	movl   $0x2,0x44(%ebx)                
  10b8b4:	eb 31                	jmp    10b8e7 <_CORE_RWLock_Release+0x97>
    }                                                                 
                                                                      
    /*                                                                
     * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING                 
     */                                                               
    the_rwlock->number_of_readers += 1;                               
  10b8b6:	ff 43 48             	incl   0x48(%ebx)                     
    the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;       
  10b8b9:	c7 43 44 01 00 00 00 	movl   $0x1,0x44(%ebx)                
                                                                      
    /*                                                                
     * Now see if more readers can be let go.                         
     */                                                               
    while ( 1 ) {                                                     
      next = _Thread_queue_First( &the_rwlock->Wait_queue );          
  10b8c0:	83 ec 0c             	sub    $0xc,%esp                      
  10b8c3:	53                   	push   %ebx                           
  10b8c4:	e8 cf 17 00 00       	call   10d098 <_Thread_queue_First>   
      if ( !next ||                                                   
  10b8c9:	83 c4 10             	add    $0x10,%esp                     
  10b8cc:	85 c0                	test   %eax,%eax                      
  10b8ce:	74 17                	je     10b8e7 <_CORE_RWLock_Release+0x97>
  10b8d0:	83 78 30 01          	cmpl   $0x1,0x30(%eax)                
  10b8d4:	74 11                	je     10b8e7 <_CORE_RWLock_Release+0x97><== NEVER TAKEN
           next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
        return CORE_RWLOCK_SUCCESSFUL;                                
      the_rwlock->number_of_readers += 1;                             
  10b8d6:	ff 43 48             	incl   0x48(%ebx)                     
      _Thread_queue_Extract( &the_rwlock->Wait_queue, next );         
  10b8d9:	52                   	push   %edx                           
  10b8da:	52                   	push   %edx                           
  10b8db:	50                   	push   %eax                           
  10b8dc:	53                   	push   %ebx                           
  10b8dd:	e8 9e 16 00 00       	call   10cf80 <_Thread_queue_Extract> 
  10b8e2:	83 c4 10             	add    $0x10,%esp                     
  10b8e5:	eb d9                	jmp    10b8c0 <_CORE_RWLock_Release+0x70>
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
  10b8e7:	31 c0                	xor    %eax,%eax                      
  10b8e9:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b8ec:	c9                   	leave                                 
  10b8ed:	c3                   	ret                                   
                                                                      

0010b8f0 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) {
  10b8f0:	55                   	push   %ebp                           
  10b8f1:	89 e5                	mov    %esp,%ebp                      
  10b8f3:	83 ec 20             	sub    $0x20,%esp                     
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  10b8f6:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  10b8f9:	50                   	push   %eax                           
  10b8fa:	ff 75 08             	pushl  0x8(%ebp)                      
  10b8fd:	e8 6a 10 00 00       	call   10c96c <_Thread_Get>           
  switch ( location ) {                                               
  10b902:	83 c4 10             	add    $0x10,%esp                     
  10b905:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  10b909:	75 17                	jne    10b922 <_CORE_RWLock_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
  10b90b:	83 ec 0c             	sub    $0xc,%esp                      
  10b90e:	50                   	push   %eax                           
  10b90f:	e8 74 18 00 00       	call   10d188 <_Thread_queue_Process_timeout>
  10b914:	a1 d0 fb 11 00       	mov    0x11fbd0,%eax                  
  10b919:	48                   	dec    %eax                           
  10b91a:	a3 d0 fb 11 00       	mov    %eax,0x11fbd0                  
  10b91f:	83 c4 10             	add    $0x10,%esp                     
      _Thread_Unnest_dispatch();                                      
      break;                                                          
  }                                                                   
}                                                                     
  10b922:	c9                   	leave                                 
  10b923:	c3                   	ret                                   
                                                                      

0010aa34 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) {
  10aa34:	55                   	push   %ebp                           
  10aa35:	89 e5                	mov    %esp,%ebp                      
  10aa37:	57                   	push   %edi                           
  10aa38:	56                   	push   %esi                           
  10aa39:	53                   	push   %ebx                           
  10aa3a:	83 ec 04             	sub    $0x4,%esp                      
  10aa3d:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10aa40:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  10aa43:	8b 45 14             	mov    0x14(%ebp),%eax                
  10aa46:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  10aa49:	8b 7d 18             	mov    0x18(%ebp),%edi                
  Thread_Control *executing;                                          
  ISR_Level       level;                                              
                                                                      
  executing = _Thread_Executing;                                      
  10aa4c:	8b 0d 50 ed 11 00    	mov    0x11ed50,%ecx                  
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;       
  10aa52:	c7 41 34 00 00 00 00 	movl   $0x0,0x34(%ecx)                
  _ISR_Disable( level );                                              
  10aa59:	9c                   	pushf                                 
  10aa5a:	fa                   	cli                                   
  10aa5b:	5b                   	pop    %ebx                           
  the_barrier->number_of_waiting_threads++;                           
  10aa5c:	8b 42 48             	mov    0x48(%edx),%eax                
  10aa5f:	40                   	inc    %eax                           
  10aa60:	89 42 48             	mov    %eax,0x48(%edx)                
  if ( the_barrier->number_of_waiting_threads ==                      
  10aa63:	3b 42 44             	cmp    0x44(%edx),%eax                
  10aa66:	75 22                	jne    10aa8a <_CORE_barrier_Wait+0x56>
       the_barrier->Attributes.maximum_count) {                       
    if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {   
  10aa68:	83 7a 40 00          	cmpl   $0x0,0x40(%edx)                
  10aa6c:	75 1c                	jne    10aa8a <_CORE_barrier_Wait+0x56><== NEVER TAKEN
      executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
  10aa6e:	c7 41 34 01 00 00 00 	movl   $0x1,0x34(%ecx)                
      _ISR_Enable( level );                                           
  10aa75:	53                   	push   %ebx                           
  10aa76:	9d                   	popf                                  
      _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
  10aa77:	89 7d 10             	mov    %edi,0x10(%ebp)                
  10aa7a:	89 75 0c             	mov    %esi,0xc(%ebp)                 
  10aa7d:	89 55 08             	mov    %edx,0x8(%ebp)                 
  executing->Wait.queue          = &the_barrier->Wait_queue;          
  executing->Wait.id             = id;                                
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );         
}                                                                     
  10aa80:	5a                   	pop    %edx                           
  10aa81:	5b                   	pop    %ebx                           
  10aa82:	5e                   	pop    %esi                           
  10aa83:	5f                   	pop    %edi                           
  10aa84:	c9                   	leave                                 
  if ( the_barrier->number_of_waiting_threads ==                      
       the_barrier->Attributes.maximum_count) {                       
    if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {   
      executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
      _ISR_Enable( level );                                           
      _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
  10aa85:	e9 c6 42 00 00       	jmp    10ed50 <_CORE_barrier_Release> 
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  10aa8a:	c7 42 30 01 00 00 00 	movl   $0x1,0x30(%edx)                
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );   
  executing->Wait.queue          = &the_barrier->Wait_queue;          
  10aa91:	89 51 44             	mov    %edx,0x44(%ecx)                
  executing->Wait.id             = id;                                
  10aa94:	89 71 20             	mov    %esi,0x20(%ecx)                
  _ISR_Enable( level );                                               
  10aa97:	53                   	push   %ebx                           
  10aa98:	9d                   	popf                                  
                                                                      
  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );         
  10aa99:	c7 45 10 5c c5 10 00 	movl   $0x10c55c,0x10(%ebp)           
  10aaa0:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10aaa3:	89 45 0c             	mov    %eax,0xc(%ebp)                 
  10aaa6:	89 55 08             	mov    %edx,0x8(%ebp)                 
}                                                                     
  10aaa9:	58                   	pop    %eax                           
  10aaaa:	5b                   	pop    %ebx                           
  10aaab:	5e                   	pop    %esi                           
  10aaac:	5f                   	pop    %edi                           
  10aaad:	c9                   	leave                                 
  _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );   
  executing->Wait.queue          = &the_barrier->Wait_queue;          
  executing->Wait.id             = id;                                
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );         
  10aaae:	e9 a5 17 00 00       	jmp    10c258 <_Thread_queue_Enqueue_with_handler>
                                                                      

00113b08 <_CORE_message_queue_Broadcast>: size_t size, Objects_Id id, CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, uint32_t *count ) {
  113b08:	55                   	push   %ebp                           
  113b09:	89 e5                	mov    %esp,%ebp                      
  113b0b:	57                   	push   %edi                           
  113b0c:	56                   	push   %esi                           
  113b0d:	53                   	push   %ebx                           
  113b0e:	83 ec 0c             	sub    $0xc,%esp                      
  Thread_Control          *the_thread;                                
  uint32_t                 number_broadcasted;                        
  Thread_Wait_information *waitp;                                     
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
  113b11:	b8 01 00 00 00       	mov    $0x1,%eax                      
  113b16:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  113b19:	8b 55 08             	mov    0x8(%ebp),%edx                 
  113b1c:	3b 4a 4c             	cmp    0x4c(%edx),%ecx                
  113b1f:	77 43                	ja     113b64 <_CORE_message_queue_Broadcast+0x5c><== NEVER TAKEN
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.                                              
   */                                                                 
                                                                      
  number_broadcasted = 0;                                             
  while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
  113b21:	31 db                	xor    %ebx,%ebx                      
   *  NOTE: This check is critical because threads can block on       
   *        send and receive and this ensures that we are broadcasting
   *        the message to threads waiting to receive -- not to send. 
   */                                                                 
                                                                      
  if ( the_message_queue->number_of_pending_messages != 0 ) {         
  113b23:	8b 75 08             	mov    0x8(%ebp),%esi                 
  113b26:	83 7e 48 00          	cmpl   $0x0,0x48(%esi)                
  113b2a:	74 21                	je     113b4d <_CORE_message_queue_Broadcast+0x45><== ALWAYS TAKEN
    *count = 0;                                                       
  113b2c:	8b 45 1c             	mov    0x1c(%ebp),%eax                <== NOT EXECUTED
  113b2f:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    <== NOT EXECUTED
  113b35:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  113b37:	eb 2b                	jmp    113b64 <_CORE_message_queue_Broadcast+0x5c><== NOT EXECUTED
   */                                                                 
                                                                      
  number_broadcasted = 0;                                             
  while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
    waitp = &the_thread->Wait;                                        
    number_broadcasted += 1;                                          
  113b39:	43                   	inc    %ebx                           
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  113b3a:	8b 78 2c             	mov    0x2c(%eax),%edi                
  113b3d:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  113b40:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  113b43:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
  113b45:	8b 40 28             	mov    0x28(%eax),%eax                
  113b48:	8b 55 10             	mov    0x10(%ebp),%edx                
  113b4b:	89 10                	mov    %edx,(%eax)                    
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.                                              
   */                                                                 
                                                                      
  number_broadcasted = 0;                                             
  while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
  113b4d:	83 ec 0c             	sub    $0xc,%esp                      
  113b50:	ff 75 08             	pushl  0x8(%ebp)                      
  113b53:	e8 98 1f 00 00       	call   115af0 <_Thread_queue_Dequeue> 
  113b58:	83 c4 10             	add    $0x10,%esp                     
  113b5b:	85 c0                	test   %eax,%eax                      
  113b5d:	75 da                	jne    113b39 <_CORE_message_queue_Broadcast+0x31>
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_message_queue_mp_support) ( the_thread, id );             
#endif                                                                
                                                                      
  }                                                                   
  *count = number_broadcasted;                                        
  113b5f:	8b 4d 1c             	mov    0x1c(%ebp),%ecx                
  113b62:	89 19                	mov    %ebx,(%ecx)                    
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                        
}                                                                     
  113b64:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  113b67:	5b                   	pop    %ebx                           
  113b68:	5e                   	pop    %esi                           
  113b69:	5f                   	pop    %edi                           
  113b6a:	c9                   	leave                                 
  113b6b:	c3                   	ret                                   
                                                                      

00112ec8 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) {
  112ec8:	55                   	push   %ebp                           
  112ec9:	89 e5                	mov    %esp,%ebp                      
  112ecb:	57                   	push   %edi                           
  112ecc:	56                   	push   %esi                           
  112ecd:	53                   	push   %ebx                           
  112ece:	83 ec 0c             	sub    $0xc,%esp                      
  112ed1:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  112ed4:	8b 7d 10             	mov    0x10(%ebp),%edi                
  112ed7:	8b 55 14             	mov    0x14(%ebp),%edx                
  size_t message_buffering_required;                                  
  size_t allocated_message_size;                                      
                                                                      
  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
  112eda:	89 7b 44             	mov    %edi,0x44(%ebx)                
  the_message_queue->number_of_pending_messages = 0;                  
  112edd:	c7 43 48 00 00 00 00 	movl   $0x0,0x48(%ebx)                
  the_message_queue->maximum_message_size       = maximum_message_size;
  112ee4:	89 53 4c             	mov    %edx,0x4c(%ebx)                
  112ee7:	c7 43 60 00 00 00 00 	movl   $0x0,0x60(%ebx)                
  112eee:	c7 43 64 00 00 00 00 	movl   $0x0,0x64(%ebx)                
   *  Round size up to multiple of a pointer for chain init and       
   *  check for overflow on adding overhead to each message.          
   */                                                                 
                                                                      
  allocated_message_size = maximum_message_size;                      
  if (allocated_message_size & (sizeof(uint32_t) - 1)) {              
  112ef5:	89 d0                	mov    %edx,%eax                      
  112ef7:	f6 c2 03             	test   $0x3,%dl                       
  112efa:	74 0a                	je     112f06 <_CORE_message_queue_Initialize+0x3e>
      allocated_message_size += sizeof(uint32_t);                     
  112efc:	8d 42 04             	lea    0x4(%edx),%eax                 
      allocated_message_size &= ~(sizeof(uint32_t) - 1);              
  112eff:	83 e0 fc             	and    $0xfffffffc,%eax               
  }                                                                   
                                                                      
  if (allocated_message_size < maximum_message_size)                  
  112f02:	39 d0                	cmp    %edx,%eax                      
  112f04:	72 5f                	jb     112f65 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN
                                                                      
  /*                                                                  
   *  Calculate how much total memory is required for message buffering and
   *  check for overflow on the multiplication.                       
   */                                                                 
  message_buffering_required = (size_t) maximum_pending_messages *    
  112f06:	8d 70 14             	lea    0x14(%eax),%esi                
  112f09:	89 f2                	mov    %esi,%edx                      
  112f0b:	0f af d7             	imul   %edi,%edx                      
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
                                                                      
  if (message_buffering_required < allocated_message_size)            
  112f0e:	39 c2                	cmp    %eax,%edx                      
  112f10:	72 53                	jb     112f65 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN
    return false;                                                     
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
  112f12:	83 ec 0c             	sub    $0xc,%esp                      
  112f15:	52                   	push   %edx                           
  112f16:	e8 92 de ff ff       	call   110dad <_Workspace_Allocate>   
  112f1b:	89 43 5c             	mov    %eax,0x5c(%ebx)                
     _Workspace_Allocate( message_buffering_required );               
                                                                      
  if (the_message_queue->message_buffers == 0)                        
  112f1e:	83 c4 10             	add    $0x10,%esp                     
  112f21:	85 c0                	test   %eax,%eax                      
  112f23:	74 40                	je     112f65 <_CORE_message_queue_Initialize+0x9d>
                                                                      
  /*                                                                  
   *  Initialize the pool of inactive messages, pending messages,     
   *  and set of waiting threads.                                     
   */                                                                 
  _Chain_Initialize (                                                 
  112f25:	56                   	push   %esi                           
  112f26:	57                   	push   %edi                           
  112f27:	50                   	push   %eax                           
  112f28:	8d 43 68             	lea    0x68(%ebx),%eax                
  112f2b:	50                   	push   %eax                           
  112f2c:	e8 93 fe ff ff       	call   112dc4 <_Chain_Initialize>     
  112f31:	8d 43 54             	lea    0x54(%ebx),%eax                
  112f34:	89 43 50             	mov    %eax,0x50(%ebx)                
  112f37:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                
  112f3e:	8d 43 50             	lea    0x50(%ebx),%eax                
  112f41:	89 43 58             	mov    %eax,0x58(%ebx)                
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );                                                                  
                                                                      
  _Chain_Initialize_empty( &the_message_queue->Pending_messages );    
                                                                      
  _Thread_queue_Initialize(                                           
  112f44:	6a 06                	push   $0x6                           
  112f46:	68 80 00 00 00       	push   $0x80                          
  112f4b:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  112f4e:	83 38 01             	cmpl   $0x1,(%eax)                    
  112f51:	0f 94 c0             	sete   %al                            
  112f54:	0f b6 c0             	movzbl %al,%eax                       
  112f57:	50                   	push   %eax                           
  112f58:	53                   	push   %ebx                           
  112f59:	e8 5a d4 ff ff       	call   1103b8 <_Thread_queue_Initialize>
  112f5e:	b0 01                	mov    $0x1,%al                       
  112f60:	83 c4 20             	add    $0x20,%esp                     
  112f63:	eb 02                	jmp    112f67 <_CORE_message_queue_Initialize+0x9f>
       THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
  112f65:	31 c0                	xor    %eax,%eax                      
}                                                                     
  112f67:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  112f6a:	5b                   	pop    %ebx                           
  112f6b:	5e                   	pop    %esi                           
  112f6c:	5f                   	pop    %edi                           
  112f6d:	c9                   	leave                                 
  112f6e:	c3                   	ret                                   
                                                                      

0010e7f8 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) {
  10e7f8:	55                   	push   %ebp                           
  10e7f9:	89 e5                	mov    %esp,%ebp                      
  10e7fb:	57                   	push   %edi                           
  10e7fc:	56                   	push   %esi                           
  10e7fd:	53                   	push   %ebx                           
  10e7fe:	83 ec 2c             	sub    $0x2c,%esp                     
  10e801:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10e804:	89 45 d0             	mov    %eax,-0x30(%ebp)               
  10e807:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10e80a:	89 55 ec             	mov    %edx,-0x14(%ebp)               
  10e80d:	8b 7d 10             	mov    0x10(%ebp),%edi                
  10e810:	89 7d e8             	mov    %edi,-0x18(%ebp)               
  10e813:	8b 45 14             	mov    0x14(%ebp),%eax                
  10e816:	89 45 e4             	mov    %eax,-0x1c(%ebp)               
  10e819:	8b 55 1c             	mov    0x1c(%ebp),%edx                
  10e81c:	89 55 dc             	mov    %edx,-0x24(%ebp)               
  10e81f:	8a 45 18             	mov    0x18(%ebp),%al                 
  10e822:	88 45 e3             	mov    %al,-0x1d(%ebp)                
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
  Thread_Control                    *the_thread;                      
                                                                      
  executing = _Thread_Executing;                                      
  10e825:	8b 35 18 64 12 00    	mov    0x126418,%esi                  
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 
  10e82b:	c7 46 34 00 00 00 00 	movl   $0x0,0x34(%esi)                
  _ISR_Disable( level );                                              
  10e832:	9c                   	pushf                                 
  10e833:	fa                   	cli                                   
  10e834:	59                   	pop    %ecx                           
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  10e835:	8b 55 d0             	mov    -0x30(%ebp),%edx               
  10e838:	8b 5a 50             	mov    0x50(%edx),%ebx                
  10e83b:	89 d0                	mov    %edx,%eax                      
  10e83d:	83 c0 54             	add    $0x54,%eax                     
  10e840:	39 c3                	cmp    %eax,%ebx                      
  10e842:	0f 84 9e 00 00 00    	je     10e8e6 <_CORE_message_queue_Seize+0xee>
  10e848:	8b 13                	mov    (%ebx),%edx                    
  10e84a:	8b 7d d0             	mov    -0x30(%ebp),%edi               
  10e84d:	89 57 50             	mov    %edx,0x50(%edi)                
  10e850:	89 f8                	mov    %edi,%eax                      
  10e852:	83 c0 50             	add    $0x50,%eax                     
  10e855:	89 42 04             	mov    %eax,0x4(%edx)                 
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {                                        
  10e858:	85 db                	test   %ebx,%ebx                      
  10e85a:	0f 84 86 00 00 00    	je     10e8e6 <_CORE_message_queue_Seize+0xee><== NEVER TAKEN
    the_message_queue->number_of_pending_messages -= 1;               
  10e860:	ff 4f 48             	decl   0x48(%edi)                     
    _ISR_Enable( level );                                             
  10e863:	51                   	push   %ecx                           
  10e864:	9d                   	popf                                  
                                                                      
    *size_p = the_message->Contents.size;                             
  10e865:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  10e868:	8b 55 e4             	mov    -0x1c(%ebp),%edx               
  10e86b:	89 02                	mov    %eax,(%edx)                    
    _Thread_Executing->Wait.count = the_message->priority;            
  10e86d:	8b 53 08             	mov    0x8(%ebx),%edx                 
  10e870:	a1 18 64 12 00       	mov    0x126418,%eax                  
  10e875:	89 50 24             	mov    %edx,0x24(%eax)                
    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
  10e878:	8d 7b 10             	lea    0x10(%ebx),%edi                
  10e87b:	89 7d f0             	mov    %edi,-0x10(%ebp)               
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  10e87e:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  10e881:	8b 08                	mov    (%eax),%ecx                    
  10e883:	8b 7d e8             	mov    -0x18(%ebp),%edi               
  10e886:	8b 75 f0             	mov    -0x10(%ebp),%esi               
  10e889:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
     *                                                                
     *  NOTE: If we note that the queue was not full before this receive,
     *  then we can avoid this dequeue.                               
     */                                                               
                                                                      
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
  10e88b:	83 ec 0c             	sub    $0xc,%esp                      
  10e88e:	ff 75 d0             	pushl  -0x30(%ebp)                    
  10e891:	e8 d6 17 00 00       	call   11006c <_Thread_queue_Dequeue> 
  10e896:	89 c2                	mov    %eax,%edx                      
    if ( !the_thread ) {                                              
  10e898:	83 c4 10             	add    $0x10,%esp                     
  10e89b:	85 c0                	test   %eax,%eax                      
  10e89d:	75 18                	jne    10e8b7 <_CORE_message_queue_Seize+0xbf>
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  void                *starting_address,                              
  size_t              *size                                           
  10e89f:	89 5d 0c             	mov    %ebx,0xc(%ebp)                 
  10e8a2:	8b 45 d0             	mov    -0x30(%ebp),%eax               
  10e8a5:	83 c0 68             	add    $0x68,%eax                     
  10e8a8:	89 45 08             	mov    %eax,0x8(%ebp)                 
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
  10e8ab:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e8ae:	5b                   	pop    %ebx                           
  10e8af:	5e                   	pop    %esi                           
  10e8b0:	5f                   	pop    %edi                           
  10e8b1:	c9                   	leave                                 
  10e8b2:	e9 71 fe ff ff       	jmp    10e728 <_Chain_Append>         
     *  There was a thread waiting to send a message.  This code      
     *  puts the messages in the message queue on behalf of the       
     *  waiting task.                                                 
     */                                                               
                                                                      
    the_message->priority  = the_thread->Wait.count;                  
  10e8b7:	8b 40 24             	mov    0x24(%eax),%eax                
  10e8ba:	89 43 08             	mov    %eax,0x8(%ebx)                 
    the_message->Contents.size = (size_t) the_thread->Wait.option;    
  10e8bd:	8b 4a 30             	mov    0x30(%edx),%ecx                
  10e8c0:	89 4b 0c             	mov    %ecx,0xc(%ebx)                 
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  10e8c3:	8b 72 2c             	mov    0x2c(%edx),%esi                
  10e8c6:	8b 7d f0             	mov    -0x10(%ebp),%edi               
  10e8c9:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
      the_thread->Wait.return_argument_second.immutable_object,       
      the_message->Contents.buffer,                                   
      the_message->Contents.size                                      
    );                                                                
                                                                      
    _CORE_message_queue_Insert_message(                               
  10e8cb:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10e8ce:	89 45 10             	mov    %eax,0x10(%ebp)                
  10e8d1:	89 5d 0c             	mov    %ebx,0xc(%ebp)                 
  10e8d4:	8b 45 d0             	mov    -0x30(%ebp),%eax               
  10e8d7:	89 45 08             	mov    %eax,0x8(%ebp)                 
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
  10e8da:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e8dd:	5b                   	pop    %ebx                           
  10e8de:	5e                   	pop    %esi                           
  10e8df:	5f                   	pop    %edi                           
  10e8e0:	c9                   	leave                                 
      the_thread->Wait.return_argument_second.immutable_object,       
      the_message->Contents.buffer,                                   
      the_message->Contents.size                                      
    );                                                                
                                                                      
    _CORE_message_queue_Insert_message(                               
  10e8e1:	e9 16 45 00 00       	jmp    112dfc <_CORE_message_queue_Insert_message>
       the_message->priority                                          
    );                                                                
    return;                                                           
  }                                                                   
                                                                      
  if ( !wait ) {                                                      
  10e8e6:	80 7d e3 00          	cmpb   $0x0,-0x1d(%ebp)               
  10e8ea:	75 11                	jne    10e8fd <_CORE_message_queue_Seize+0x105>
    _ISR_Enable( level );                                             
  10e8ec:	51                   	push   %ecx                           
  10e8ed:	9d                   	popf                                  
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
  10e8ee:	c7 46 34 04 00 00 00 	movl   $0x4,0x34(%esi)                
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
  10e8f5:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e8f8:	5b                   	pop    %ebx                           
  10e8f9:	5e                   	pop    %esi                           
  10e8fa:	5f                   	pop    %edi                           
  10e8fb:	c9                   	leave                                 
  10e8fc:	c3                   	ret                                   
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  10e8fd:	8b 55 d0             	mov    -0x30(%ebp),%edx               
  10e900:	c7 42 30 01 00 00 00 	movl   $0x1,0x30(%edx)                
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
    return;                                                           
  }                                                                   
                                                                      
  _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
  executing->Wait.queue = &the_message_queue->Wait_queue;             
  10e907:	89 56 44             	mov    %edx,0x44(%esi)                
  executing->Wait.id = id;                                            
  10e90a:	8b 7d ec             	mov    -0x14(%ebp),%edi               
  10e90d:	89 7e 20             	mov    %edi,0x20(%esi)                
  executing->Wait.return_argument_second.mutable_object = buffer;     
  10e910:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10e913:	89 46 2c             	mov    %eax,0x2c(%esi)                
  executing->Wait.return_argument = size_p;                           
  10e916:	8b 55 e4             	mov    -0x1c(%ebp),%edx               
  10e919:	89 56 28             	mov    %edx,0x28(%esi)                
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
  10e91c:	51                   	push   %ecx                           
  10e91d:	9d                   	popf                                  
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
  10e91e:	c7 45 10 88 04 11 00 	movl   $0x110488,0x10(%ebp)           
  10e925:	8b 7d dc             	mov    -0x24(%ebp),%edi               
  10e928:	89 7d 0c             	mov    %edi,0xc(%ebp)                 
  10e92b:	8b 45 d0             	mov    -0x30(%ebp),%eax               
  10e92e:	89 45 08             	mov    %eax,0x8(%ebp)                 
}                                                                     
  10e931:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e934:	5b                   	pop    %ebx                           
  10e935:	5e                   	pop    %esi                           
  10e936:	5f                   	pop    %edi                           
  10e937:	c9                   	leave                                 
  executing->Wait.return_argument_second.mutable_object = buffer;     
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
  10e938:	e9 47 18 00 00       	jmp    110184 <_Thread_queue_Enqueue_with_handler>
                                                                      

00109b38 <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) {
  109b38:	55                   	push   %ebp                           
  109b39:	89 e5                	mov    %esp,%ebp                      
  109b3b:	57                   	push   %edi                           
  109b3c:	56                   	push   %esi                           
  109b3d:	53                   	push   %ebx                           
  109b3e:	83 ec 1c             	sub    $0x1c,%esp                     
  109b41:	8b 5d 10             	mov    0x10(%ebp),%ebx                
  109b44:	8a 45 20             	mov    0x20(%ebp),%al                 
  109b47:	88 45 f3             	mov    %al,-0xd(%ebp)                 
  ISR_Level                            level;                         
  CORE_message_queue_Buffer_control   *the_message;                   
  Thread_Control                      *the_thread;                    
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
  109b4a:	b8 01 00 00 00       	mov    $0x1,%eax                      
  109b4f:	8b 55 08             	mov    0x8(%ebp),%edx                 
  109b52:	3b 5a 4c             	cmp    0x4c(%edx),%ebx                
  109b55:	0f 87 d9 00 00 00    	ja     109c34 <_CORE_message_queue_Submit+0xfc>
                                                                      
  /*                                                                  
   *  Is there a thread currently waiting on this message queue?      
   */                                                                 
                                                                      
  if ( the_message_queue->number_of_pending_messages == 0 ) {         
  109b5b:	8b 75 08             	mov    0x8(%ebp),%esi                 
  109b5e:	83 7e 48 00          	cmpl   $0x0,0x48(%esi)                
  109b62:	75 2e                	jne    109b92 <_CORE_message_queue_Submit+0x5a>
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
  109b64:	83 ec 0c             	sub    $0xc,%esp                      
  109b67:	56                   	push   %esi                           
  109b68:	e8 57 16 00 00       	call   10b1c4 <_Thread_queue_Dequeue> 
  109b6d:	89 c2                	mov    %eax,%edx                      
    if ( the_thread ) {                                               
  109b6f:	83 c4 10             	add    $0x10,%esp                     
  109b72:	85 c0                	test   %eax,%eax                      
  109b74:	74 1c                	je     109b92 <_CORE_message_queue_Submit+0x5a>
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  109b76:	8b 78 2c             	mov    0x2c(%eax),%edi                
  109b79:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  109b7c:	89 d9                	mov    %ebx,%ecx                      
  109b7e:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
      _CORE_message_queue_Copy_buffer(                                
        buffer,                                                       
        the_thread->Wait.return_argument_second.mutable_object,       
        size                                                          
      );                                                              
      *(size_t *) the_thread->Wait.return_argument = size;            
  109b80:	8b 40 28             	mov    0x28(%eax),%eax                
  109b83:	89 18                	mov    %ebx,(%eax)                    
      the_thread->Wait.count = submit_type;                           
  109b85:	8b 45 1c             	mov    0x1c(%ebp),%eax                
  109b88:	89 42 24             	mov    %eax,0x24(%edx)                
  109b8b:	31 c0                	xor    %eax,%eax                      
  109b8d:	e9 a2 00 00 00       	jmp    109c34 <_CORE_message_queue_Submit+0xfc>
  /*                                                                  
   *  No one waiting on the message queue at this time, so attempt to 
   *  queue the message up for a future receive.                      
   */                                                                 
                                                                      
  if ( the_message_queue->number_of_pending_messages <                
  109b92:	8b 55 08             	mov    0x8(%ebp),%edx                 
  109b95:	8b 42 48             	mov    0x48(%edx),%eax                
  109b98:	3b 42 44             	cmp    0x44(%edx),%eax                
  109b9b:	73 37                	jae    109bd4 <_CORE_message_queue_Submit+0x9c>
);                                                                    
                                                                      
/**                                                                   
 *  This function sets @a *size to the size of the block of user memory
 *  which begins at @a starting_address. The size returned in @a *size could
 *  be greater than the size requested for allocation.                
  109b9d:	83 ec 0c             	sub    $0xc,%esp                      
  109ba0:	89 d0                	mov    %edx,%eax                      
  109ba2:	83 c0 68             	add    $0x68,%eax                     
  109ba5:	50                   	push   %eax                           
  109ba6:	e8 65 ff ff ff       	call   109b10 <_Chain_Get>            
                                                                      
    /*                                                                
     *  NOTE: If the system is consistent, this error should never occur.
     */                                                               
                                                                      
    if ( !the_message ) {                                             
  109bab:	83 c4 10             	add    $0x10,%esp                     
  109bae:	85 c0                	test   %eax,%eax                      
  109bb0:	74 7d                	je     109c2f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  109bb2:	8d 78 10             	lea    0x10(%eax),%edi                
  109bb5:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  109bb8:	89 d9                	mov    %ebx,%ecx                      
  109bba:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
    _CORE_message_queue_Copy_buffer(                                  
      buffer,                                                         
      the_message->Contents.buffer,                                   
      size                                                            
    );                                                                
    the_message->Contents.size = size;                                
  109bbc:	89 58 0c             	mov    %ebx,0xc(%eax)                 
    the_message->priority  = submit_type;                             
  109bbf:	8b 55 1c             	mov    0x1c(%ebp),%edx                
  109bc2:	89 50 08             	mov    %edx,0x8(%eax)                 
                                                                      
    _CORE_message_queue_Insert_message(                               
  109bc5:	51                   	push   %ecx                           
  109bc6:	52                   	push   %edx                           
  109bc7:	50                   	push   %eax                           
  109bc8:	ff 75 08             	pushl  0x8(%ebp)                      
  109bcb:	e8 c4 41 00 00       	call   10dd94 <_CORE_message_queue_Insert_message>
  109bd0:	31 c0                	xor    %eax,%eax                      
  109bd2:	eb 56                	jmp    109c2a <_CORE_message_queue_Submit+0xf2>
   *  No message buffers were available so we may need to return an   
   *  overflow error or block the sender until the message is placed  
   *  on the queue.                                                   
   */                                                                 
                                                                      
  if ( !wait ) {                                                      
  109bd4:	b8 02 00 00 00       	mov    $0x2,%eax                      
  109bd9:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  109bdd:	74 55                	je     109c34 <_CORE_message_queue_Submit+0xfc>
  /*                                                                  
   *  Do NOT block on a send if the caller is in an ISR.  It is       
   *  deadly to block in an ISR.                                      
   */                                                                 
                                                                      
  if ( _ISR_Is_in_progress() ) {                                      
  109bdf:	a1 34 d8 11 00       	mov    0x11d834,%eax                  
  109be4:	85 c0                	test   %eax,%eax                      
  109be6:	75 47                	jne    109c2f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN
   *  it as a variable.  Doing this emphasizes how dangerous it       
   *  would be to use this variable prior to here.                    
   */                                                                 
                                                                      
  {                                                                   
    Thread_Control  *executing = _Thread_Executing;                   
  109be8:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
                                                                      
    _ISR_Disable( level );                                            
  109bed:	9c                   	pushf                                 
  109bee:	fa                   	cli                                   
  109bef:	59                   	pop    %ecx                           
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  109bf0:	8b 75 08             	mov    0x8(%ebp),%esi                 
  109bf3:	c7 46 30 01 00 00 00 	movl   $0x1,0x30(%esi)                
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;           
  109bfa:	89 70 44             	mov    %esi,0x44(%eax)                
    executing->Wait.id = id;                                          
  109bfd:	8b 55 14             	mov    0x14(%ebp),%edx                
  109c00:	89 50 20             	mov    %edx,0x20(%eax)                
    executing->Wait.return_argument_second.immutable_object = buffer; 
  109c03:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  109c06:	89 50 2c             	mov    %edx,0x2c(%eax)                
    executing->Wait.option = (uint32_t) size;                         
  109c09:	89 58 30             	mov    %ebx,0x30(%eax)                
    executing->Wait.count = submit_type;                              
  109c0c:	8b 75 1c             	mov    0x1c(%ebp),%esi                
  109c0f:	89 70 24             	mov    %esi,0x24(%eax)                
    _ISR_Enable( level );                                             
  109c12:	51                   	push   %ecx                           
  109c13:	9d                   	popf                                  
                                                                      
    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 
  109c14:	50                   	push   %eax                           
  109c15:	68 e0 b5 10 00       	push   $0x10b5e0                      
  109c1a:	ff 75 24             	pushl  0x24(%ebp)                     
  109c1d:	ff 75 08             	pushl  0x8(%ebp)                      
  109c20:	e8 b7 16 00 00       	call   10b2dc <_Thread_queue_Enqueue_with_handler>
  109c25:	b8 07 00 00 00       	mov    $0x7,%eax                      
  109c2a:	83 c4 10             	add    $0x10,%esp                     
  109c2d:	eb 05                	jmp    109c34 <_CORE_message_queue_Submit+0xfc>
  }                                                                   
                                                                      
  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;                  
  109c2f:	b8 03 00 00 00       	mov    $0x3,%eax                      <== NOT EXECUTED
}                                                                     
  109c34:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109c37:	5b                   	pop    %ebx                           
  109c38:	5e                   	pop    %esi                           
  109c39:	5f                   	pop    %edi                           
  109c3a:	c9                   	leave                                 
  109c3b:	c3                   	ret                                   
                                                                      

00109c48 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) {
  109c48:	55                   	push   %ebp                           
  109c49:	89 e5                	mov    %esp,%ebp                      
  109c4b:	57                   	push   %edi                           
  109c4c:	56                   	push   %esi                           
  109c4d:	53                   	push   %ebx                           
  109c4e:	83 ec 0c             	sub    $0xc,%esp                      
  109c51:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  109c54:	8b 45 10             	mov    0x10(%ebp),%eax                
/* Add this to the RTEMS environment later ?????????                  
  rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||                  
                initial_lock == CORE_MUTEX_UNLOCKED );                
 */                                                                   
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
  109c57:	8d 7b 40             	lea    0x40(%ebx),%edi                
  109c5a:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  109c5f:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  109c62:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  the_mutex->lock          = initial_lock;                            
  109c64:	89 43 50             	mov    %eax,0x50(%ebx)                
  the_mutex->blocked_count = 0;                                       
  109c67:	c7 43 58 00 00 00 00 	movl   $0x0,0x58(%ebx)                
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
  109c6e:	85 c0                	test   %eax,%eax                      
  109c70:	75 35                	jne    109ca7 <_CORE_mutex_Initialize+0x5f>
    the_mutex->nest_count = 1;                                        
  109c72:	c7 43 54 01 00 00 00 	movl   $0x1,0x54(%ebx)                
    the_mutex->holder     = _Thread_Executing;                        
  109c79:	8b 15 58 d8 11 00    	mov    0x11d858,%edx                  
  109c7f:	89 53 5c             	mov    %edx,0x5c(%ebx)                
    the_mutex->holder_id  = _Thread_Executing->Object.id;             
  109c82:	8b 42 08             	mov    0x8(%edx),%eax                 
  109c85:	89 43 60             	mov    %eax,0x60(%ebx)                
                                                                      
/**                                                                   
 *  This function attempts to allocate a memory block of @a size bytes from
 *  @a the_heap so that the start of the user memory is aligned on the
 *  @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
 *  Any other value of @a alignment is taken "as is", i.e., even odd  
  109c88:	8b 43 48             	mov    0x48(%ebx),%eax                
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
  109c8b:	83 f8 02             	cmp    $0x2,%eax                      
  109c8e:	74 05                	je     109c95 <_CORE_mutex_Initialize+0x4d>
  109c90:	83 f8 03             	cmp    $0x3,%eax                      
  109c93:	75 27                	jne    109cbc <_CORE_mutex_Initialize+0x74><== ALWAYS TAKEN
         _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
                                                                      
      if ( _Thread_Executing->current_priority <                      
  109c95:	8b 42 14             	mov    0x14(%edx),%eax                
  109c98:	b9 06 00 00 00       	mov    $0x6,%ecx                      
  109c9d:	3b 43 4c             	cmp    0x4c(%ebx),%eax                
  109ca0:	72 3a                	jb     109cdc <_CORE_mutex_Initialize+0x94><== NEVER TAKEN
       _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,    
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif                                                                
                                                                      
      _Thread_Executing->resource_count++;                            
  109ca2:	ff 42 1c             	incl   0x1c(%edx)                     
  109ca5:	eb 15                	jmp    109cbc <_CORE_mutex_Initialize+0x74>
    }                                                                 
  } else {                                                            
    the_mutex->nest_count = 0;                                        
  109ca7:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                
    the_mutex->holder     = NULL;                                     
  109cae:	c7 43 5c 00 00 00 00 	movl   $0x0,0x5c(%ebx)                
    the_mutex->holder_id  = 0;                                        
  109cb5:	c7 43 60 00 00 00 00 	movl   $0x0,0x60(%ebx)                
  }                                                                   
                                                                      
  _Thread_queue_Initialize(                                           
  109cbc:	6a 05                	push   $0x5                           
  109cbe:	68 00 04 00 00       	push   $0x400                         
  109cc3:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  109cc6:	83 78 08 00          	cmpl   $0x0,0x8(%eax)                 
  109cca:	0f 95 c0             	setne  %al                            
  109ccd:	0f b6 c0             	movzbl %al,%eax                       
  109cd0:	50                   	push   %eax                           
  109cd1:	53                   	push   %ebx                           
  109cd2:	e8 39 18 00 00       	call   10b510 <_Thread_queue_Initialize>
  109cd7:	31 c9                	xor    %ecx,%ecx                      
  109cd9:	83 c4 10             	add    $0x10,%esp                     
    STATES_WAITING_FOR_MUTEX,                                         
    CORE_MUTEX_TIMEOUT                                                
  );                                                                  
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
}                                                                     
  109cdc:	89 c8                	mov    %ecx,%eax                      
  109cde:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109ce1:	5b                   	pop    %ebx                           
  109ce2:	5e                   	pop    %esi                           
  109ce3:	5f                   	pop    %edi                           
  109ce4:	c9                   	leave                                 
  109ce5:	c3                   	ret                                   
                                                                      

00109d34 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) {
  109d34:	55                   	push   %ebp                           
  109d35:	89 e5                	mov    %esp,%ebp                      
  109d37:	56                   	push   %esi                           
  109d38:	53                   	push   %ebx                           
  109d39:	8b 75 08             	mov    0x8(%ebp),%esi                 
  109d3c:	8a 5d 10             	mov    0x10(%ebp),%bl                 
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
  109d3f:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  109d44:	85 c0                	test   %eax,%eax                      
  109d46:	74 19                	je     109d61 <_CORE_mutex_Seize+0x2d>
  109d48:	84 db                	test   %bl,%bl                        
  109d4a:	74 15                	je     109d61 <_CORE_mutex_Seize+0x2d><== NEVER TAKEN
  109d4c:	83 3d 38 d9 11 00 01 	cmpl   $0x1,0x11d938                  
  109d53:	76 0c                	jbe    109d61 <_CORE_mutex_Seize+0x2d>
  109d55:	50                   	push   %eax                           
  109d56:	6a 13                	push   $0x13                          
  109d58:	6a 00                	push   $0x0                           
  109d5a:	6a 00                	push   $0x0                           
  109d5c:	e8 93 04 00 00       	call   10a1f4 <_Internal_error_Occurred>
  109d61:	50                   	push   %eax                           
  109d62:	50                   	push   %eax                           
  109d63:	8d 45 18             	lea    0x18(%ebp),%eax                
  109d66:	50                   	push   %eax                           
  109d67:	56                   	push   %esi                           
  109d68:	e8 f3 40 00 00       	call   10de60 <_CORE_mutex_Seize_interrupt_trylock>
  109d6d:	83 c4 10             	add    $0x10,%esp                     
  109d70:	85 c0                	test   %eax,%eax                      
  109d72:	74 49                	je     109dbd <_CORE_mutex_Seize+0x89>
  109d74:	84 db                	test   %bl,%bl                        
  109d76:	75 12                	jne    109d8a <_CORE_mutex_Seize+0x56>
  109d78:	ff 75 18             	pushl  0x18(%ebp)                     
  109d7b:	9d                   	popf                                  
  109d7c:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  109d81:	c7 40 34 01 00 00 00 	movl   $0x1,0x34(%eax)                
  109d88:	eb 33                	jmp    109dbd <_CORE_mutex_Seize+0x89>
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  109d8a:	c7 46 30 01 00 00 00 	movl   $0x1,0x30(%esi)                
  109d91:	8b 15 58 d8 11 00    	mov    0x11d858,%edx                  
  109d97:	89 72 44             	mov    %esi,0x44(%edx)                
  109d9a:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  109d9d:	89 42 20             	mov    %eax,0x20(%edx)                
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109da0:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  109da5:	40                   	inc    %eax                           
  109da6:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
  109dab:	ff 75 18             	pushl  0x18(%ebp)                     
  109dae:	9d                   	popf                                  
  109daf:	53                   	push   %ebx                           
  109db0:	53                   	push   %ebx                           
  109db1:	ff 75 14             	pushl  0x14(%ebp)                     
  109db4:	56                   	push   %esi                           
  109db5:	e8 2e ff ff ff       	call   109ce8 <_CORE_mutex_Seize_interrupt_blocking>
  109dba:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  109dbd:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  109dc0:	5b                   	pop    %ebx                           
  109dc1:	5e                   	pop    %esi                           
  109dc2:	c9                   	leave                                 
  109dc3:	c3                   	ret                                   
                                                                      

0010de60 <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) {
  10de60:	55                   	push   %ebp                           
  10de61:	89 e5                	mov    %esp,%ebp                      
  10de63:	56                   	push   %esi                           
  10de64:	53                   	push   %ebx                           
  10de65:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  void                *starting_address,                              
  size_t              *size                                           
);                                                                    
                                                                      
  10de68:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10de6b:	8b 30                	mov    (%eax),%esi                    
/**                                                                   
 *  This function tries to resize in place the block that is pointed to by the
 *  @a starting_address to the new @a size.                           
 *                                                                    
  10de6d:	8b 15 58 d8 11 00    	mov    0x11d858,%edx                  
 *  @param[in] the_heap is the heap to operate upon                   
  10de73:	c7 42 34 00 00 00 00 	movl   $0x0,0x34(%edx)                
 *  @param[in] starting_address is the starting address of the user block
  10de7a:	83 79 50 00          	cmpl   $0x0,0x50(%ecx)                
  10de7e:	0f 84 82 00 00 00    	je     10df06 <_CORE_mutex_Seize_interrupt_trylock+0xa6>
 *         to be resized                                              
  10de84:	c7 41 50 00 00 00 00 	movl   $0x0,0x50(%ecx)                
 *  @param[in] size is the new size                                   
  10de8b:	89 51 5c             	mov    %edx,0x5c(%ecx)                
 *                                                                    
  10de8e:	8b 42 08             	mov    0x8(%edx),%eax                 
  10de91:	89 41 60             	mov    %eax,0x60(%ecx)                
 *  @return TRUE if successfully able to resize the block.            
  10de94:	c7 41 54 01 00 00 00 	movl   $0x1,0x54(%ecx)                
                                                                      
/**                                                                   
 *  This function attempts to allocate a memory block of @a size bytes from
 *  @a the_heap so that the start of the user memory is aligned on the
 *  @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
 *  Any other value of @a alignment is taken "as is", i.e., even odd  
  10de9b:	8b 41 48             	mov    0x48(%ecx),%eax                
 *  @param[in] starting_address is the starting address of the user block
 *         to be resized                                              
 *  @param[in] size is the new size                                   
 *                                                                    
 *  @return TRUE if successfully able to resize the block.            
 *          FALSE if the block can't be resized in place.             
  10de9e:	83 f8 02             	cmp    $0x2,%eax                      
  10dea1:	74 05                	je     10dea8 <_CORE_mutex_Seize_interrupt_trylock+0x48>
  10dea3:	83 f8 03             	cmp    $0x3,%eax                      
  10dea6:	75 03                	jne    10deab <_CORE_mutex_Seize_interrupt_trylock+0x4b>
  void         *starting_address,                                     
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
 *  This routine returns the block of memory which begins             
  10dea8:	ff 42 1c             	incl   0x1c(%edx)                     
 *  at @a starting_address to @a the_heap.  Any coalescing which is   
 *  possible with the freeing of this routine is performed.           
 *                                                                    
  10deab:	83 79 48 03          	cmpl   $0x3,0x48(%ecx)                
  10deaf:	74 04                	je     10deb5 <_CORE_mutex_Seize_interrupt_trylock+0x55>
 *  @param[in] the_heap is the heap to operate upon                   
  10deb1:	56                   	push   %esi                           
  10deb2:	9d                   	popf                                  
  10deb3:	eb 74                	jmp    10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
  void         *start_address                                         
);                                                                    
                                                                      
/**                                                                   
 *  This routine walks the heap to verify its integrity.              
 *                                                                    
  10deb5:	8b 42 14             	mov    0x14(%edx),%eax                
 *  @param[in] the_heap is the heap to operate upon                   
  10deb8:	3b 41 4c             	cmp    0x4c(%ecx),%eax                
  10debb:	75 04                	jne    10dec1 <_CORE_mutex_Seize_interrupt_trylock+0x61><== ALWAYS TAKEN
 *  @param[in] source is a user specified integer which may be used to
  10debd:	56                   	push   %esi                           <== NOT EXECUTED
  10debe:	9d                   	popf                                  <== NOT EXECUTED
  10debf:	eb 68                	jmp    10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9><== NOT EXECUTED
 *         indicate where in the application this was invoked from    
 *  @param[in] do_dump is set to TRUE if errors should be printed     
 *  @return TRUE if the test passed fine, FALSE otherwise.            
 */                                                                   
  10dec1:	76 27                	jbe    10deea <_CORE_mutex_Seize_interrupt_trylock+0x8a>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10dec3:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  10dec8:	40                   	inc    %eax                           
  10dec9:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
 *         indicate where in the application this was invoked from    
 *  @param[in] do_dump is set to TRUE if errors should be printed     
 *  @return TRUE if the test passed fine, FALSE otherwise.            
 */                                                                   
bool _Protected_heap_Walk(                                            
  Heap_Control *the_heap,                                             
  10dece:	56                   	push   %esi                           
  10decf:	9d                   	popf                                  
  int           source,                                               
  10ded0:	50                   	push   %eax                           
  10ded1:	6a 00                	push   $0x0                           
  10ded3:	ff 71 4c             	pushl  0x4c(%ecx)                     
  10ded6:	ff 71 5c             	pushl  0x5c(%ecx)                     
  10ded9:	e8 0e cb ff ff       	call   10a9ec <_Thread_Change_priority>
  bool          do_dump                                               
);                                                                    
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
  10dede:	e8 a9 cf ff ff       	call   10ae8c <_Thread_Enable_dispatch>
  10dee3:	31 c0                	xor    %eax,%eax                      
  10dee5:	83 c4 10             	add    $0x10,%esp                     
  10dee8:	eb 48                	jmp    10df32 <_CORE_mutex_Seize_interrupt_trylock+0xd2>
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
 *  @param[in] the_info pointer to a status information area          
  10deea:	c7 42 34 06 00 00 00 	movl   $0x6,0x34(%edx)                
 *                                                                    
  10def1:	c7 41 50 01 00 00 00 	movl   $0x1,0x50(%ecx)                
 *  @return true if successfully able to return information           
  10def8:	c7 41 54 00 00 00 00 	movl   $0x0,0x54(%ecx)                
 */                                                                   
  10deff:	ff 4a 1c             	decl   0x1c(%edx)                     
bool _Protected_heap_Get_information(                                 
  10df02:	56                   	push   %esi                           
  10df03:	9d                   	popf                                  
  10df04:	eb 23                	jmp    10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
 *  in the specified heap.                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header.                       
 *  @param[in] info pointer to the free block information.            
 *                                                                    
 *  @return free block information filled in.                         
  10df06:	8b 59 5c             	mov    0x5c(%ecx),%ebx                
  10df09:	39 d3                	cmp    %edx,%ebx                      
  10df0b:	75 20                	jne    10df2d <_CORE_mutex_Seize_interrupt_trylock+0xcd>
 */                                                                   
  10df0d:	8b 41 40             	mov    0x40(%ecx),%eax                
  10df10:	85 c0                	test   %eax,%eax                      
  10df12:	74 05                	je     10df19 <_CORE_mutex_Seize_interrupt_trylock+0xb9>
  10df14:	48                   	dec    %eax                           
  10df15:	75 16                	jne    10df2d <_CORE_mutex_Seize_interrupt_trylock+0xcd>
  10df17:	eb 07                	jmp    10df20 <_CORE_mutex_Seize_interrupt_trylock+0xc0>
bool _Protected_heap_Get_free_information(                            
  Heap_Control        *the_heap,                                      
  10df19:	ff 41 54             	incl   0x54(%ecx)                     
  Heap_Information    *info                                           
  10df1c:	56                   	push   %esi                           
  10df1d:	9d                   	popf                                  
  10df1e:	eb 09                	jmp    10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
);                                                                    
                                                                      
#ifdef __cplusplus                                                    
  10df20:	c7 43 34 02 00 00 00 	movl   $0x2,0x34(%ebx)                
}                                                                     
  10df27:	56                   	push   %esi                           
  10df28:	9d                   	popf                                  
  10df29:	31 c0                	xor    %eax,%eax                      
  10df2b:	eb 05                	jmp    10df32 <_CORE_mutex_Seize_interrupt_trylock+0xd2>
  10df2d:	b8 01 00 00 00       	mov    $0x1,%eax                      
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}                                                                     
  10df32:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10df35:	5b                   	pop    %ebx                           
  10df36:	5e                   	pop    %esi                           
  10df37:	c9                   	leave                                 
  10df38:	c3                   	ret                                   
                                                                      

00109dc4 <_CORE_mutex_Surrender>: CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) {
  109dc4:	55                   	push   %ebp                           
  109dc5:	89 e5                	mov    %esp,%ebp                      
  109dc7:	53                   	push   %ebx                           
  109dc8:	83 ec 04             	sub    $0x4,%esp                      
  109dcb:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  Thread_Control *the_thread;                                         
  Thread_Control *holder;                                             
#ifdef __RTEMS_STRICT_ORDER_MUTEX__                                   
  Chain_Node *first_node;                                             
#endif                                                                
  holder    = the_mutex->holder;                                      
  109dce:	8b 4b 5c             	mov    0x5c(%ebx),%ecx                
   *  allowed when the mutex in quetion is FIFO or simple Priority    
   *  discipline.  But Priority Ceiling or Priority Inheritance mutexes
   *  must be released by the thread which acquired them.             
   */                                                                 
                                                                      
  if ( the_mutex->Attributes.only_owner_release ) {                   
  109dd1:	80 7b 44 00          	cmpb   $0x0,0x44(%ebx)                
  109dd5:	74 11                	je     109de8 <_CORE_mutex_Surrender+0x24>
    if ( !_Thread_Is_executing( holder ) )                            
  109dd7:	b8 03 00 00 00       	mov    $0x3,%eax                      
  109ddc:	3b 0d 58 d8 11 00    	cmp    0x11d858,%ecx                  
  109de2:	0f 85 cb 00 00 00    	jne    109eb3 <_CORE_mutex_Surrender+0xef>
      return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;                 
  }                                                                   
                                                                      
  /* XXX already unlocked -- not right status */                      
                                                                      
  if ( !the_mutex->nest_count )                                       
  109de8:	8b 43 54             	mov    0x54(%ebx),%eax                
  109deb:	85 c0                	test   %eax,%eax                      
  109ded:	0f 84 be 00 00 00    	je     109eb1 <_CORE_mutex_Surrender+0xed>
    return CORE_MUTEX_STATUS_SUCCESSFUL;                              
                                                                      
  the_mutex->nest_count--;                                            
  109df3:	48                   	dec    %eax                           
  109df4:	89 43 54             	mov    %eax,0x54(%ebx)                
                                                                      
  if ( the_mutex->nest_count != 0 ) {                                 
  109df7:	85 c0                	test   %eax,%eax                      
  109df9:	74 17                	je     109e12 <_CORE_mutex_Surrender+0x4e>
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {          
  109dfb:	8b 53 40             	mov    0x40(%ebx),%edx                
  109dfe:	85 d2                	test   %edx,%edx                      
  109e00:	0f 84 ab 00 00 00    	je     109eb1 <_CORE_mutex_Surrender+0xed><== ALWAYS TAKEN
  109e06:	b8 02 00 00 00       	mov    $0x2,%eax                      <== NOT EXECUTED
  109e0b:	4a                   	dec    %edx                           <== NOT EXECUTED
  109e0c:	0f 84 a1 00 00 00    	je     109eb3 <_CORE_mutex_Surrender+0xef><== NOT EXECUTED
                                                                      
/**                                                                   
 *  This function attempts to allocate a memory block of @a size bytes from
 *  @a the_heap so that the start of the user memory is aligned on the
 *  @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
 *  Any other value of @a alignment is taken "as is", i.e., even odd  
  109e12:	8b 43 48             	mov    0x48(%ebx),%eax                
                                                                      
  /*                                                                  
   *  Formally release the mutex before possibly transferring it to a 
   *  blocked thread.                                                 
   */                                                                 
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||   
  109e15:	83 f8 02             	cmp    $0x2,%eax                      
  109e18:	74 05                	je     109e1f <_CORE_mutex_Surrender+0x5b>
  109e1a:	83 f8 03             	cmp    $0x3,%eax                      
  109e1d:	75 03                	jne    109e22 <_CORE_mutex_Surrender+0x5e>
      the_mutex->nest_count++;                                        
      return CORE_MUTEX_RELEASE_NOT_ORDER;                            
    }                                                                 
    first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);   
#endif                                                                
    holder->resource_count--;                                         
  109e1f:	ff 49 1c             	decl   0x1c(%ecx)                     
  }                                                                   
  the_mutex->holder    = NULL;                                        
  109e22:	c7 43 5c 00 00 00 00 	movl   $0x0,0x5c(%ebx)                
  the_mutex->holder_id = 0;                                           
  109e29:	c7 43 60 00 00 00 00 	movl   $0x0,0x60(%ebx)                
  109e30:	8b 43 48             	mov    0x48(%ebx),%eax                
  /*                                                                  
   *  Whether or not someone is waiting for the mutex, an             
   *  inherited priority must be lowered if this is the last          
   *  mutex (i.e. resource) this task has.                            
   */                                                                 
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||   
  109e33:	83 f8 02             	cmp    $0x2,%eax                      
  109e36:	74 05                	je     109e3d <_CORE_mutex_Surrender+0x79>
  109e38:	83 f8 03             	cmp    $0x3,%eax                      
  109e3b:	75 1b                	jne    109e58 <_CORE_mutex_Surrender+0x94>
       _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {  
#ifdef __RTEMS_STRICT_ORDER_MUTEX__                                   
    if(the_mutex->queue.priority_before != holder->current_priority)  
      _Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE);
#endif                                                                
    if ( holder->resource_count == 0 &&                               
  109e3d:	83 79 1c 00          	cmpl   $0x0,0x1c(%ecx)                
  109e41:	75 15                	jne    109e58 <_CORE_mutex_Surrender+0x94>
  109e43:	8b 41 18             	mov    0x18(%ecx),%eax                
  109e46:	3b 41 14             	cmp    0x14(%ecx),%eax                
  109e49:	74 0d                	je     109e58 <_CORE_mutex_Surrender+0x94>
         holder->real_priority != holder->current_priority ) {        
      _Thread_Change_priority( holder, holder->real_priority, TRUE ); 
  109e4b:	52                   	push   %edx                           
  109e4c:	6a 01                	push   $0x1                           
  109e4e:	50                   	push   %eax                           
  109e4f:	51                   	push   %ecx                           
  109e50:	e8 97 0b 00 00       	call   10a9ec <_Thread_Change_priority>
  109e55:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Now we check if another thread was waiting for this mutex.  If so,
   *  transfer the mutex to that thread.                              
   */                                                                 
  if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
  109e58:	83 ec 0c             	sub    $0xc,%esp                      
  109e5b:	53                   	push   %ebx                           
  109e5c:	e8 63 13 00 00       	call   10b1c4 <_Thread_queue_Dequeue> 
  109e61:	89 c2                	mov    %eax,%edx                      
  109e63:	83 c4 10             	add    $0x10,%esp                     
  109e66:	85 c0                	test   %eax,%eax                      
  109e68:	74 40                	je     109eaa <_CORE_mutex_Surrender+0xe6>
                                                                      
    } else                                                            
#endif                                                                
    {                                                                 
                                                                      
      the_mutex->holder     = the_thread;                             
  109e6a:	89 43 5c             	mov    %eax,0x5c(%ebx)                
      the_mutex->holder_id  = the_thread->Object.id;                  
  109e6d:	8b 40 08             	mov    0x8(%eax),%eax                 
  109e70:	89 43 60             	mov    %eax,0x60(%ebx)                
      the_mutex->nest_count = 1;                                      
  109e73:	c7 43 54 01 00 00 00 	movl   $0x1,0x54(%ebx)                
                                                                      
      switch ( the_mutex->Attributes.discipline ) {                   
  109e7a:	8b 43 48             	mov    0x48(%ebx),%eax                
  109e7d:	83 f8 02             	cmp    $0x2,%eax                      
  109e80:	74 07                	je     109e89 <_CORE_mutex_Surrender+0xc5>
  109e82:	83 f8 03             	cmp    $0x3,%eax                      
  109e85:	75 2a                	jne    109eb1 <_CORE_mutex_Surrender+0xed>
  109e87:	eb 05                	jmp    109e8e <_CORE_mutex_Surrender+0xca>
        case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:                 
#ifdef __RTEMS_STRICT_ORDER_MUTEX__                                   
	  _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
	  the_mutex->queue.priority_before = the_thread->current_priority;   
#endif                                                                
          the_thread->resource_count++;                               
  109e89:	ff 42 1c             	incl   0x1c(%edx)                     
  109e8c:	eb 23                	jmp    109eb1 <_CORE_mutex_Surrender+0xed>
        case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:                 
#ifdef __RTEMS_STRICT_ORDER_MUTEX__                                   
	  _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
	  the_mutex->queue.priority_before = the_thread->current_priority;   
#endif                                                                
          the_thread->resource_count++;                               
  109e8e:	ff 42 1c             	incl   0x1c(%edx)                     
          if (the_mutex->Attributes.priority_ceiling <                
  109e91:	8b 43 4c             	mov    0x4c(%ebx),%eax                
  109e94:	3b 42 14             	cmp    0x14(%edx),%eax                
  109e97:	73 18                	jae    109eb1 <_CORE_mutex_Surrender+0xed><== NEVER TAKEN
              the_thread->current_priority){                          
              _Thread_Change_priority(                                
  109e99:	51                   	push   %ecx                           
  109e9a:	6a 00                	push   $0x0                           
  109e9c:	50                   	push   %eax                           
  109e9d:	52                   	push   %edx                           
  109e9e:	e8 49 0b 00 00       	call   10a9ec <_Thread_Change_priority>
  109ea3:	31 c0                	xor    %eax,%eax                      
  109ea5:	83 c4 10             	add    $0x10,%esp                     
  109ea8:	eb 09                	jmp    109eb3 <_CORE_mutex_Surrender+0xef>
          }                                                           
          break;                                                      
      }                                                               
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
  109eaa:	c7 43 50 01 00 00 00 	movl   $0x1,0x50(%ebx)                
  109eb1:	31 c0                	xor    %eax,%eax                      
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
}                                                                     
  109eb3:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109eb6:	c9                   	leave                                 
  109eb7:	c3                   	ret                                   
                                                                      

00109f04 <_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 ) {
  109f04:	55                   	push   %ebp                           
  109f05:	89 e5                	mov    %esp,%ebp                      
  109f07:	53                   	push   %ebx                           
  109f08:	83 ec 10             	sub    $0x10,%esp                     
  109f0b:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
  109f0e:	53                   	push   %ebx                           
  109f0f:	e8 b0 12 00 00       	call   10b1c4 <_Thread_queue_Dequeue> 
  109f14:	83 c4 10             	add    $0x10,%esp                     
  109f17:	31 d2                	xor    %edx,%edx                      
  109f19:	85 c0                	test   %eax,%eax                      
  109f1b:	75 18                	jne    109f35 <_CORE_semaphore_Surrender+0x31>
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_semaphore_mp_support) ( the_thread, id );                 
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
  109f1d:	9c                   	pushf                                 
  109f1e:	fa                   	cli                                   
  109f1f:	59                   	pop    %ecx                           
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
  109f20:	8b 43 48             	mov    0x48(%ebx),%eax                
  109f23:	ba 04 00 00 00       	mov    $0x4,%edx                      
  109f28:	3b 43 40             	cmp    0x40(%ebx),%eax                
  109f2b:	73 06                	jae    109f33 <_CORE_semaphore_Surrender+0x2f><== NEVER TAKEN
        the_semaphore->count += 1;                                    
  109f2d:	40                   	inc    %eax                           
  109f2e:	89 43 48             	mov    %eax,0x48(%ebx)                
  109f31:	31 d2                	xor    %edx,%edx                      
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
  109f33:	51                   	push   %ecx                           
  109f34:	9d                   	popf                                  
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
  109f35:	89 d0                	mov    %edx,%eax                      
  109f37:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109f3a:	c9                   	leave                                 
  109f3b:	c3                   	ret                                   
                                                                      

0010a750 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) {
  10a750:	55                   	push   %ebp                           
  10a751:	89 e5                	mov    %esp,%ebp                      
  10a753:	53                   	push   %ebx                           
  10a754:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
  10a757:	9c                   	pushf                                 
  10a758:	fa                   	cli                                   
  10a759:	5b                   	pop    %ebx                           
                                                                      
    /*                                                                
     *  It must locked before it can be unlocked.                     
     */                                                               
    if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {             
  10a75a:	8b 41 04             	mov    0x4(%ecx),%eax                 
  10a75d:	85 c0                	test   %eax,%eax                      
  10a75f:	75 06                	jne    10a767 <_CORE_spinlock_Release+0x17>
      _ISR_Enable( level );                                           
  10a761:	53                   	push   %ebx                           
  10a762:	9d                   	popf                                  
  10a763:	b0 06                	mov    $0x6,%al                       
  10a765:	eb 2f                	jmp    10a796 <_CORE_spinlock_Release+0x46>
    }                                                                 
                                                                      
    /*                                                                
     *  It must locked by the current thread before it can be unlocked.
     */                                                               
    if ( the_spinlock->holder != _Thread_Executing->Object.id ) {     
  10a767:	8b 51 0c             	mov    0xc(%ecx),%edx                 
  10a76a:	a1 d8 e7 11 00       	mov    0x11e7d8,%eax                  
  10a76f:	3b 50 08             	cmp    0x8(%eax),%edx                 
  10a772:	74 09                	je     10a77d <_CORE_spinlock_Release+0x2d><== ALWAYS TAKEN
      _ISR_Enable( level );                                           
  10a774:	53                   	push   %ebx                           <== NOT EXECUTED
  10a775:	9d                   	popf                                  <== NOT EXECUTED
  10a776:	b8 02 00 00 00       	mov    $0x2,%eax                      <== NOT EXECUTED
  10a77b:	eb 19                	jmp    10a796 <_CORE_spinlock_Release+0x46><== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     *  Let it be unlocked.                                           
     */                                                               
    the_spinlock->users -= 1;                                         
  10a77d:	8b 41 08             	mov    0x8(%ecx),%eax                 
  10a780:	48                   	dec    %eax                           
  10a781:	89 41 08             	mov    %eax,0x8(%ecx)                 
    the_spinlock->lock   = CORE_SPINLOCK_UNLOCKED;                    
  10a784:	c7 41 04 00 00 00 00 	movl   $0x0,0x4(%ecx)                 
    the_spinlock->holder = 0;                                         
  10a78b:	c7 41 0c 00 00 00 00 	movl   $0x0,0xc(%ecx)                 
                                                                      
  _ISR_Enable( level );                                               
  10a792:	53                   	push   %ebx                           
  10a793:	9d                   	popf                                  
  10a794:	31 c0                	xor    %eax,%eax                      
  return CORE_SPINLOCK_SUCCESSFUL;                                    
}                                                                     
  10a796:	5b                   	pop    %ebx                           
  10a797:	c9                   	leave                                 
  10a798:	c3                   	ret                                   
                                                                      

0010a79c <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, bool wait, Watchdog_Interval timeout ) {
  10a79c:	55                   	push   %ebp                           
  10a79d:	89 e5                	mov    %esp,%ebp                      
  10a79f:	57                   	push   %edi                           
  10a7a0:	56                   	push   %esi                           
  10a7a1:	53                   	push   %ebx                           
  10a7a2:	83 ec 0c             	sub    $0xc,%esp                      
  10a7a5:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a7a8:	8b 7d 10             	mov    0x10(%ebp),%edi                
  10a7ab:	8a 45 0c             	mov    0xc(%ebp),%al                  
  10a7ae:	88 45 f3             	mov    %al,-0xd(%ebp)                 
  ISR_Level level;                                                    
  Watchdog_Interval       limit = _Watchdog_Ticks_since_boot + timeout;
  10a7b1:	a1 68 e8 11 00       	mov    0x11e868,%eax                  
  10a7b6:	8d 34 07             	lea    (%edi,%eax,1),%esi             
                                                                      
  _ISR_Disable( level );                                              
  10a7b9:	9c                   	pushf                                 
  10a7ba:	fa                   	cli                                   
  10a7bb:	59                   	pop    %ecx                           
    if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&              
  10a7bc:	8b 43 04             	mov    0x4(%ebx),%eax                 
  10a7bf:	48                   	dec    %eax                           
  10a7c0:	75 16                	jne    10a7d8 <_CORE_spinlock_Wait+0x3c>
  10a7c2:	8b 53 0c             	mov    0xc(%ebx),%edx                 
  10a7c5:	a1 d8 e7 11 00       	mov    0x11e7d8,%eax                  
  10a7ca:	3b 50 08             	cmp    0x8(%eax),%edx                 
  10a7cd:	75 09                	jne    10a7d8 <_CORE_spinlock_Wait+0x3c>
         (the_spinlock->holder == _Thread_Executing->Object.id) ) {   
      _ISR_Enable( level );                                           
  10a7cf:	51                   	push   %ecx                           
  10a7d0:	9d                   	popf                                  
  10a7d1:	b8 01 00 00 00       	mov    $0x1,%eax                      
  10a7d6:	eb 70                	jmp    10a848 <_CORE_spinlock_Wait+0xac>
      return CORE_SPINLOCK_HOLDER_RELOCKING;                          
    }                                                                 
    the_spinlock->users += 1;                                         
  10a7d8:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10a7db:	40                   	inc    %eax                           
  10a7dc:	89 43 08             	mov    %eax,0x8(%ebx)                 
    for ( ;; ) {                                                      
      if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {           
  10a7df:	8b 43 04             	mov    0x4(%ebx),%eax                 
  10a7e2:	85 c0                	test   %eax,%eax                      
  10a7e4:	75 18                	jne    10a7fe <_CORE_spinlock_Wait+0x62>
        the_spinlock->lock = CORE_SPINLOCK_LOCKED;                    
  10a7e6:	c7 43 04 01 00 00 00 	movl   $0x1,0x4(%ebx)                 
        the_spinlock->holder = _Thread_Executing->Object.id;          
  10a7ed:	a1 d8 e7 11 00       	mov    0x11e7d8,%eax                  
  10a7f2:	8b 40 08             	mov    0x8(%eax),%eax                 
  10a7f5:	89 43 0c             	mov    %eax,0xc(%ebx)                 
        _ISR_Enable( level );                                         
  10a7f8:	51                   	push   %ecx                           
  10a7f9:	9d                   	popf                                  
  10a7fa:	31 c0                	xor    %eax,%eax                      
  10a7fc:	eb 4a                	jmp    10a848 <_CORE_spinlock_Wait+0xac>
      }                                                               
                                                                      
      /*                                                              
       *  Spinlock is unavailable.  If not willing to wait, return.   
       */                                                             
      if ( !wait ) {                                                  
  10a7fe:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  10a802:	75 10                	jne    10a814 <_CORE_spinlock_Wait+0x78><== ALWAYS TAKEN
        the_spinlock->users -= 1;                                     
  10a804:	8b 43 08             	mov    0x8(%ebx),%eax                 <== NOT EXECUTED
  10a807:	48                   	dec    %eax                           <== NOT EXECUTED
  10a808:	89 43 08             	mov    %eax,0x8(%ebx)                 <== NOT EXECUTED
        _ISR_Enable( level );                                         
  10a80b:	51                   	push   %ecx                           <== NOT EXECUTED
  10a80c:	9d                   	popf                                  <== NOT EXECUTED
  10a80d:	b8 05 00 00 00       	mov    $0x5,%eax                      <== NOT EXECUTED
  10a812:	eb 34                	jmp    10a848 <_CORE_spinlock_Wait+0xac><== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       *  They are willing to wait but there could be a timeout.      
       */                                                             
      if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) {       
  10a814:	85 ff                	test   %edi,%edi                      
  10a816:	74 19                	je     10a831 <_CORE_spinlock_Wait+0x95><== ALWAYS TAKEN
  10a818:	a1 68 e8 11 00       	mov    0x11e868,%eax                  <== NOT EXECUTED
  10a81d:	39 c6                	cmp    %eax,%esi                      <== NOT EXECUTED
  10a81f:	77 10                	ja     10a831 <_CORE_spinlock_Wait+0x95><== NOT EXECUTED
        the_spinlock->users -= 1;                                     
  10a821:	8b 43 08             	mov    0x8(%ebx),%eax                 <== NOT EXECUTED
  10a824:	48                   	dec    %eax                           <== NOT EXECUTED
  10a825:	89 43 08             	mov    %eax,0x8(%ebx)                 <== NOT EXECUTED
        _ISR_Enable( level );                                         
  10a828:	51                   	push   %ecx                           <== NOT EXECUTED
  10a829:	9d                   	popf                                  <== NOT EXECUTED
  10a82a:	b8 03 00 00 00       	mov    $0x3,%eax                      <== NOT EXECUTED
  10a82f:	eb 17                	jmp    10a848 <_CORE_spinlock_Wait+0xac><== NOT EXECUTED
       *                                                              
       *  A spinlock cannot be deleted while it is being used so we are
       *  safe from deletion.                                         
       */                                                             
                                                                      
       _ISR_Enable( level );                                          
  10a831:	51                   	push   %ecx                           
  10a832:	9d                   	popf                                  
       /* An ISR could occur here */                                  
                                                                      
       _Thread_Enable_dispatch();                                     
  10a833:	e8 68 0f 00 00       	call   10b7a0 <_Thread_Enable_dispatch>
  10a838:	a1 18 e7 11 00       	mov    0x11e718,%eax                  
  10a83d:	40                   	inc    %eax                           
  10a83e:	a3 18 e7 11 00       	mov    %eax,0x11e718                  
       /* Another thread could get dispatched here */                 
                                                                      
       /* Reenter the critical sections so we can attempt the lock again. */
       _Thread_Disable_dispatch();                                    
                                                                      
       _ISR_Disable( level );                                         
  10a843:	9c                   	pushf                                 
  10a844:	fa                   	cli                                   
  10a845:	59                   	pop    %ecx                           
  10a846:	eb 97                	jmp    10a7df <_CORE_spinlock_Wait+0x43>
    }                                                                 
                                                                      
}                                                                     
  10a848:	83 c4 0c             	add    $0xc,%esp                      
  10a84b:	5b                   	pop    %ebx                           
  10a84c:	5e                   	pop    %esi                           
  10a84d:	5f                   	pop    %edi                           
  10a84e:	c9                   	leave                                 
  10a84f:	c3                   	ret                                   
                                                                      

0010dcf1 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) {
  10dcf1:	55                   	push   %ebp                           <== NOT EXECUTED
  10dcf2:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10dcf4:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10dcf7:	85 05 5c d8 11 00    	test   %eax,0x11d85c                  <== NOT EXECUTED
  10dcfd:	0f 95 c0             	setne  %al                            <== NOT EXECUTED
  return (_Debug_Level & level) ? true : false;                       
}                                                                     
  10dd00:	c9                   	leave                                 <== NOT EXECUTED
  10dd01:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00108bcc <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) {
  108bcc:	55                   	push   %ebp                           
  108bcd:	89 e5                	mov    %esp,%ebp                      
  108bcf:	57                   	push   %edi                           
  108bd0:	56                   	push   %esi                           
  108bd1:	53                   	push   %ebx                           
  108bd2:	83 ec 0c             	sub    $0xc,%esp                      
  108bd5:	8b 45 08             	mov    0x8(%ebp),%eax                 
  108bd8:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  108bdb:	8b 55 10             	mov    0x10(%ebp),%edx                
  108bde:	89 55 ec             	mov    %edx,-0x14(%ebp)               
  108be1:	8b 4d 14             	mov    0x14(%ebp),%ecx                
  108be4:	89 4d e8             	mov    %ecx,-0x18(%ebp)               
  rtems_event_set                   pending_events;                   
  ISR_Level                         level;                            
  RTEMS_API_Control                *api;                              
  Thread_blocking_operation_States  sync_state;                       
                                                                      
  executing = _Thread_Executing;                                      
  108be7:	8b 1d 58 d8 11 00    	mov    0x11d858,%ebx                  
  executing->Wait.return_code = RTEMS_SUCCESSFUL;                     
  108bed:	c7 43 34 00 00 00 00 	movl   $0x0,0x34(%ebx)                
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  108bf4:	8b 93 f4 00 00 00    	mov    0xf4(%ebx),%edx                
  108bfa:	89 55 f0             	mov    %edx,-0x10(%ebp)               
                                                                      
  _ISR_Disable( level );                                              
  108bfd:	9c                   	pushf                                 
  108bfe:	fa                   	cli                                   
  108bff:	5f                   	pop    %edi                           
  pending_events = api->pending_events;                               
  108c00:	8b 4d f0             	mov    -0x10(%ebp),%ecx               
  108c03:	8b 11                	mov    (%ecx),%edx                    
  seized_events  = _Event_sets_Get( pending_events, event_in );       
                                                                      
  if ( !_Event_sets_Is_empty( seized_events ) &&                      
  108c05:	89 c1                	mov    %eax,%ecx                      
  108c07:	21 d1                	and    %edx,%ecx                      
  108c09:	74 23                	je     108c2e <_Event_Seize+0x62>     
  108c0b:	39 c1                	cmp    %eax,%ecx                      
  108c0d:	74 08                	je     108c17 <_Event_Seize+0x4b>     
  108c0f:	f7 c6 02 00 00 00    	test   $0x2,%esi                      
  108c15:	74 17                	je     108c2e <_Event_Seize+0x62>     <== NEVER TAKEN
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
    api->pending_events =                                             
  108c17:	89 c8                	mov    %ecx,%eax                      
  108c19:	f7 d0                	not    %eax                           
  108c1b:	21 d0                	and    %edx,%eax                      
  108c1d:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  108c20:	89 02                	mov    %eax,(%edx)                    
      _Event_sets_Clear( pending_events, seized_events );             
    _ISR_Enable( level );                                             
  108c22:	57                   	push   %edi                           
  108c23:	9d                   	popf                                  
    *event_out = seized_events;                                       
  108c24:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  108c27:	89 08                	mov    %ecx,(%eax)                    
  108c29:	e9 ad 00 00 00       	jmp    108cdb <_Event_Seize+0x10f>    
    return;                                                           
  }                                                                   
                                                                      
  if ( _Options_Is_no_wait( option_set ) ) {                          
  108c2e:	f7 c6 01 00 00 00    	test   $0x1,%esi                      
  108c34:	74 13                	je     108c49 <_Event_Seize+0x7d>     
    _ISR_Enable( level );                                             
  108c36:	57                   	push   %edi                           
  108c37:	9d                   	popf                                  
    executing->Wait.return_code = RTEMS_UNSATISFIED;                  
  108c38:	c7 43 34 0d 00 00 00 	movl   $0xd,0x34(%ebx)                
    *event_out = seized_events;                                       
  108c3f:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  108c42:	89 0a                	mov    %ecx,(%edx)                    
  108c44:	e9 92 00 00 00       	jmp    108cdb <_Event_Seize+0x10f>    
    return;                                                           
  }                                                                   
                                                                      
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;     
  108c49:	c7 05 8c e0 11 00 01 	movl   $0x1,0x11e08c                  
  108c50:	00 00 00                                                    
                                                                      
  executing->Wait.option            = (uint32_t) option_set;          
  108c53:	89 73 30             	mov    %esi,0x30(%ebx)                
  executing->Wait.count             = (uint32_t) event_in;            
  108c56:	89 43 24             	mov    %eax,0x24(%ebx)                
  executing->Wait.return_argument   = event_out;                      
  108c59:	8b 4d e8             	mov    -0x18(%ebp),%ecx               
  108c5c:	89 4b 28             	mov    %ecx,0x28(%ebx)                
                                                                      
  _ISR_Enable( level );                                               
  108c5f:	57                   	push   %edi                           
  108c60:	9d                   	popf                                  
                                                                      
  if ( ticks ) {                                                      
  108c61:	83 7d ec 00          	cmpl   $0x0,-0x14(%ebp)               
  108c65:	74 34                	je     108c9b <_Event_Seize+0xcf>     
    _Watchdog_Initialize(                                             
  108c67:	8b 43 08             	mov    0x8(%ebx),%eax                 
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  108c6a:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  108c71:	c7 43 64 1c 8e 10 00 	movl   $0x108e1c,0x64(%ebx)           
 *  @param[in] starting_address is the starting address of the memory for
  108c78:	89 43 68             	mov    %eax,0x68(%ebx)                
 *         the heap                                                   
  108c7b:	c7 43 6c 00 00 00 00 	movl   $0x0,0x6c(%ebx)                
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  108c82:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  108c85:	89 43 54             	mov    %eax,0x54(%ebx)                
  void                *starting_address,                              
  size_t              *size                                           
  108c88:	52                   	push   %edx                           
  108c89:	52                   	push   %edx                           
  108c8a:	8d 43 48             	lea    0x48(%ebx),%eax                
  108c8d:	50                   	push   %eax                           
  108c8e:	68 78 d8 11 00       	push   $0x11d878                      
  108c93:	e8 90 2f 00 00       	call   10bc28 <_Watchdog_Insert>      
  108c98:	83 c4 10             	add    $0x10,%esp                     
      NULL                                                            
    );                                                                
    _Watchdog_Insert_ticks( &executing->Timer, ticks );               
  }                                                                   
                                                                      
  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );           
  108c9b:	50                   	push   %eax                           
  108c9c:	50                   	push   %eax                           
  108c9d:	68 00 01 00 00       	push   $0x100                         
  108ca2:	53                   	push   %ebx                           
  108ca3:	e8 d4 29 00 00       	call   10b67c <_Thread_Set_state>     
                                                                      
  _ISR_Disable( level );                                              
  108ca8:	9c                   	pushf                                 
  108ca9:	fa                   	cli                                   
  108caa:	5a                   	pop    %edx                           
                                                                      
  sync_state = _Event_Sync_state;                                     
  108cab:	a1 8c e0 11 00       	mov    0x11e08c,%eax                  
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;         
  108cb0:	c7 05 8c e0 11 00 00 	movl   $0x0,0x11e08c                  
  108cb7:	00 00 00                                                    
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {   
  108cba:	83 c4 10             	add    $0x10,%esp                     
  108cbd:	83 f8 01             	cmp    $0x1,%eax                      
  108cc0:	75 04                	jne    108cc6 <_Event_Seize+0xfa>     
    _ISR_Enable( level );                                             
  108cc2:	52                   	push   %edx                           
  108cc3:	9d                   	popf                                  
  108cc4:	eb 15                	jmp    108cdb <_Event_Seize+0x10f>    
   *  An interrupt completed the thread's blocking request.           
   *  The blocking thread was satisfied by an ISR or timed out.       
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  _Thread_blocking_operation_Cancel( sync_state, executing, level );  
  108cc6:	89 55 10             	mov    %edx,0x10(%ebp)                
  108cc9:	89 5d 0c             	mov    %ebx,0xc(%ebp)                 
  108ccc:	89 45 08             	mov    %eax,0x8(%ebp)                 
}                                                                     
  108ccf:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108cd2:	5b                   	pop    %ebx                           
  108cd3:	5e                   	pop    %esi                           
  108cd4:	5f                   	pop    %edi                           
  108cd5:	c9                   	leave                                 
   *  An interrupt completed the thread's blocking request.           
   *  The blocking thread was satisfied by an ISR or timed out.       
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  _Thread_blocking_operation_Cancel( sync_state, executing, level );  
  108cd6:	e9 c5 1c 00 00       	jmp    10a9a0 <_Thread_blocking_operation_Cancel>
}                                                                     
  108cdb:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108cde:	5b                   	pop    %ebx                           
  108cdf:	5e                   	pop    %esi                           
  108ce0:	5f                   	pop    %edi                           
  108ce1:	c9                   	leave                                 
  108ce2:	c3                   	ret                                   
                                                                      

00108d30 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) {
  108d30:	55                   	push   %ebp                           
  108d31:	89 e5                	mov    %esp,%ebp                      
  108d33:	57                   	push   %edi                           
  108d34:	56                   	push   %esi                           
  108d35:	53                   	push   %ebx                           
  108d36:	83 ec 0c             	sub    $0xc,%esp                      
  108d39:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  rtems_event_set     event_condition;                                
  rtems_event_set     seized_events;                                  
  rtems_option        option_set;                                     
  RTEMS_API_Control  *api;                                            
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
  108d3c:	8b 83 f4 00 00 00    	mov    0xf4(%ebx),%eax                
  108d42:	89 45 f0             	mov    %eax,-0x10(%ebp)               
                                                                      
  option_set = (rtems_option) the_thread->Wait.option;                
  108d45:	8b 53 30             	mov    0x30(%ebx),%edx                
  108d48:	89 55 ec             	mov    %edx,-0x14(%ebp)               
                                                                      
  _ISR_Disable( level );                                              
  108d4b:	9c                   	pushf                                 
  108d4c:	fa                   	cli                                   
  108d4d:	5f                   	pop    %edi                           
  pending_events  = api->pending_events;                              
  108d4e:	8b 30                	mov    (%eax),%esi                    
  event_condition = (rtems_event_set) the_thread->Wait.count;         
  108d50:	8b 53 24             	mov    0x24(%ebx),%edx                
  seized_events = _Event_sets_Get( pending_events, event_condition ); 
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
  108d53:	89 d1                	mov    %edx,%ecx                      
  108d55:	21 f1                	and    %esi,%ecx                      
  108d57:	75 07                	jne    108d60 <_Event_Surrender+0x30> 
    _ISR_Enable( level );                                             
  108d59:	57                   	push   %edi                           
  108d5a:	9d                   	popf                                  
  108d5b:	e9 b1 00 00 00       	jmp    108e11 <_Event_Surrender+0xe1> 
                                                                      
  /*                                                                  
   *  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() &&                                       
  108d60:	a1 34 d8 11 00       	mov    0x11d834,%eax                  
  108d65:	85 c0                	test   %eax,%eax                      
  108d67:	74 49                	je     108db2 <_Event_Surrender+0x82> 
  108d69:	3b 1d 58 d8 11 00    	cmp    0x11d858,%ebx                  
  108d6f:	75 41                	jne    108db2 <_Event_Surrender+0x82> <== NEVER TAKEN
  108d71:	a1 8c e0 11 00       	mov    0x11e08c,%eax                  
  108d76:	48                   	dec    %eax                           
  108d77:	74 0a                	je     108d83 <_Event_Surrender+0x53> <== ALWAYS TAKEN
  108d79:	a1 8c e0 11 00       	mov    0x11e08c,%eax                  <== NOT EXECUTED
  108d7e:	83 f8 02             	cmp    $0x2,%eax                      <== NOT EXECUTED
  108d81:	75 2f                	jne    108db2 <_Event_Surrender+0x82> <== NOT EXECUTED
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ||
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { 
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
  108d83:	39 d1                	cmp    %edx,%ecx                      
  108d85:	74 06                	je     108d8d <_Event_Surrender+0x5d> <== ALWAYS TAKEN
  108d87:	f6 45 ec 02          	testb  $0x2,-0x14(%ebp)               <== NOT EXECUTED
  108d8b:	74 21                	je     108dae <_Event_Surrender+0x7e> <== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
  108d8d:	89 c8                	mov    %ecx,%eax                      
  108d8f:	f7 d0                	not    %eax                           
  108d91:	21 f0                	and    %esi,%eax                      
  108d93:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  108d96:	89 02                	mov    %eax,(%edx)                    
      the_thread->Wait.count = 0;                                     
  108d98:	c7 43 24 00 00 00 00 	movl   $0x0,0x24(%ebx)                
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
  108d9f:	8b 43 28             	mov    0x28(%ebx),%eax                
  108da2:	89 08                	mov    %ecx,(%eax)                    
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;        
  108da4:	c7 05 8c e0 11 00 03 	movl   $0x3,0x11e08c                  
  108dab:	00 00 00                                                    
    }                                                                 
    _ISR_Enable( level );                                             
  108dae:	57                   	push   %edi                           
  108daf:	9d                   	popf                                  
  108db0:	eb 5f                	jmp    108e11 <_Event_Surrender+0xe1> 
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
  108db2:	f6 43 11 01          	testb  $0x1,0x11(%ebx)                
  108db6:	74 57                	je     108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
  108db8:	39 d1                	cmp    %edx,%ecx                      
  108dba:	74 06                	je     108dc2 <_Event_Surrender+0x92> 
  108dbc:	f6 45 ec 02          	testb  $0x2,-0x14(%ebp)               
  108dc0:	74 4d                	je     108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
  108dc2:	89 c8                	mov    %ecx,%eax                      
  108dc4:	f7 d0                	not    %eax                           
  108dc6:	21 f0                	and    %esi,%eax                      
  108dc8:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  108dcb:	89 02                	mov    %eax,(%edx)                    
      the_thread->Wait.count = 0;                                     
  108dcd:	c7 43 24 00 00 00 00 	movl   $0x0,0x24(%ebx)                
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
  108dd4:	8b 43 28             	mov    0x28(%ebx),%eax                
  108dd7:	89 08                	mov    %ecx,(%eax)                    
                                                                      
      _ISR_Flash( level );                                            
  108dd9:	57                   	push   %edi                           
  108dda:	9d                   	popf                                  
  108ddb:	fa                   	cli                                   
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
  108ddc:	83 7b 50 02          	cmpl   $0x2,0x50(%ebx)                
  108de0:	74 06                	je     108de8 <_Event_Surrender+0xb8> 
        _ISR_Enable( level );                                         
  108de2:	57                   	push   %edi                           
  108de3:	9d                   	popf                                  
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  108de4:	51                   	push   %ecx                           
  108de5:	51                   	push   %ecx                           
  108de6:	eb 17                	jmp    108dff <_Event_Surrender+0xcf> 
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
  108de8:	c7 43 50 03 00 00 00 	movl   $0x3,0x50(%ebx)                
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
  108def:	57                   	push   %edi                           
  108df0:	9d                   	popf                                  
        (void) _Watchdog_Remove( &the_thread->Timer );                
  108df1:	83 ec 0c             	sub    $0xc,%esp                      
  108df4:	8d 43 48             	lea    0x48(%ebx),%eax                
  108df7:	50                   	push   %eax                           
  108df8:	e8 43 2f 00 00       	call   10bd40 <_Watchdog_Remove>      
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  108dfd:	58                   	pop    %eax                           
  108dfe:	5a                   	pop    %edx                           
  108dff:	68 f8 ff 03 10       	push   $0x1003fff8                    
  108e04:	53                   	push   %ebx                           
  108e05:	e8 02 1d 00 00       	call   10ab0c <_Thread_Clear_state>   
  108e0a:	83 c4 10             	add    $0x10,%esp                     
  108e0d:	eb 02                	jmp    108e11 <_Event_Surrender+0xe1> 
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
  108e0f:	57                   	push   %edi                           <== NOT EXECUTED
  108e10:	9d                   	popf                                  <== NOT EXECUTED
}                                                                     
  108e11:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108e14:	5b                   	pop    %ebx                           
  108e15:	5e                   	pop    %esi                           
  108e16:	5f                   	pop    %edi                           
  108e17:	c9                   	leave                                 
  108e18:	c3                   	ret                                   
                                                                      

00108e1c <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) {
  108e1c:	55                   	push   %ebp                           
  108e1d:	89 e5                	mov    %esp,%ebp                      
  108e1f:	83 ec 20             	sub    $0x20,%esp                     
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
  ISR_Level          level;                                           
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  108e22:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  108e25:	50                   	push   %eax                           
  108e26:	ff 75 08             	pushl  0x8(%ebp)                      
  108e29:	e8 7e 20 00 00       	call   10aeac <_Thread_Get>           
  108e2e:	89 c2                	mov    %eax,%edx                      
  switch ( location ) {                                               
  108e30:	83 c4 10             	add    $0x10,%esp                     
  108e33:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  108e37:	75 5f                	jne    108e98 <_Event_Timeout+0x7c>   <== NEVER TAKEN
       *  this is the "timeout" transition.  After a request is satisfied,
       *  a timeout is not allowed to occur.                          
       */                                                             
                                                                      
                                                                      
      _ISR_Disable( level );                                          
  108e39:	9c                   	pushf                                 
  108e3a:	fa                   	cli                                   
  108e3b:	59                   	pop    %ecx                           
        if ( !the_thread->Wait.count ) {  /* verify thread is waiting */
  108e3c:	83 78 24 00          	cmpl   $0x0,0x24(%eax)                
  108e40:	75 0f                	jne    108e51 <_Event_Timeout+0x35>   <== ALWAYS TAKEN
  108e42:	a1 98 d7 11 00       	mov    0x11d798,%eax                  <== NOT EXECUTED
  108e47:	48                   	dec    %eax                           <== NOT EXECUTED
  108e48:	a3 98 d7 11 00       	mov    %eax,0x11d798                  <== NOT EXECUTED
          _Thread_Unnest_dispatch();                                  
          _ISR_Enable( level );                                       
  108e4d:	51                   	push   %ecx                           <== NOT EXECUTED
  108e4e:	9d                   	popf                                  <== NOT EXECUTED
  108e4f:	eb 47                	jmp    108e98 <_Event_Timeout+0x7c>   <== NOT EXECUTED
          return;                                                     
        }                                                             
                                                                      
        the_thread->Wait.count = 0;                                   
  108e51:	c7 40 24 00 00 00 00 	movl   $0x0,0x24(%eax)                
        if ( _Thread_Is_executing( the_thread ) ) {                   
  108e58:	3b 05 58 d8 11 00    	cmp    0x11d858,%eax                  
  108e5e:	75 14                	jne    108e74 <_Event_Timeout+0x58>   
          Thread_blocking_operation_States sync = _Event_Sync_state;  
  108e60:	a1 8c e0 11 00       	mov    0x11e08c,%eax                  
          if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||    
  108e65:	83 f8 01             	cmp    $0x1,%eax                      
  108e68:	77 0a                	ja     108e74 <_Event_Timeout+0x58>   <== NEVER TAKEN
               (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
  108e6a:	c7 05 8c e0 11 00 02 	movl   $0x2,0x11e08c                  
  108e71:	00 00 00                                                    
          }                                                           
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
  108e74:	c7 42 34 06 00 00 00 	movl   $0x6,0x34(%edx)                
      _ISR_Enable( level );                                           
  108e7b:	51                   	push   %ecx                           
  108e7c:	9d                   	popf                                  
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  108e7d:	50                   	push   %eax                           
  108e7e:	50                   	push   %eax                           
  108e7f:	68 f8 ff 03 10       	push   $0x1003fff8                    
  108e84:	52                   	push   %edx                           
  108e85:	e8 82 1c 00 00       	call   10ab0c <_Thread_Clear_state>   
  108e8a:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  108e8f:	48                   	dec    %eax                           
  108e90:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
  108e95:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
}                                                                     
  108e98:	c9                   	leave                                 
  108e99:	c3                   	ret                                   
                                                                      

0010df90 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) {
  10df90:	55                   	push   %ebp                           
  10df91:	89 e5                	mov    %esp,%ebp                      
  10df93:	57                   	push   %edi                           
  10df94:	56                   	push   %esi                           
  10df95:	53                   	push   %ebx                           
  10df96:	83 ec 10             	sub    $0x10,%esp                     
  10df99:	8b 75 08             	mov    0x8(%ebp),%esi                 
  Heap_Block *the_block;                                              
  void       *ptr = NULL;                                             
  Heap_Statistics *const stats = &the_heap->stats;                    
  Heap_Block *const tail = _Heap_Tail(the_heap);                      
                                                                      
  the_size =                                                          
  10df9c:	ff 76 14             	pushl  0x14(%esi)                     
  10df9f:	ff 76 10             	pushl  0x10(%esi)                     
  10dfa2:	ff 75 0c             	pushl  0xc(%ebp)                      
  10dfa5:	e8 91 c1 ff ff       	call   10a13b <_Heap_Calc_block_size> 
    _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
  if(the_size == 0)                                                   
  10dfaa:	83 c4 10             	add    $0x10,%esp                     
  10dfad:	31 d2                	xor    %edx,%edx                      
  10dfaf:	85 c0                	test   %eax,%eax                      
  10dfb1:	74 3c                	je     10dfef <_Heap_Allocate+0x5f>   <== NEVER TAKEN
 *  @param[in] starting_address is the starting address of the memory 
 *         to add to the heap                                         
 *  @param[in] size is the size in bytes of the memory area to add    
 *  @return a status indicating success or the reason for failure     
 */                                                                   
bool _Protected_heap_Extend(                                          
  10dfb3:	8b 5e 08             	mov    0x8(%esi),%ebx                 
  10dfb6:	31 ff                	xor    %edi,%edi                      
  10dfb8:	eb 27                	jmp    10dfe1 <_Heap_Allocate+0x51>   
    /* As we always coalesce free blocks, prev block must have been used. */
    _HAssert(_Heap_Is_prev_used(the_block));                          
                                                                      
    /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the
       result of the comparison. */                                   
    if(the_block->size >= the_size) {                                 
  10dfba:	39 43 04             	cmp    %eax,0x4(%ebx)                 
  10dfbd:	72 1e                	jb     10dfdd <_Heap_Allocate+0x4d>   
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );     
  10dfbf:	52                   	push   %edx                           
  10dfc0:	50                   	push   %eax                           
  10dfc1:	53                   	push   %ebx                           
  10dfc2:	56                   	push   %esi                           
  10dfc3:	e8 b0 c1 ff ff       	call   10a178 <_Heap_Block_allocate>  
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
 *         the heap                                                   
  10dfc8:	8d 53 08             	lea    0x8(%ebx),%edx                 
                                                                      
      ptr = _Heap_User_area(the_block);                               
                                                                      
      stats->allocs += 1;                                             
  10dfcb:	ff 46 48             	incl   0x48(%esi)                     
      stats->searches += search_count + 1;                            
  10dfce:	8b 46 4c             	mov    0x4c(%esi),%eax                
  10dfd1:	8d 44 07 01          	lea    0x1(%edi,%eax,1),%eax          
  10dfd5:	89 46 4c             	mov    %eax,0x4c(%esi)                
  10dfd8:	83 c4 10             	add    $0x10,%esp                     
  10dfdb:	eb 0a                	jmp    10dfe7 <_Heap_Allocate+0x57>   
    return NULL;                                                      
                                                                      
  /* Find large enough free block. */                                 
  for(the_block = _Heap_First(the_heap), search_count = 0;            
      the_block != tail;                                              
      the_block = the_block->next, ++search_count)                    
  10dfdd:	8b 5b 08             	mov    0x8(%ebx),%ebx                 
  10dfe0:	47                   	inc    %edi                           
  if(the_size == 0)                                                   
    return NULL;                                                      
                                                                      
  /* Find large enough free block. */                                 
  for(the_block = _Heap_First(the_heap), search_count = 0;            
      the_block != tail;                                              
  10dfe1:	39 f3                	cmp    %esi,%ebx                      
  10dfe3:	75 d5                	jne    10dfba <_Heap_Allocate+0x2a>   
  10dfe5:	31 d2                	xor    %edx,%edx                      
      _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));       
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if(stats->max_search < search_count)                                
  10dfe7:	39 7e 44             	cmp    %edi,0x44(%esi)                
  10dfea:	73 03                	jae    10dfef <_Heap_Allocate+0x5f>   
    stats->max_search = search_count;                                 
  10dfec:	89 7e 44             	mov    %edi,0x44(%esi)                
                                                                      
  return ptr;                                                         
}                                                                     
  10dfef:	89 d0                	mov    %edx,%eax                      
  10dff1:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10dff4:	5b                   	pop    %ebx                           
  10dff5:	5e                   	pop    %esi                           
  10dff6:	5f                   	pop    %edi                           
  10dff7:	c9                   	leave                                 
  10dff8:	c3                   	ret                                   
                                                                      

0010b7f8 <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) {
  10b7f8:	55                   	push   %ebp                           
  10b7f9:	89 e5                	mov    %esp,%ebp                      
  10b7fb:	57                   	push   %edi                           
  10b7fc:	56                   	push   %esi                           
  10b7fd:	53                   	push   %ebx                           
  10b7fe:	83 ec 30             	sub    $0x30,%esp                     
  10b801:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  uint32_t search_count;                                              
  Heap_Block *the_block;                                              
                                                                      
  void *user_ptr = NULL;                                              
  uint32_t  const page_size = the_heap->page_size;                    
  10b804:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b807:	8b 52 10             	mov    0x10(%edx),%edx                
  10b80a:	89 55 dc             	mov    %edx,-0x24(%ebp)               
  Heap_Statistics *const stats = &the_heap->stats;                    
  Heap_Block *const tail = _Heap_Tail(the_heap);                      
                                                                      
  uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;  
  10b80d:	8d 48 fc             	lea    -0x4(%eax),%ecx                
  10b810:	89 4d e0             	mov    %ecx,-0x20(%ebp)               
                                                                      
  uint32_t const the_size =                                           
    _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 
  10b813:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b816:	ff 72 14             	pushl  0x14(%edx)                     
  10b819:	ff 75 dc             	pushl  -0x24(%ebp)                    
  10b81c:	50                   	push   %eax                           
  10b81d:	e8 2d 04 00 00       	call   10bc4f <_Heap_Calc_block_size> 
  10b822:	89 45 e4             	mov    %eax,-0x1c(%ebp)               
                                                                      
  if(the_size == 0)                                                   
  10b825:	83 c4 10             	add    $0x10,%esp                     
  10b828:	31 c0                	xor    %eax,%eax                      
  10b82a:	83 7d e4 00          	cmpl   $0x0,-0x1c(%ebp)               
  10b82e:	0f 84 30 01 00 00    	je     10b964 <_Heap_Allocate_aligned+0x16c><== NEVER TAKEN
    return NULL;                                                      
                                                                      
  if(alignment == 0)                                                  
  10b834:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  10b838:	75 07                	jne    10b841 <_Heap_Allocate_aligned+0x49>
  10b83a:	c7 45 10 04 00 00 00 	movl   $0x4,0x10(%ebp)                
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
}                                                                     
                                                                      
/**                                                                   
  10b841:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10b844:	8b 59 08             	mov    0x8(%ecx),%ebx                 
  10b847:	c7 45 d8 00 00 00 00 	movl   $0x0,-0x28(%ebp)               
  10b84e:	e9 f8 00 00 00       	jmp    10b94b <_Heap_Allocate_aligned+0x153>
  10b853:	8b 43 04             	mov    0x4(%ebx),%eax                 
  10b856:	83 e0 fe             	and    $0xfffffffe,%eax               
  10b859:	89 45 e8             	mov    %eax,-0x18(%ebp)               
    uint32_t const block_size = _Heap_Block_size(the_block);          
                                                                      
    /* As we always coalesce free blocks, prev block must have been used. */
    _HAssert(_Heap_Is_prev_used(the_block));                          
                                                                      
    if(block_size >= the_size) { /* the_block is large enough. */     
  10b85c:	8b 55 e4             	mov    -0x1c(%ebp),%edx               
  10b85f:	39 d0                	cmp    %edx,%eax                      
  10b861:	0f 82 de 00 00 00    	jb     10b945 <_Heap_Allocate_aligned+0x14d>
                                                                      
      _H_uptr_t user_addr;                                            
      _H_uptr_t aligned_user_addr;                                    
      _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 
  10b867:	8d 4b 08             	lea    0x8(%ebx),%ecx                 
      /* Calculate 'aligned_user_addr' that will become the user pointer we
         return. It should be at least 'end_to_user_offs' bytes less than the
         the 'block_end' and should be aligned on 'alignment' boundary.
         Calculations are from the 'block_end' as we are going to split free
         block so that the upper part of the block becomes used block. */
      _H_uptr_t const block_end = _H_p2u(the_block) + block_size;     
  10b86a:	01 d8                	add    %ebx,%eax                      
  10b86c:	89 45 ec             	mov    %eax,-0x14(%ebp)               
      aligned_user_addr = block_end - end_to_user_offs;               
  10b86f:	89 c6                	mov    %eax,%esi                      
  10b871:	2b 75 e0             	sub    -0x20(%ebp),%esi               
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void )     
{                                                                     
  _Thread_Dispatch_disable_level = 1;                                 
}                                                                     
                                                                      
  10b874:	89 f0                	mov    %esi,%eax                      
  10b876:	31 d2                	xor    %edx,%edx                      
  10b878:	f7 75 10             	divl   0x10(%ebp)                     
  10b87b:	89 f7                	mov    %esi,%edi                      
  10b87d:	29 d7                	sub    %edx,%edi                      
  10b87f:	89 f8                	mov    %edi,%eax                      
  10b881:	31 d2                	xor    %edx,%edx                      
  10b883:	f7 75 dc             	divl   -0x24(%ebp)                    
  10b886:	89 fe                	mov    %edi,%esi                      
  10b888:	29 d6                	sub    %edx,%esi                      
         only at 'page_size' aligned addresses */                     
      user_addr = aligned_user_addr;                                  
      _Heap_Align_down_uptr(&user_addr, page_size);                   
                                                                      
      /* Make sure 'user_addr' calculated didn't run out of 'the_block'. */
      if(user_addr >= user_area) {                                    
  10b88a:	39 ce                	cmp    %ecx,%esi                      
  10b88c:	0f 82 b3 00 00 00    	jb     10b945 <_Heap_Allocate_aligned+0x14d>
                                                                      
        /* The block seems to be acceptable. Check if the remainder of
           'the_block' is less than 'min_block_size' so that 'the_block' won't
           actually be split at the address we assume. */             
        if(user_addr - user_area < the_heap->min_block_size) {        
  10b892:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b895:	8b 52 14             	mov    0x14(%edx),%edx                
  10b898:	89 55 f0             	mov    %edx,-0x10(%ebp)               
  10b89b:	89 f0                	mov    %esi,%eax                      
  10b89d:	29 c8                	sub    %ecx,%eax                      
  10b89f:	39 d0                	cmp    %edx,%eax                      
  10b8a1:	73 2f                	jae    10b8d2 <_Heap_Allocate_aligned+0xda>
           'aligned_user_addr' to be outside of [0,page_size) range. If we do,
           we will need to store this distance somewhere to be able to
           resurrect the block address from the user pointer. (Having the
           distance within [0,page_size) range allows resurrection by 
           aligning user pointer down to the nearest 'page_size' boundary.) */
          if(aligned_user_addr - user_addr >= page_size) {            
  10b8a3:	89 f8                	mov    %edi,%eax                      
  10b8a5:	29 c8                	sub    %ecx,%eax                      
  10b8a7:	89 ce                	mov    %ecx,%esi                      
  10b8a9:	3b 45 dc             	cmp    -0x24(%ebp),%eax               
  10b8ac:	72 24                	jb     10b8d2 <_Heap_Allocate_aligned+0xda>
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )      
{                                                                     
  return ( _Thread_Dispatch_disable_level == 0 );                     
}                                                                     
                                                                      
/**                                                                   
  10b8ae:	89 c8                	mov    %ecx,%eax                      
  10b8b0:	31 d2                	xor    %edx,%edx                      
  10b8b2:	f7 75 10             	divl   0x10(%ebp)                     
  10b8b5:	89 d6                	mov    %edx,%esi                      
 *  This function returns TRUE if dispatching is disabled, and FALSE  
  10b8b7:	89 ca                	mov    %ecx,%edx                      
  10b8b9:	85 f6                	test   %esi,%esi                      
  10b8bb:	74 08                	je     10b8c5 <_Heap_Allocate_aligned+0xcd>
  10b8bd:	8b 45 10             	mov    0x10(%ebp),%eax                
  10b8c0:	8d 14 01             	lea    (%ecx,%eax,1),%edx             
  10b8c3:	29 f2                	sub    %esi,%edx                      
            /* The user pointer will be too far from 'user_addr'. See if we
               can make 'aligned_user_addr' to be close enough to the 
               'user_addr'. */                                        
            aligned_user_addr = user_addr;                            
            _Heap_Align_up_uptr(&aligned_user_addr, alignment);       
            if(aligned_user_addr - user_addr >= page_size) {          
  10b8c5:	89 d0                	mov    %edx,%eax                      
  10b8c7:	29 c8                	sub    %ecx,%eax                      
  10b8c9:	3b 45 dc             	cmp    -0x24(%ebp),%eax               
  10b8cc:	73 77                	jae    10b945 <_Heap_Allocate_aligned+0x14d>
  10b8ce:	89 ce                	mov    %ecx,%esi                      
  10b8d0:	89 d7                	mov    %edx,%edi                      
              aligned_user_addr = 0;                                  
            }                                                         
          }                                                           
        }                                                             
                                                                      
        if(aligned_user_addr) {                                       
  10b8d2:	85 ff                	test   %edi,%edi                      
  10b8d4:	74 6f                	je     10b945 <_Heap_Allocate_aligned+0x14d><== NEVER TAKEN
                                                                      
          /* The block is indeed acceptable: calculate the size of the block
             to be allocated and perform allocation. */               
          uint32_t const alloc_size =                                 
            block_end - user_addr + HEAP_BLOCK_USER_OFFSET;           
  10b8d6:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  10b8d9:	83 c2 08             	add    $0x8,%edx                      
  10b8dc:	29 f2                	sub    %esi,%edx                      
  Heap_Block    *the_block,                                           
  uint32_t      alloc_size)                                           
{                                                                     
  Heap_Statistics *const stats = &the_heap->stats;                    
  uint32_t const block_size = _Heap_Block_size(the_block);            
  uint32_t const the_rest = block_size - alloc_size;                  
  10b8de:	8b 4d e8             	mov    -0x18(%ebp),%ecx               
  10b8e1:	29 d1                	sub    %edx,%ecx                      
  _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size));        
  _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size));        
  _HAssert(alloc_size <= block_size);                                 
  _HAssert(_Heap_Is_prev_used(the_block));                            
                                                                      
  if(the_rest >= the_heap->min_block_size) {                          
  10b8e3:	3b 4d f0             	cmp    -0x10(%ebp),%ecx               
  10b8e6:	72 14                	jb     10b8fc <_Heap_Allocate_aligned+0x104>
    /* Split the block so that lower part is still free, and upper part
       becomes used. */                                               
    the_block->size = the_rest | HEAP_PREV_USED;                      
  10b8e8:	89 c8                	mov    %ecx,%eax                      
  10b8ea:	83 c8 01             	or     $0x1,%eax                      
  10b8ed:	89 43 04             	mov    %eax,0x4(%ebx)                 
  Context_Control *context_p = &context_area;                         
                                                                      
  if ( _System_state_Is_up(_System_state_Get ()) )                    
    context_p = &_Thread_Executing->Registers;                        
                                                                      
  _Context_Switch( context_p, &_Thread_BSP_context );                 
  10b8f0:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax             
/** @brief _Thread_Is_proxy_blocking                                  
 *                                                                    
 *  status which indicates that a proxy is blocking, and FALSE otherwise.
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (                 
  uint32_t   code                                                     
  10b8f3:	89 c3                	mov    %eax,%ebx                      
    the_block = _Heap_Block_at(the_block, the_rest);                  
    the_block->prev_size = the_rest;                                  
  10b8f5:	89 08                	mov    %ecx,(%eax)                    
    the_block->size = alloc_size;                                     
  10b8f7:	89 50 04             	mov    %edx,0x4(%eax)                 
  10b8fa:	eb 15                	jmp    10b911 <_Heap_Allocate_aligned+0x119>
 *  This routine resets the current context of the calling thread     
 *  to that of its initial state.                                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )                
{                                                                     
  10b8fc:	8b 53 08             	mov    0x8(%ebx),%edx                 
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  10b8ff:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  if ( _Thread_Executing->fp_context != NULL )                        
  10b902:	89 50 08             	mov    %edx,0x8(%eax)                 
    _Context_Restore_fp( &_Thread_Executing->fp_context );            
  10b905:	89 42 0c             	mov    %eax,0xc(%edx)                 
    /* Don't split the block as remainder is either zero or too small to be
       used as a separate free block. Change 'alloc_size' to the size of the
       block and remove the block from the list of free blocks. */    
    _Heap_Block_remove(the_block);                                    
    alloc_size = block_size;                                          
    stats->free_blocks -= 1;                                          
  10b908:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b90b:	ff 4a 38             	decl   0x38(%edx)                     
  10b90e:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  }                                                                   
  /* Mark the block as used (in the next block). */                   
  _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;      
  10b911:	83 4c 13 04 01       	orl    $0x1,0x4(%ebx,%edx,1)          
  /* Update statistics */                                             
  stats->free_size -= alloc_size;                                     
  10b916:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10b919:	8b 41 30             	mov    0x30(%ecx),%eax                
  10b91c:	29 d0                	sub    %edx,%eax                      
  10b91e:	89 41 30             	mov    %eax,0x30(%ecx)                
  if(stats->min_free_size > stats->free_size)                         
  10b921:	39 41 34             	cmp    %eax,0x34(%ecx)                
  10b924:	76 03                	jbe    10b929 <_Heap_Allocate_aligned+0x131>
    stats->min_free_size = stats->free_size;                          
  10b926:	89 41 34             	mov    %eax,0x34(%ecx)                
  stats->used_blocks += 1;                                            
  10b929:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10b92c:	ff 40 40             	incl   0x40(%eax)                     
                                                                      
          _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
                                                                      
          the_block = block_allocate(the_heap, the_block, alloc_size);
                                                                      
          stats->searches += search_count + 1;                        
  10b92f:	89 c2                	mov    %eax,%edx                      
  10b931:	8b 40 4c             	mov    0x4c(%eax),%eax                
  10b934:	8b 4d d8             	mov    -0x28(%ebp),%ecx               
  10b937:	8d 44 01 01          	lea    0x1(%ecx,%eax,1),%eax          
  10b93b:	89 42 4c             	mov    %eax,0x4c(%edx)                
          stats->allocs += 1;                                         
  10b93e:	ff 42 48             	incl   0x48(%edx)                     
                                                                      
          check_result(the_heap, the_block, user_addr,                
            aligned_user_addr, size);                                 
                                                                      
          user_ptr = (void*)aligned_user_addr;                        
  10b941:	89 f8                	mov    %edi,%eax                      
  10b943:	eb 11                	jmp    10b956 <_Heap_Allocate_aligned+0x15e>
                                                                      
  /* Find large enough free block that satisfies the alignment requirements. */
                                                                      
  for(the_block = _Heap_First(the_heap), search_count = 0;            
      the_block != tail;                                              
      the_block = the_block->next, ++search_count)                    
  10b945:	8b 5b 08             	mov    0x8(%ebx),%ebx                 
  10b948:	ff 45 d8             	incl   -0x28(%ebp)                    
    alignment = CPU_ALIGNMENT;                                        
                                                                      
  /* Find large enough free block that satisfies the alignment requirements. */
                                                                      
  for(the_block = _Heap_First(the_heap), search_count = 0;            
      the_block != tail;                                              
  10b94b:	3b 5d 08             	cmp    0x8(%ebp),%ebx                 
  10b94e:	0f 85 ff fe ff ff    	jne    10b853 <_Heap_Allocate_aligned+0x5b>
  10b954:	31 c0                	xor    %eax,%eax                      
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if(stats->max_search < search_count)                                
  10b956:	8b 55 d8             	mov    -0x28(%ebp),%edx               
  10b959:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10b95c:	39 51 44             	cmp    %edx,0x44(%ecx)                
  10b95f:	73 03                	jae    10b964 <_Heap_Allocate_aligned+0x16c>
    stats->max_search = search_count;                                 
  10b961:	89 51 44             	mov    %edx,0x44(%ecx)                
                                                                      
  return user_ptr;                                                    
}                                                                     
  10b964:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b967:	5b                   	pop    %ebx                           
  10b968:	5e                   	pop    %esi                           
  10b969:	5f                   	pop    %edi                           
  10b96a:	c9                   	leave                                 
  10b96b:	c3                   	ret                                   
                                                                      

0010ff58 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) {
  10ff58:	55                   	push   %ebp                           
  10ff59:	89 e5                	mov    %esp,%ebp                      
  10ff5b:	57                   	push   %edi                           
  10ff5c:	56                   	push   %esi                           
  10ff5d:	53                   	push   %ebx                           
  10ff5e:	83 ec 0c             	sub    $0xc,%esp                      
  10ff61:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10ff64:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10ff67:	8b 75 10             	mov    0x10(%ebp),%esi                
   *    5. non-contiguous higher address    (NOT SUPPORTED)           
   *                                                                  
   *  As noted, this code only supports (4).                          
   */                                                                 
                                                                      
  if ( starting_address >= the_heap->begin &&        /* case 3 */     
  10ff6a:	3b 51 18             	cmp    0x18(%ecx),%edx                
  10ff6d:	72 0a                	jb     10ff79 <_Heap_Extend+0x21>     
  10ff6f:	b8 01 00 00 00       	mov    $0x1,%eax                      
  10ff74:	3b 51 1c             	cmp    0x1c(%ecx),%edx                
  10ff77:	72 5f                	jb     10ffd8 <_Heap_Extend+0x80>     
       starting_address < the_heap->end                               
     )                                                                
    return HEAP_EXTEND_ERROR;                                         
                                                                      
  if ( starting_address != the_heap->end )                            
  10ff79:	b8 02 00 00 00       	mov    $0x2,%eax                      
  10ff7e:	3b 51 1c             	cmp    0x1c(%ecx),%edx                
  10ff81:	75 55                	jne    10ffd8 <_Heap_Extend+0x80>     
   *  Currently only case 4 should make it to this point.             
   *  The basic trick is to make the extend area look like a used     
   *  block and free it.                                              
   */                                                                 
                                                                      
  old_final = the_heap->final;                                        
  10ff83:	8b 59 24             	mov    0x24(%ecx),%ebx                
  Context_Control *context_p = &context_area;                         
                                                                      
  if ( _System_state_Is_up(_System_state_Get ()) )                    
    context_p = &_Thread_Executing->Registers;                        
                                                                      
  _Context_Switch( context_p, &_Thread_BSP_context );                 
  10ff86:	8d 04 32             	lea    (%edx,%esi,1),%eax             
  the_heap->end = _Addresses_Add_offset( the_heap->end, size );       
  10ff89:	89 41 1c             	mov    %eax,0x1c(%ecx)                
  the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
  10ff8c:	29 d8                	sub    %ebx,%eax                      
  10ff8e:	8d 78 f8             	lea    -0x8(%eax),%edi                
 *  the outer most dispatching critical section, then a dispatching   
 *  operation will be performed and, if necessary, control of the     
 *  processor will be transferred to the heir thread.                 
 */                                                                   
                                                                      
#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \                      
  10ff91:	89 f8                	mov    %edi,%eax                      
  10ff93:	31 d2                	xor    %edx,%edx                      
  10ff95:	f7 71 10             	divl   0x10(%ecx)                     
  10ff98:	29 d7                	sub    %edx,%edi                      
  _Heap_Align_down( &the_size, the_heap->page_size );                 
                                                                      
  *amount_extended = size;                                            
  10ff9a:	8b 45 14             	mov    0x14(%ebp),%eax                
  10ff9d:	89 30                	mov    %esi,(%eax)                    
                                                                      
  if( the_size < the_heap->min_block_size )                           
  10ff9f:	31 c0                	xor    %eax,%eax                      
  10ffa1:	3b 79 14             	cmp    0x14(%ecx),%edi                
  10ffa4:	72 32                	jb     10ffd8 <_Heap_Extend+0x80>     <== NEVER TAKEN
    return HEAP_EXTEND_SUCCESSFUL;                                    
                                                                      
  old_final->size = the_size | (old_final->size & HEAP_PREV_USED);    
  10ffa6:	8b 43 04             	mov    0x4(%ebx),%eax                 
  10ffa9:	83 e0 01             	and    $0x1,%eax                      
  10ffac:	09 f8                	or     %edi,%eax                      
  10ffae:	89 43 04             	mov    %eax,0x4(%ebx)                 
/** @brief _Thread_Is_proxy_blocking                                  
 *                                                                    
 *  status which indicates that a proxy is blocking, and FALSE otherwise.
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (                 
  uint32_t   code                                                     
  10ffb1:	8d 04 3b             	lea    (%ebx,%edi,1),%eax             
  new_final = _Heap_Block_at( old_final, the_size );                  
  new_final->size = HEAP_PREV_USED;                                   
  10ffb4:	c7 40 04 01 00 00 00 	movl   $0x1,0x4(%eax)                 
  the_heap->final = new_final;                                        
  10ffbb:	89 41 24             	mov    %eax,0x24(%ecx)                
                                                                      
  stats->size += size;                                                
  10ffbe:	01 71 2c             	add    %esi,0x2c(%ecx)                
  stats->used_blocks += 1;                                            
  10ffc1:	ff 41 40             	incl   0x40(%ecx)                     
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */
  10ffc4:	ff 49 50             	decl   0x50(%ecx)                     
                                                                      
  _Heap_Free( the_heap, _Heap_User_area( old_final ) );               
  10ffc7:	50                   	push   %eax                           
  10ffc8:	50                   	push   %eax                           
  10ffc9:	8d 43 08             	lea    0x8(%ebx),%eax                 
  10ffcc:	50                   	push   %eax                           
  10ffcd:	51                   	push   %ecx                           
  10ffce:	e8 05 ba ff ff       	call   10b9d8 <_Heap_Free>            
  10ffd3:	31 c0                	xor    %eax,%eax                      
  10ffd5:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return HEAP_EXTEND_SUCCESSFUL;                                      
}                                                                     
  10ffd8:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ffdb:	5b                   	pop    %ebx                           
  10ffdc:	5e                   	pop    %esi                           
  10ffdd:	5f                   	pop    %edi                           
  10ffde:	c9                   	leave                                 
  10ffdf:	c3                   	ret                                   
                                                                      

0010dffc <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) {
  10dffc:	55                   	push   %ebp                           
  10dffd:	89 e5                	mov    %esp,%ebp                      
  10dfff:	57                   	push   %edi                           
  10e000:	56                   	push   %esi                           
  10e001:	53                   	push   %ebx                           
  10e002:	83 ec 14             	sub    $0x14,%esp                     
  10e005:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10e008:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  uint32_t         the_size;                                          
  uint32_t         next_size;                                         
  Heap_Statistics *const stats = &the_heap->stats;                    
  bool             next_is_free;                                      
                                                                      
  if ( !_Addresses_Is_in_range(                                       
  10e00b:	8b 47 24             	mov    0x24(%edi),%eax                
  10e00e:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  10e011:	8b 57 20             	mov    0x20(%edi),%edx                
  10e014:	89 55 e4             	mov    %edx,-0x1c(%ebp)               
  10e017:	39 d1                	cmp    %edx,%ecx                      
  10e019:	0f 93 c2             	setae  %dl                            
  10e01c:	39 c1                	cmp    %eax,%ecx                      
  10e01e:	0f 96 c0             	setbe  %al                            
  10e021:	84 d0                	test   %dl,%al                        
  10e023:	0f 84 2f 01 00 00    	je     10e158 <_Heap_Free+0x15c>      
  10e029:	8d 59 f8             	lea    -0x8(%ecx),%ebx                
  10e02c:	89 c8                	mov    %ecx,%eax                      
  10e02e:	31 d2                	xor    %edx,%edx                      
  10e030:	f7 77 10             	divl   0x10(%edi)                     
  10e033:	29 d3                	sub    %edx,%ebx                      
    return( FALSE );                                                  
  }                                                                   
                                                                      
  _Heap_Start_of_block( the_heap, starting_address, &the_block );     
                                                                      
  if ( !_Heap_Is_block_in( the_heap, the_block ) ) {                  
  10e035:	3b 5d e4             	cmp    -0x1c(%ebp),%ebx               
  10e038:	0f 93 c2             	setae  %dl                            
  10e03b:	3b 5d e0             	cmp    -0x20(%ebp),%ebx               
  10e03e:	0f 96 c0             	setbe  %al                            
  10e041:	84 d0                	test   %dl,%al                        
  10e043:	0f 84 0f 01 00 00    	je     10e158 <_Heap_Free+0x15c>      <== NEVER TAKEN
  10e049:	8b 4b 04             	mov    0x4(%ebx),%ecx                 
  10e04c:	89 c8                	mov    %ecx,%eax                      
  10e04e:	83 e0 fe             	and    $0xfffffffe,%eax               
  10e051:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  10e054:	8d 34 03             	lea    (%ebx,%eax,1),%esi             
  }                                                                   
                                                                      
  the_size = _Heap_Block_size( the_block );                           
  next_block = _Heap_Block_at( the_block, the_size );                 
                                                                      
  if ( !_Heap_Is_block_in( the_heap, next_block ) ) {                 
  10e057:	3b 75 e4             	cmp    -0x1c(%ebp),%esi               
  10e05a:	0f 93 c2             	setae  %dl                            
  10e05d:	3b 75 e0             	cmp    -0x20(%ebp),%esi               
  10e060:	0f 96 c0             	setbe  %al                            
  10e063:	84 d0                	test   %dl,%al                        
  10e065:	0f 84 ed 00 00 00    	je     10e158 <_Heap_Free+0x15c>      <== NEVER TAKEN
  10e06b:	8b 46 04             	mov    0x4(%esi),%eax                 
    _HAssert( FALSE );                                                
    return( FALSE );                                                  
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
  10e06e:	a8 01                	test   $0x1,%al                       
  10e070:	0f 84 e2 00 00 00    	je     10e158 <_Heap_Free+0x15c>      <== NEVER TAKEN
  10e076:	83 e0 fe             	and    $0xfffffffe,%eax               
  10e079:	89 45 ec             	mov    %eax,-0x14(%ebp)               
    _HAssert( FALSE );                                                
    return( FALSE );                                                  
  }                                                                   
                                                                      
  next_size = _Heap_Block_size( next_block );                         
  next_is_free = next_block < the_heap->final &&                      
  10e07c:	31 c0                	xor    %eax,%eax                      
  10e07e:	3b 75 e0             	cmp    -0x20(%ebp),%esi               
  10e081:	73 0c                	jae    10e08f <_Heap_Free+0x93>       
  10e083:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  10e086:	8b 44 16 04          	mov    0x4(%esi,%edx,1),%eax          
  10e08a:	f7 d0                	not    %eax                           
  10e08c:	83 e0 01             	and    $0x1,%eax                      
  10e08f:	88 45 f3             	mov    %al,-0xd(%ebp)                 
    !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));       
                                                                      
  if ( !_Heap_Is_prev_used( the_block ) ) {                           
  10e092:	80 e1 01             	and    $0x1,%cl                       
  10e095:	75 56                	jne    10e0ed <_Heap_Free+0xf1>       
    uint32_t const prev_size = the_block->prev_size;                  
  10e097:	8b 0b                	mov    (%ebx),%ecx                    
  10e099:	29 cb                	sub    %ecx,%ebx                      
    Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size );
                                                                      
    if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {               
  10e09b:	3b 5d e4             	cmp    -0x1c(%ebp),%ebx               
  10e09e:	0f 93 c2             	setae  %dl                            
  10e0a1:	3b 5d e0             	cmp    -0x20(%ebp),%ebx               
  10e0a4:	0f 96 c0             	setbe  %al                            
  10e0a7:	84 d0                	test   %dl,%al                        
  10e0a9:	0f 84 a9 00 00 00    	je     10e158 <_Heap_Free+0x15c>      <== NEVER TAKEN
      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) ) {                        
  10e0af:	f6 43 04 01          	testb  $0x1,0x4(%ebx)                 
  10e0b3:	0f 84 9f 00 00 00    	je     10e158 <_Heap_Free+0x15c>      <== NEVER TAKEN
      _HAssert( FALSE );                                              
      return( FALSE );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
  10e0b9:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  10e0bd:	74 19                	je     10e0d8 <_Heap_Free+0xdc>       
      uint32_t const size = the_size + prev_size + next_size;         
  10e0bf:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  10e0c2:	03 55 ec             	add    -0x14(%ebp),%edx               
  10e0c5:	01 ca                	add    %ecx,%edx                      
 *  Any other value of @a alignment is taken "as is", i.e., even odd  
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  10e0c7:	8b 4e 08             	mov    0x8(%esi),%ecx                 
 *  @param[in] size is the amount of memory to allocate in bytes      
  10e0ca:	8b 46 0c             	mov    0xc(%esi),%eax                 
 *  @param[in] alignment the required alignment                       
  10e0cd:	89 48 08             	mov    %ecx,0x8(%eax)                 
 *  @return NULL if unsuccessful and a pointer to the block if successful
  10e0d0:	89 41 0c             	mov    %eax,0xc(%ecx)                 
      _Heap_Block_remove( next_block );                               
      stats->free_blocks -= 1;                                        
  10e0d3:	ff 4f 38             	decl   0x38(%edi)                     
  10e0d6:	eb 33                	jmp    10e10b <_Heap_Free+0x10f>      
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    }                                                                 
    else {                      /* coalesce prev */                   
      uint32_t const size = the_size + prev_size;                     
  10e0d8:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  10e0db:	01 ca                	add    %ecx,%edx                      
      prev_block->size = size | HEAP_PREV_USED;                       
  10e0dd:	89 d0                	mov    %edx,%eax                      
  10e0df:	83 c8 01             	or     $0x1,%eax                      
  10e0e2:	89 43 04             	mov    %eax,0x4(%ebx)                 
      next_block->size &= ~HEAP_PREV_USED;                            
  10e0e5:	83 66 04 fe          	andl   $0xfffffffe,0x4(%esi)          
      next_block->prev_size = size;                                   
  10e0e9:	89 16                	mov    %edx,(%esi)                    
  10e0eb:	eb 5b                	jmp    10e148 <_Heap_Free+0x14c>      
    }                                                                 
  }                                                                   
  else if ( next_is_free ) {    /* coalesce next */                   
  10e0ed:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  10e0f1:	74 25                	je     10e118 <_Heap_Free+0x11c>      
    uint32_t const size = the_size + next_size;                       
  10e0f3:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  10e0f6:	03 55 e8             	add    -0x18(%ebp),%edx               
 *  @param[in] starting_address is the starting address of the user block
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
  10e0f9:	8b 4e 08             	mov    0x8(%esi),%ecx                 
bool _Protected_heap_Get_block_size(                                  
  10e0fc:	8b 46 0c             	mov    0xc(%esi),%eax                 
  Heap_Control        *the_heap,                                      
  void                *starting_address,                              
  size_t              *size                                           
  10e0ff:	89 4b 08             	mov    %ecx,0x8(%ebx)                 
);                                                                    
  10e102:	89 43 0c             	mov    %eax,0xc(%ebx)                 
                                                                      
  10e105:	89 58 08             	mov    %ebx,0x8(%eax)                 
  10e108:	89 59 0c             	mov    %ebx,0xc(%ecx)                 
    _Heap_Block_replace( next_block, the_block );                     
    the_block->size = size | HEAP_PREV_USED;                          
  10e10b:	89 d0                	mov    %edx,%eax                      
  10e10d:	83 c8 01             	or     $0x1,%eax                      
  10e110:	89 43 04             	mov    %eax,0x4(%ebx)                 
    next_block  = _Heap_Block_at( the_block, size );                  
    next_block->prev_size = size;                                     
  10e113:	89 14 13             	mov    %edx,(%ebx,%edx,1)             
  10e116:	eb 30                	jmp    10e148 <_Heap_Free+0x14c>      
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size                                                  
);                                                                    
                                                                      
  10e118:	8b 47 08             	mov    0x8(%edi),%eax                 
/**                                                                   
  10e11b:	89 43 08             	mov    %eax,0x8(%ebx)                 
 *  This routine returns the block of memory which begins             
  10e11e:	89 7b 0c             	mov    %edi,0xc(%ebx)                 
 *  at @a starting_address to @a the_heap.  Any coalescing which is   
  10e121:	89 5f 08             	mov    %ebx,0x8(%edi)                 
  10e124:	89 58 0c             	mov    %ebx,0xc(%eax)                 
  }                                                                   
  else {                        /* no coalesce */                     
    /* Add 'the_block' to the head of the free blocks list as it tends to
       produce less fragmentation than adding to the tail. */         
    _Heap_Block_insert_after( _Heap_Head( the_heap), the_block );     
    the_block->size = the_size | HEAP_PREV_USED;                      
  10e127:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10e12a:	83 c8 01             	or     $0x1,%eax                      
  10e12d:	89 43 04             	mov    %eax,0x4(%ebx)                 
    next_block->size &= ~HEAP_PREV_USED;                              
  10e130:	83 66 04 fe          	andl   $0xfffffffe,0x4(%esi)          
    next_block->prev_size = the_size;                                 
  10e134:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10e137:	89 06                	mov    %eax,(%esi)                    
                                                                      
    stats->free_blocks += 1;                                          
  10e139:	8b 47 38             	mov    0x38(%edi),%eax                
  10e13c:	40                   	inc    %eax                           
  10e13d:	89 47 38             	mov    %eax,0x38(%edi)                
    if ( stats->max_free_blocks < stats->free_blocks )                
  10e140:	39 47 3c             	cmp    %eax,0x3c(%edi)                
  10e143:	73 03                	jae    10e148 <_Heap_Free+0x14c>      
      stats->max_free_blocks = stats->free_blocks;                    
  10e145:	89 47 3c             	mov    %eax,0x3c(%edi)                
  }                                                                   
                                                                      
  stats->used_blocks -= 1;                                            
  10e148:	ff 4f 40             	decl   0x40(%edi)                     
  stats->free_size += the_size;                                       
  10e14b:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  10e14e:	01 57 30             	add    %edx,0x30(%edi)                
  stats->frees += 1;                                                  
  10e151:	ff 47 50             	incl   0x50(%edi)                     
  10e154:	b0 01                	mov    $0x1,%al                       
  10e156:	eb 02                	jmp    10e15a <_Heap_Free+0x15e>      
                                                                      
  return( TRUE );                                                     
  10e158:	31 c0                	xor    %eax,%eax                      
}                                                                     
  10e15a:	83 c4 14             	add    $0x14,%esp                     
  10e15d:	5b                   	pop    %ebx                           
  10e15e:	5e                   	pop    %esi                           
  10e15f:	5f                   	pop    %edi                           
  10e160:	c9                   	leave                                 
  10e161:	c3                   	ret                                   
                                                                      

0010ffe0 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) {
  10ffe0:	55                   	push   %ebp                           
  10ffe1:	89 e5                	mov    %esp,%ebp                      
  10ffe3:	53                   	push   %ebx                           
  10ffe4:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10ffe7:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  Heap_Block *the_block;                                              
  Heap_Block *const tail = _Heap_Tail(the_heap);                      
                                                                      
  info->number = 0;                                                   
  10ffea:	c7 02 00 00 00 00    	movl   $0x0,(%edx)                    
  info->largest = 0;                                                  
  10fff0:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)                 
  info->total = 0;                                                    
  10fff7:	c7 42 08 00 00 00 00 	movl   $0x0,0x8(%edx)                 
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
}                                                                     
                                                                      
/**                                                                   
  10fffe:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  110001:	eb 16                	jmp    110019 <_Heap_Get_free_information+0x39>
  110003:	8b 41 04             	mov    0x4(%ecx),%eax                 
  110006:	83 e0 fe             	and    $0xfffffffe,%eax               
    uint32_t const the_size = _Heap_Block_size(the_block);            
                                                                      
    /* As we always coalesce free blocks, prev block must have been used. */
    _HAssert(_Heap_Is_prev_used(the_block));                          
                                                                      
    info->number++;                                                   
  110009:	ff 02                	incl   (%edx)                         
    info->total += the_size;                                          
  11000b:	01 42 08             	add    %eax,0x8(%edx)                 
    if ( info->largest < the_size )                                   
  11000e:	39 42 04             	cmp    %eax,0x4(%edx)                 
  110011:	73 03                	jae    110016 <_Heap_Get_free_information+0x36><== NEVER TAKEN
        info->largest = the_size;                                     
  110013:	89 42 04             	mov    %eax,0x4(%edx)                 
  info->largest = 0;                                                  
  info->total = 0;                                                    
                                                                      
  for(the_block = _Heap_First(the_heap);                              
      the_block != tail;                                              
      the_block = the_block->next)                                    
  110016:	8b 49 08             	mov    0x8(%ecx),%ecx                 
  info->number = 0;                                                   
  info->largest = 0;                                                  
  info->total = 0;                                                    
                                                                      
  for(the_block = _Heap_First(the_heap);                              
      the_block != tail;                                              
  110019:	39 d9                	cmp    %ebx,%ecx                      
  11001b:	75 e6                	jne    110003 <_Heap_Get_free_information+0x23>
    info->number++;                                                   
    info->total += the_size;                                          
    if ( info->largest < the_size )                                   
        info->largest = the_size;                                     
  }                                                                   
}                                                                     
  11001d:	5b                   	pop    %ebx                           
  11001e:	c9                   	leave                                 
  11001f:	c3                   	ret                                   
                                                                      

00110020 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) {
  110020:	55                   	push   %ebp                           
  110021:	89 e5                	mov    %esp,%ebp                      
  110023:	53                   	push   %ebx                           
  110024:	8b 45 08             	mov    0x8(%ebp),%eax                 
  110027:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  Heap_Block *the_block = the_heap->start;                            
  11002a:	8b 48 20             	mov    0x20(%eax),%ecx                
  Heap_Block *const end = the_heap->final;                            
  11002d:	8b 58 24             	mov    0x24(%eax),%ebx                
                                                                      
  _HAssert(the_block->prev_size == HEAP_PREV_USED);                   
  _HAssert(_Heap_Is_prev_used(the_block));                            
                                                                      
  the_info->Free.number  = 0;                                         
  110030:	c7 02 00 00 00 00    	movl   $0x0,(%edx)                    
  the_info->Free.total   = 0;                                         
  110036:	c7 42 08 00 00 00 00 	movl   $0x0,0x8(%edx)                 
  the_info->Free.largest = 0;                                         
  11003d:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)                 
  the_info->Used.number  = 0;                                         
  110044:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)                 
  the_info->Used.total   = 0;                                         
  11004b:	c7 42 14 00 00 00 00 	movl   $0x0,0x14(%edx)                
  the_info->Used.largest = 0;                                         
  110052:	c7 42 10 00 00 00 00 	movl   $0x0,0x10(%edx)                
  110059:	eb 36                	jmp    110091 <_Heap_Get_information+0x71>
  11005b:	8b 41 04             	mov    0x4(%ecx),%eax                 
  11005e:	83 e0 fe             	and    $0xfffffffe,%eax               
/** @brief _Thread_Is_proxy_blocking                                  
 *                                                                    
 *  status which indicates that a proxy is blocking, and FALSE otherwise.
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (                 
  uint32_t   code                                                     
  110061:	01 c1                	add    %eax,%ecx                      
                                                                      
  while ( the_block != end ) {                                        
    uint32_t const the_size = _Heap_Block_size(the_block);            
    Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
                                                                      
    if ( _Heap_Is_prev_used(next_block) ) {                           
  110063:	f6 41 04 01          	testb  $0x1,0x4(%ecx)                 
  110067:	74 10                	je     110079 <_Heap_Get_information+0x59>
      the_info->Used.number++;                                        
  110069:	ff 42 0c             	incl   0xc(%edx)                      
      the_info->Used.total += the_size;                               
  11006c:	01 42 14             	add    %eax,0x14(%edx)                
      if ( the_info->Used.largest < the_size )                        
  11006f:	39 42 10             	cmp    %eax,0x10(%edx)                
  110072:	73 1d                	jae    110091 <_Heap_Get_information+0x71>
        the_info->Used.largest = the_size;                            
  110074:	89 42 10             	mov    %eax,0x10(%edx)                
  110077:	eb 18                	jmp    110091 <_Heap_Get_information+0x71>
    } else {                                                          
      the_info->Free.number++;                                        
  110079:	ff 02                	incl   (%edx)                         
      the_info->Free.total += the_size;                               
  11007b:	01 42 08             	add    %eax,0x8(%edx)                 
      if ( the_info->Free.largest < the_size )                        
  11007e:	39 42 04             	cmp    %eax,0x4(%edx)                 
  110081:	73 03                	jae    110086 <_Heap_Get_information+0x66><== NEVER TAKEN
        the_info->Free.largest = the_size;                            
  110083:	89 42 04             	mov    %eax,0x4(%edx)                 
      if ( the_size != next_block->prev_size )                        
  110086:	3b 01                	cmp    (%ecx),%eax                    
  110088:	74 07                	je     110091 <_Heap_Get_information+0x71><== ALWAYS TAKEN
  11008a:	b8 01 00 00 00       	mov    $0x1,%eax                      <== NOT EXECUTED
  11008f:	eb 0a                	jmp    11009b <_Heap_Get_information+0x7b><== NOT EXECUTED
  the_info->Free.largest = 0;                                         
  the_info->Used.number  = 0;                                         
  the_info->Used.total   = 0;                                         
  the_info->Used.largest = 0;                                         
                                                                      
  while ( the_block != end ) {                                        
  110091:	39 d9                	cmp    %ebx,%ecx                      
  110093:	75 c6                	jne    11005b <_Heap_Get_information+0x3b>
  }                                                                   
                                                                      
  /* Handle the last dummy block. Don't consider this block to be     
     "used" as client never allocated it. Make 'Used.total' contain this
     blocks' overhead though. */                                      
  the_info->Used.total += HEAP_OVERHEAD;                              
  110095:	83 42 14 08          	addl   $0x8,0x14(%edx)                
  110099:	31 c0                	xor    %eax,%eax                      
                                                                      
  return HEAP_GET_INFORMATION_SUCCESSFUL;                             
}                                                                     
  11009b:	5b                   	pop    %ebx                           
  11009c:	c9                   	leave                                 
  11009d:	c3                   	ret                                   
                                                                      

0010a02c <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) {
  10a02c:	55                   	push   %ebp                           
  10a02d:	89 e5                	mov    %esp,%ebp                      
  10a02f:	57                   	push   %edi                           
  10a030:	56                   	push   %esi                           
  10a031:	53                   	push   %ebx                           
  10a032:	83 ec 0c             	sub    $0xc,%esp                      
  10a035:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10a038:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  10a03b:	8b 4d 14             	mov    0x14(%ebp),%ecx                
  _H_uptr_t              start;                                       
  _H_uptr_t              aligned_start;                               
  uint32_t               overhead;                                    
  Heap_Statistics *const stats = &the_heap->stats;                    
                                                                      
  if (page_size == 0)                                                 
  10a03e:	85 c9                	test   %ecx,%ecx                      
  10a040:	75 04                	jne    10a046 <_Heap_Initialize+0x1a> 
  10a042:	b1 04                	mov    $0x4,%cl                       
  10a044:	eb 0c                	jmp    10a052 <_Heap_Initialize+0x26> 
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
 *  @param[in] the_info pointer to a status information area          
 *                                                                    
 *  @return true if successfully able to return information           
 */                                                                   
  10a046:	89 c8                	mov    %ecx,%eax                      
  10a048:	83 e0 03             	and    $0x3,%eax                      
  10a04b:	74 05                	je     10a052 <_Heap_Initialize+0x26> 
  10a04d:	83 c1 04             	add    $0x4,%ecx                      
  10a050:	29 c1                	sub    %eax,%ecx                      
                                                                      
  /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET
     (value of user pointer) is aligned on 'page_size' boundary. Make sure
     resulting 'aligned_start' is not below 'starting_address'. */    
  start = _H_p2u(starting_address);                                   
  aligned_start = start + HEAP_BLOCK_USER_OFFSET;                     
  10a052:	8d 5f 08             	lea    0x8(%edi),%ebx                 
  10a055:	89 d8                	mov    %ebx,%eax                      
  10a057:	31 d2                	xor    %edx,%edx                      
  10a059:	f7 f1                	div    %ecx                           
  10a05b:	85 d2                	test   %edx,%edx                      
  10a05d:	74 05                	je     10a064 <_Heap_Initialize+0x38> 
  10a05f:	8d 1c 19             	lea    (%ecx,%ebx,1),%ebx             
  10a062:	29 d3                	sub    %edx,%ebx                      
  _Heap_Align_up_uptr ( &aligned_start, page_size );                  
  aligned_start -= HEAP_BLOCK_USER_OFFSET;                            
  10a064:	83 eb 08             	sub    $0x8,%ebx                      
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
 *  @param[in] the_info pointer to a status information area          
 *                                                                    
 *  @return true if successfully able to return information           
  10a067:	b8 10 00 00 00       	mov    $0x10,%eax                     
  10a06c:	31 d2                	xor    %edx,%edx                      
  10a06e:	f7 f1                	div    %ecx                           
 */                                                                   
  10a070:	b8 10 00 00 00       	mov    $0x10,%eax                     
  10a075:	85 d2                	test   %edx,%edx                      
  10a077:	74 05                	je     10a07e <_Heap_Initialize+0x52> 
  10a079:	8d 41 10             	lea    0x10(%ecx),%eax                
  10a07c:	29 d0                	sub    %edx,%eax                      
  10a07e:	89 46 14             	mov    %eax,0x14(%esi)                
                                                                      
  /* Calculate 'the_size' -- size of the first block so that there is enough
     space at the end for the permanent last block. It is equal to 'size'
     minus total overhead aligned down to the nearest multiple of     
     'page_size'. */                                                  
  overhead = HEAP_OVERHEAD + (aligned_start - start);                 
  10a081:	89 d8                	mov    %ebx,%eax                      
  10a083:	29 f8                	sub    %edi,%eax                      
  10a085:	83 c0 08             	add    $0x8,%eax                      
  if ( size < overhead )                                              
  10a088:	39 45 10             	cmp    %eax,0x10(%ebp)                
  10a08b:	0f 82 a0 00 00 00    	jb     10a131 <_Heap_Initialize+0x105>
    return 0;   /* Too small area for the heap */                     
  the_size = size - overhead;                                         
  10a091:	8b 55 10             	mov    0x10(%ebp),%edx                
  10a094:	29 c2                	sub    %eax,%edx                      
  10a096:	89 55 e8             	mov    %edx,-0x18(%ebp)               
 *                                                                    
 *  @return free block information filled in.                         
 */                                                                   
bool _Protected_heap_Get_free_information(                            
  Heap_Control        *the_heap,                                      
  Heap_Information    *info                                           
  10a099:	89 d0                	mov    %edx,%eax                      
  10a09b:	31 d2                	xor    %edx,%edx                      
  10a09d:	f7 f1                	div    %ecx                           
  _Heap_Align_down ( &the_size, page_size );                          
  if ( the_size == 0 )                                                
  10a09f:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10a0a2:	29 d0                	sub    %edx,%eax                      
  10a0a4:	89 c2                	mov    %eax,%edx                      
  10a0a6:	0f 84 85 00 00 00    	je     10a131 <_Heap_Initialize+0x105><== NEVER TAKEN
    return 0;   /* Too small area for the heap */                     
                                                                      
  the_heap->page_size = page_size;                                    
  10a0ac:	89 4e 10             	mov    %ecx,0x10(%esi)                
  the_heap->begin = starting_address;                                 
  10a0af:	89 7e 18             	mov    %edi,0x18(%esi)                
  the_heap->end = starting_address + size;                            
  10a0b2:	03 7d 10             	add    0x10(%ebp),%edi                
  10a0b5:	89 7e 1c             	mov    %edi,0x1c(%esi)                
                                                                      
  the_block = (Heap_Block *) aligned_start;                           
                                                                      
  the_block->prev_size = page_size;                                   
  10a0b8:	89 0b                	mov    %ecx,(%ebx)                    
  the_block->size = the_size | HEAP_PREV_USED;                        
  10a0ba:	83 c8 01             	or     $0x1,%eax                      
  10a0bd:	89 43 04             	mov    %eax,0x4(%ebx)                 
  the_block->next = _Heap_Tail( the_heap );                           
  10a0c0:	89 73 08             	mov    %esi,0x8(%ebx)                 
  the_block->prev = _Heap_Head( the_heap );                           
  10a0c3:	89 73 0c             	mov    %esi,0xc(%ebx)                 
  _Heap_Head(the_heap)->next = the_block;                             
  10a0c6:	89 5e 08             	mov    %ebx,0x8(%esi)                 
  _Heap_Tail(the_heap)->prev = the_block;                             
  10a0c9:	89 5e 0c             	mov    %ebx,0xc(%esi)                 
  the_heap->start = the_block;                                        
  10a0cc:	89 5e 20             	mov    %ebx,0x20(%esi)                
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
 *         the heap                                                   
  10a0cf:	8d 04 13             	lea    (%ebx,%edx,1),%eax             
  _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT));     
  _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size));    
  _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size));
                                                                      
  the_block = _Heap_Block_at( the_block, the_size );                  
  the_heap->final = the_block;       /* Permanent final block of the heap */
  10a0d2:	89 46 24             	mov    %eax,0x24(%esi)                
  the_block->prev_size = the_size;   /* Previous block is free */     
  10a0d5:	89 10                	mov    %edx,(%eax)                    
  the_block->size = page_size;                                        
  10a0d7:	89 48 04             	mov    %ecx,0x4(%eax)                 
                                                                      
  stats->size = size;                                                 
  10a0da:	8b 45 10             	mov    0x10(%ebp),%eax                
  10a0dd:	89 46 2c             	mov    %eax,0x2c(%esi)                
  stats->free_size = the_size;                                        
  10a0e0:	89 56 30             	mov    %edx,0x30(%esi)                
  stats->min_free_size = the_size;                                    
  10a0e3:	89 56 34             	mov    %edx,0x34(%esi)                
  stats->free_blocks = 1;                                             
  10a0e6:	c7 46 38 01 00 00 00 	movl   $0x1,0x38(%esi)                
  stats->max_free_blocks = 1;                                         
  10a0ed:	c7 46 3c 01 00 00 00 	movl   $0x1,0x3c(%esi)                
  stats->used_blocks = 0;                                             
  10a0f4:	c7 46 40 00 00 00 00 	movl   $0x0,0x40(%esi)                
  stats->max_search = 0;                                              
  10a0fb:	c7 46 44 00 00 00 00 	movl   $0x0,0x44(%esi)                
  stats->allocs = 0;                                                  
  10a102:	c7 46 48 00 00 00 00 	movl   $0x0,0x48(%esi)                
  stats->searches = 0;                                                
  10a109:	c7 46 4c 00 00 00 00 	movl   $0x0,0x4c(%esi)                
  stats->frees = 0;                                                   
  10a110:	c7 46 50 00 00 00 00 	movl   $0x0,0x50(%esi)                
  stats->resizes = 0;                                                 
  10a117:	c7 46 54 00 00 00 00 	movl   $0x0,0x54(%esi)                
  stats->instance = instance++;                                       
  10a11e:	a1 4c d5 11 00       	mov    0x11d54c,%eax                  
  10a123:	89 46 28             	mov    %eax,0x28(%esi)                
  10a126:	40                   	inc    %eax                           
  10a127:	a3 4c d5 11 00       	mov    %eax,0x11d54c                  
                                                                      
  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );                     
  10a12c:	8d 42 fc             	lea    -0x4(%edx),%eax                
  10a12f:	eb 02                	jmp    10a133 <_Heap_Initialize+0x107>
  10a131:	31 c0                	xor    %eax,%eax                      
}                                                                     
  10a133:	83 c4 0c             	add    $0xc,%esp                      
  10a136:	5b                   	pop    %ebx                           
  10a137:	5e                   	pop    %esi                           
  10a138:	5f                   	pop    %edi                           
  10a139:	c9                   	leave                                 
  10a13a:	c3                   	ret                                   
                                                                      

00115a54 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) {
  115a54:	55                   	push   %ebp                           
  115a55:	89 e5                	mov    %esp,%ebp                      
  115a57:	57                   	push   %edi                           
  115a58:	56                   	push   %esi                           
  115a59:	53                   	push   %ebx                           
  115a5a:	83 ec 2c             	sub    $0x2c,%esp                     
  Heap_Block *next_next_block;                                        
  uint32_t   old_block_size;                                          
  uint32_t   old_user_size;                                           
  uint32_t   prev_used_flag;                                          
  Heap_Statistics *const stats = &the_heap->stats;                    
  uint32_t const min_block_size = the_heap->min_block_size;           
  115a5d:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115a60:	8b 40 14             	mov    0x14(%eax),%eax                
  115a63:	89 45 ec             	mov    %eax,-0x14(%ebp)               
  uint32_t const page_size = the_heap->page_size;                     
  115a66:	8b 55 08             	mov    0x8(%ebp),%edx                 
  115a69:	8b 72 10             	mov    0x10(%edx),%esi                
                                                                      
  *old_mem_size = 0;                                                  
  115a6c:	8b 4d 14             	mov    0x14(%ebp),%ecx                
  115a6f:	c7 01 00 00 00 00    	movl   $0x0,(%ecx)                    
  *avail_mem_size = 0;                                                
  115a75:	8b 45 18             	mov    0x18(%ebp),%eax                
  115a78:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    
  115a7e:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  115a81:	83 ea 08             	sub    $0x8,%edx                      
  115a84:	89 55 f0             	mov    %edx,-0x10(%ebp)               
  115a87:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  115a8a:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  115a8d:	31 d2                	xor    %edx,%edx                      
  115a8f:	f7 71 10             	divl   0x10(%ecx)                     
  115a92:	29 55 f0             	sub    %edx,-0x10(%ebp)               
  115a95:	89 c8                	mov    %ecx,%eax                      
  115a97:	8b 49 24             	mov    0x24(%ecx),%ecx                
  115a9a:	8b 58 20             	mov    0x20(%eax),%ebx                
                                                                      
  _Heap_Start_of_block(the_heap, starting_address, &the_block);       
  _HAssert(_Heap_Is_block_in(the_heap, the_block));                   
  if (!_Heap_Is_block_in(the_heap, the_block))                        
  115a9d:	39 5d f0             	cmp    %ebx,-0x10(%ebp)               
  115aa0:	0f 93 c2             	setae  %dl                            
  115aa3:	39 4d f0             	cmp    %ecx,-0x10(%ebp)               
  115aa6:	0f 96 c0             	setbe  %al                            
  115aa9:	84 d0                	test   %dl,%al                        
  115aab:	0f 84 7e 01 00 00    	je     115c2f <_Heap_Resize_block+0x1db>
    return HEAP_RESIZE_FATAL_ERROR;                                   
                                                                      
  prev_used_flag = the_block->size & HEAP_PREV_USED;                  
  115ab1:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  115ab4:	8b 52 04             	mov    0x4(%edx),%edx                 
  115ab7:	89 55 d8             	mov    %edx,-0x28(%ebp)               
  115aba:	83 e2 fe             	and    $0xfffffffe,%edx               
  115abd:	89 55 e4             	mov    %edx,-0x1c(%ebp)               
  115ac0:	8b 7d f0             	mov    -0x10(%ebp),%edi               
  115ac3:	01 d7                	add    %edx,%edi                      
  old_block_size = _Heap_Block_size(the_block);                       
  next_block = _Heap_Block_at(the_block, old_block_size);             
                                                                      
  _HAssert(_Heap_Is_block_in(the_heap, next_block));                  
  _HAssert(_Heap_Is_prev_used(next_block));                           
  if ( !_Heap_Is_block_in(the_heap, next_block) ||                    
  115ac5:	39 df                	cmp    %ebx,%edi                      
  115ac7:	0f 93 c2             	setae  %dl                            
  115aca:	39 cf                	cmp    %ecx,%edi                      
  115acc:	0f 96 c0             	setbe  %al                            
  115acf:	84 d0                	test   %dl,%al                        
  115ad1:	0f 84 58 01 00 00    	je     115c2f <_Heap_Resize_block+0x1db><== NEVER TAKEN
  115ad7:	8b 47 04             	mov    0x4(%edi),%eax                 
  115ada:	a8 01                	test   $0x1,%al                       
  115adc:	0f 84 4d 01 00 00    	je     115c2f <_Heap_Resize_block+0x1db><== NEVER TAKEN
  115ae2:	83 e0 fe             	and    $0xfffffffe,%eax               
  115ae5:	89 45 dc             	mov    %eax,-0x24(%ebp)               
  115ae8:	01 f8                	add    %edi,%eax                      
  115aea:	89 45 e0             	mov    %eax,-0x20(%ebp)               
       !_Heap_Is_prev_used(next_block))                               
    return HEAP_RESIZE_FATAL_ERROR;                                   
                                                                      
  next_block_size = _Heap_Block_size(next_block);                     
  next_next_block = _Heap_Block_at(next_block, next_block_size);      
  next_is_used    = (next_block == the_heap->final) ||                
  115aed:	b8 01 00 00 00       	mov    $0x1,%eax                      
  115af2:	39 cf                	cmp    %ecx,%edi                      
  115af4:	74 09                	je     115aff <_Heap_Resize_block+0xab><== NEVER TAKEN
  115af6:	8b 4d e0             	mov    -0x20(%ebp),%ecx               
  115af9:	8b 41 04             	mov    0x4(%ecx),%eax                 
  115afc:	83 e0 01             	and    $0x1,%eax                      
  _Heap_Start_of_block(the_heap, starting_address, &the_block);       
  _HAssert(_Heap_Is_block_in(the_heap, the_block));                   
  if (!_Heap_Is_block_in(the_heap, the_block))                        
    return HEAP_RESIZE_FATAL_ERROR;                                   
                                                                      
  prev_used_flag = the_block->size & HEAP_PREV_USED;                  
  115aff:	8b 55 d8             	mov    -0x28(%ebp),%edx               
  115b02:	83 e2 01             	and    $0x1,%edx                      
  115b05:	89 55 e8             	mov    %edx,-0x18(%ebp)               
       !_Heap_Is_prev_used(next_block))                               
    return HEAP_RESIZE_FATAL_ERROR;                                   
                                                                      
  next_block_size = _Heap_Block_size(next_block);                     
  next_next_block = _Heap_Block_at(next_block, next_block_size);      
  next_is_used    = (next_block == the_heap->final) ||                
  115b08:	88 c1                	mov    %al,%cl                        
                     _Heap_Is_prev_used(next_next_block);             
                                                                      
  /* See _Heap_Size_of_user_area() source for explanations */         
  old_user_size = _Addresses_Subtract(next_block, starting_address)   
  115b0a:	89 f8                	mov    %edi,%eax                      
  115b0c:	2b 45 0c             	sub    0xc(%ebp),%eax                 
  115b0f:	83 c0 04             	add    $0x4,%eax                      
    + HEAP_BLOCK_HEADER_OFFSET;                                       
                                                                      
  *old_mem_size = old_user_size;                                      
  115b12:	8b 55 14             	mov    0x14(%ebp),%edx                
  115b15:	89 02                	mov    %eax,(%edx)                    
                                                                      
  if (size > old_user_size) {                                         
  115b17:	39 45 10             	cmp    %eax,0x10(%ebp)                
  115b1a:	76 50                	jbe    115b6c <_Heap_Resize_block+0x118>
    /* Need to extend the block: allocate part of the next block and then
       merge 'the_block' and allocated block together. */             
    if (next_is_used)    /* Next block is in use, -- no way to extend */
  115b1c:	84 c9                	test   %cl,%cl                        
  115b1e:	0f 85 12 01 00 00    	jne    115c36 <_Heap_Resize_block+0x1e2>
      return HEAP_RESIZE_UNSATISFIED;                                 
    else {                                                            
      uint32_t add_block_size = size - old_user_size;                 
  115b24:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  115b27:	29 c1                	sub    %eax,%ecx                      
  115b29:	89 c8                	mov    %ecx,%eax                      
  115b2b:	31 d2                	xor    %edx,%edx                      
  115b2d:	f7 f6                	div    %esi                           
  115b2f:	85 d2                	test   %edx,%edx                      
  115b31:	74 04                	je     115b37 <_Heap_Resize_block+0xe3><== NEVER TAKEN
  115b33:	01 f1                	add    %esi,%ecx                      
  115b35:	29 d1                	sub    %edx,%ecx                      
  115b37:	89 c8                	mov    %ecx,%eax                      
  115b39:	3b 4d ec             	cmp    -0x14(%ebp),%ecx               
  115b3c:	73 03                	jae    115b41 <_Heap_Resize_block+0xed><== NEVER TAKEN
  115b3e:	8b 45 ec             	mov    -0x14(%ebp),%eax               
      _Heap_Align_up(&add_block_size, page_size);                     
      if (add_block_size < min_block_size)                            
        add_block_size = min_block_size;                              
      if (add_block_size > next_block_size)                           
  115b41:	3b 45 dc             	cmp    -0x24(%ebp),%eax               
  115b44:	0f 87 ec 00 00 00    	ja     115c36 <_Heap_Resize_block+0x1e2><== NEVER TAKEN
        return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
      add_block_size =                                                
  115b4a:	53                   	push   %ebx                           
  115b4b:	50                   	push   %eax                           
  115b4c:	57                   	push   %edi                           
  115b4d:	ff 75 08             	pushl  0x8(%ebp)                      
  115b50:	e8 23 46 ff ff       	call   10a178 <_Heap_Block_allocate>  
        _Heap_Block_allocate(the_heap, next_block, add_block_size);   
      /* Merge two subsequent blocks */                               
      the_block->size = (old_block_size + add_block_size) | prev_used_flag;
  115b55:	03 45 e4             	add    -0x1c(%ebp),%eax               
  115b58:	0b 45 e8             	or     -0x18(%ebp),%eax               
  115b5b:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  115b5e:	89 42 04             	mov    %eax,0x4(%edx)                 
      --stats->used_blocks;                                           
  115b61:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  115b64:	ff 49 40             	decl   0x40(%ecx)                     
  115b67:	e9 b6 00 00 00       	jmp    115c22 <_Heap_Resize_block+0x1ce>
    }                                                                 
  } else {                                                            
                                                                      
    /* Calculate how much memory we could free */                     
    uint32_t free_block_size = old_user_size - size;                  
  115b6c:	89 c3                	mov    %eax,%ebx                      
  115b6e:	2b 5d 10             	sub    0x10(%ebp),%ebx                
  115b71:	89 d8                	mov    %ebx,%eax                      
  115b73:	31 d2                	xor    %edx,%edx                      
  115b75:	f7 f6                	div    %esi                           
    _Heap_Align_down(&free_block_size, page_size);                    
                                                                      
    if (free_block_size > 0) {                                        
  115b77:	89 de                	mov    %ebx,%esi                      
  115b79:	29 d6                	sub    %edx,%esi                      
  115b7b:	0f 84 a4 00 00 00    	je     115c25 <_Heap_Resize_block+0x1d1>
                                                                      
      /* To free some memory the block should be shortened so that it can
         can hold 'size' user bytes and still remain not shorter than 
         'min_block_size'. */                                         
                                                                      
      uint32_t new_block_size = old_block_size - free_block_size;     
  115b81:	8b 5d e4             	mov    -0x1c(%ebp),%ebx               
  115b84:	29 f3                	sub    %esi,%ebx                      
                                                                      
      if (new_block_size < min_block_size) {                          
  115b86:	3b 5d ec             	cmp    -0x14(%ebp),%ebx               
  115b89:	73 16                	jae    115ba1 <_Heap_Resize_block+0x14d>
        uint32_t delta = min_block_size - new_block_size;             
  115b8b:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  115b8e:	29 d8                	sub    %ebx,%eax                      
        _HAssert(free_block_size >= delta);                           
        free_block_size -= delta;                                     
        if (free_block_size == 0) {                                   
  115b90:	29 c6                	sub    %eax,%esi                      
  115b92:	75 0b                	jne    115b9f <_Heap_Resize_block+0x14b><== NEVER TAKEN
          ++stats->resizes;                                           
  115b94:	8b 55 08             	mov    0x8(%ebp),%edx                 
  115b97:	ff 42 54             	incl   0x54(%edx)                     
  115b9a:	e9 8c 00 00 00       	jmp    115c2b <_Heap_Resize_block+0x1d7>
          return HEAP_RESIZE_SUCCESSFUL;                              
        }                                                             
        new_block_size += delta;                                      
  115b9f:	01 c3                	add    %eax,%ebx                      <== NOT EXECUTED
      _HAssert(new_block_size >= min_block_size);                     
      _HAssert(new_block_size + free_block_size == old_block_size);   
      _HAssert(_Heap_Is_aligned(new_block_size, page_size));          
      _HAssert(_Heap_Is_aligned(free_block_size, page_size));         
                                                                      
      if (!next_is_used) {                                            
  115ba1:	84 c9                	test   %cl,%cl                        
  115ba3:	75 43                	jne    115be8 <_Heap_Resize_block+0x194><== NEVER TAKEN
  115ba5:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  115ba8:	01 da                	add    %ebx,%edx                      
        /* Extend the next block to the low addresses by 'free_block_size' */
        Heap_Block *const new_next_block =                            
          _Heap_Block_at(the_block, new_block_size);                  
        uint32_t const new_next_block_size =                          
          next_block_size + free_block_size;                          
  115baa:	8b 45 dc             	mov    -0x24(%ebp),%eax               
  115bad:	8d 0c 06             	lea    (%esi,%eax,1),%ecx             
        _HAssert(_Heap_Is_block_in(the_heap, next_next_block));       
        the_block->size = new_block_size | prev_used_flag;            
  115bb0:	0b 5d e8             	or     -0x18(%ebp),%ebx               
  115bb3:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  115bb6:	89 58 04             	mov    %ebx,0x4(%eax)                 
        new_next_block->size = new_next_block_size | HEAP_PREV_USED;  
  115bb9:	89 c8                	mov    %ecx,%eax                      
  115bbb:	83 c8 01             	or     $0x1,%eax                      
  115bbe:	89 42 04             	mov    %eax,0x4(%edx)                 
        next_next_block->prev_size = new_next_block_size;             
  115bc1:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  115bc4:	89 08                	mov    %ecx,(%eax)                    
{                                                                     
  return (state == SYSTEM_STATE_FAILED);                              
}                                                                     
                                                                      
/**@}*/                                                               
                                                                      
  115bc6:	8b 5f 08             	mov    0x8(%edi),%ebx                 
#endif                                                                
  115bc9:	8b 47 0c             	mov    0xc(%edi),%eax                 
/* end of include file */                                             
  115bcc:	89 5a 08             	mov    %ebx,0x8(%edx)                 
  115bcf:	89 42 0c             	mov    %eax,0xc(%edx)                 
  115bd2:	89 50 08             	mov    %edx,0x8(%eax)                 
  115bd5:	89 53 0c             	mov    %edx,0xc(%ebx)                 
        _Heap_Block_replace(next_block, new_next_block);              
        the_heap->stats.free_size += free_block_size;                 
  115bd8:	8b 55 08             	mov    0x8(%ebp),%edx                 
  115bdb:	01 72 30             	add    %esi,0x30(%edx)                
        *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
  115bde:	83 e9 04             	sub    $0x4,%ecx                      
  115be1:	8b 45 18             	mov    0x18(%ebp),%eax                
  115be4:	89 08                	mov    %ecx,(%eax)                    
  115be6:	eb 3d                	jmp    115c25 <_Heap_Resize_block+0x1d1>
                                                                      
      } else if (free_block_size >= min_block_size) {                 
  115be8:	3b 75 ec             	cmp    -0x14(%ebp),%esi               <== NOT EXECUTED
  115beb:	72 38                	jb     115c25 <_Heap_Resize_block+0x1d1><== NOT EXECUTED
        /* Split the block into 2 used  parts, then free the second one. */
        the_block->size = new_block_size | prev_used_flag;            
  115bed:	09 5d e8             	or     %ebx,-0x18(%ebp)               <== NOT EXECUTED
  115bf0:	8b 4d e8             	mov    -0x18(%ebp),%ecx               <== NOT EXECUTED
  115bf3:	8b 55 f0             	mov    -0x10(%ebp),%edx               <== NOT EXECUTED
  115bf6:	89 4a 04             	mov    %ecx,0x4(%edx)                 <== NOT EXECUTED
  115bf9:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  115bfb:	01 d8                	add    %ebx,%eax                      <== NOT EXECUTED
        next_block = _Heap_Block_at(the_block, new_block_size);       
        next_block->size = free_block_size | HEAP_PREV_USED;          
  115bfd:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  115bff:	83 ca 01             	or     $0x1,%edx                      <== NOT EXECUTED
  115c02:	89 50 04             	mov    %edx,0x4(%eax)                 <== NOT EXECUTED
        ++stats->used_blocks; /* We have created used block */        
  115c05:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  115c08:	ff 42 40             	incl   0x40(%edx)                     <== NOT EXECUTED
        --stats->frees;       /* Don't count next call in stats */    
  115c0b:	ff 4a 50             	decl   0x50(%edx)                     <== NOT EXECUTED
        _Heap_Free(the_heap, _Heap_User_area(next_block));            
  115c0e:	51                   	push   %ecx                           <== NOT EXECUTED
  115c0f:	51                   	push   %ecx                           <== NOT EXECUTED
  115c10:	83 c0 08             	add    $0x8,%eax                      <== NOT EXECUTED
  115c13:	50                   	push   %eax                           <== NOT EXECUTED
  115c14:	52                   	push   %edx                           <== NOT EXECUTED
  115c15:	e8 e2 83 ff ff       	call   10dffc <_Heap_Free>            <== NOT EXECUTED
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 
  115c1a:	8d 46 fc             	lea    -0x4(%esi),%eax                <== NOT EXECUTED
  115c1d:	8b 4d 18             	mov    0x18(%ebp),%ecx                <== NOT EXECUTED
  115c20:	89 01                	mov    %eax,(%ecx)                    <== NOT EXECUTED
  115c22:	83 c4 10             	add    $0x10,%esp                     
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  ++stats->resizes;                                                   
  115c25:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115c28:	ff 40 54             	incl   0x54(%eax)                     
  115c2b:	31 c0                	xor    %eax,%eax                      
  115c2d:	eb 0c                	jmp    115c3b <_Heap_Resize_block+0x1e7>
  return HEAP_RESIZE_SUCCESSFUL;                                      
  115c2f:	b8 02 00 00 00       	mov    $0x2,%eax                      
  115c34:	eb 05                	jmp    115c3b <_Heap_Resize_block+0x1e7>
  115c36:	b8 01 00 00 00       	mov    $0x1,%eax                      
}                                                                     
  115c3b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  115c3e:	5b                   	pop    %ebx                           
  115c3f:	5e                   	pop    %esi                           
  115c40:	5f                   	pop    %edi                           
  115c41:	c9                   	leave                                 
  115c42:	c3                   	ret                                   
                                                                      

00115c44 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) {
  115c44:	55                   	push   %ebp                           
  115c45:	89 e5                	mov    %esp,%ebp                      
  115c47:	57                   	push   %edi                           
  115c48:	56                   	push   %esi                           
  115c49:	53                   	push   %ebx                           
  115c4a:	8b 75 08             	mov    0x8(%ebp),%esi                 
  Heap_Block        *the_block;                                       
  Heap_Block        *next_block;                                      
  uint32_t           the_size;                                        
                                                                      
  if ( !_Addresses_Is_in_range(                                       
  115c4d:	8b 7e 24             	mov    0x24(%esi),%edi                
  115c50:	8b 5e 20             	mov    0x20(%esi),%ebx                
  115c53:	39 5d 0c             	cmp    %ebx,0xc(%ebp)                 
  115c56:	0f 93 c2             	setae  %dl                            
  115c59:	39 7d 0c             	cmp    %edi,0xc(%ebp)                 
  115c5c:	0f 96 c0             	setbe  %al                            
  115c5f:	84 d0                	test   %dl,%al                        
  115c61:	74 49                	je     115cac <_Heap_Size_of_user_area+0x68>
  115c63:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  115c66:	83 e9 08             	sub    $0x8,%ecx                      
  115c69:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  115c6c:	31 d2                	xor    %edx,%edx                      
  115c6e:	f7 76 10             	divl   0x10(%esi)                     
  115c71:	29 d1                	sub    %edx,%ecx                      
    return( FALSE );                                                  
                                                                      
  _Heap_Start_of_block( the_heap, starting_address, &the_block );     
                                                                      
  _HAssert(_Heap_Is_block_in( the_heap, the_block ));                 
  if ( !_Heap_Is_block_in( the_heap, the_block ) )                    
  115c73:	39 d9                	cmp    %ebx,%ecx                      
  115c75:	0f 93 c2             	setae  %dl                            
  115c78:	39 f9                	cmp    %edi,%ecx                      
  115c7a:	0f 96 c0             	setbe  %al                            
  115c7d:	84 d0                	test   %dl,%al                        
  115c7f:	74 2b                	je     115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
  115c81:	8b 41 04             	mov    0x4(%ecx),%eax                 
  115c84:	83 e0 fe             	and    $0xfffffffe,%eax               
  115c87:	01 c1                	add    %eax,%ecx                      
  the_size   = _Heap_Block_size( the_block );                         
  next_block = _Heap_Block_at( the_block, the_size );                 
                                                                      
  _HAssert(_Heap_Is_block_in( the_heap, next_block ));                
  _HAssert(_Heap_Is_prev_used( next_block ));                         
  if (                                                                
  115c89:	39 d9                	cmp    %ebx,%ecx                      
  115c8b:	0f 93 c2             	setae  %dl                            
  115c8e:	39 f9                	cmp    %edi,%ecx                      
  115c90:	0f 96 c0             	setbe  %al                            
  115c93:	84 d0                	test   %dl,%al                        
  115c95:	74 15                	je     115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
  115c97:	f6 41 04 01          	testb  $0x1,0x4(%ecx)                 
  115c9b:	74 0f                	je     115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
     and then add correction equal to the offset of the 'size' field of the
     'Heap_Block' structure. The correction is due to the fact that   
     'prev_size' field of the next block is actually used as user accessible
     area of 'the_block'. */                                          
                                                                      
  *size = _Addresses_Subtract ( next_block, starting_address )        
  115c9d:	2b 4d 0c             	sub    0xc(%ebp),%ecx                 
  115ca0:	8d 51 04             	lea    0x4(%ecx),%edx                 
  115ca3:	8b 45 10             	mov    0x10(%ebp),%eax                
  115ca6:	89 10                	mov    %edx,(%eax)                    
  115ca8:	b0 01                	mov    $0x1,%al                       
  115caa:	eb 02                	jmp    115cae <_Heap_Size_of_user_area+0x6a>
    + HEAP_BLOCK_HEADER_OFFSET;                                       
                                                                      
  return( TRUE );                                                     
  115cac:	31 c0                	xor    %eax,%eax                      
}                                                                     
  115cae:	5b                   	pop    %ebx                           
  115caf:	5e                   	pop    %esi                           
  115cb0:	5f                   	pop    %edi                           
  115cb1:	c9                   	leave                                 
  115cb2:	c3                   	ret                                   
                                                                      

00110110 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) {
  110110:	55                   	push   %ebp                           
  110111:	89 e5                	mov    %esp,%ebp                      
  110113:	57                   	push   %edi                           
  110114:	56                   	push   %esi                           
  110115:	53                   	push   %ebx                           
  110116:	83 ec 1c             	sub    $0x1c,%esp                     
  110119:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  Heap_Block *the_block = the_heap->start;                            
  11011c:	8b 45 08             	mov    0x8(%ebp),%eax                 
  11011f:	8b 70 20             	mov    0x20(%eax),%esi                
  Heap_Block *const end = the_heap->final;                            
  110122:	8b 50 24             	mov    0x24(%eax),%edx                
  110125:	89 55 e8             	mov    %edx,-0x18(%ebp)               
/*                                                                    
  if ( !_System_state_Is_up( _System_state_Get() ) )                  
    return TRUE;                                                      
*/                                                                    
                                                                      
  if (source < 0)                                                     
  110128:	85 db                	test   %ebx,%ebx                      
  11012a:	79 03                	jns    11012f <_Heap_Walk+0x1f>       <== ALWAYS TAKEN
    source = the_heap->stats.instance;                                
  11012c:	8b 58 28             	mov    0x28(%eax),%ebx                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Handle the 1st block                                             
   */                                                                 
                                                                      
  if (!_Heap_Is_prev_used(the_block)) {                               
  11012f:	31 c9                	xor    %ecx,%ecx                      
  110131:	f6 46 04 01          	testb  $0x1,0x4(%esi)                 
  110135:	75 15                	jne    11014c <_Heap_Walk+0x3c>       <== ALWAYS TAKEN
    printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
  110137:	50                   	push   %eax                           <== NOT EXECUTED
  110138:	50                   	push   %eax                           <== NOT EXECUTED
  110139:	53                   	push   %ebx                           <== NOT EXECUTED
  11013a:	68 18 bb 11 00       	push   $0x11bb18                      <== NOT EXECUTED
  11013f:	e8 92 83 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  110144:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  110149:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    error = 1;                                                        
  }                                                                   
                                                                      
  if (the_block->prev_size != the_heap->page_size) {                  
  11014c:	8b 06                	mov    (%esi),%eax                    
  11014e:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  110151:	3b 47 10             	cmp    0x10(%edi),%eax                
  110154:	0f 84 38 01 00 00    	je     110292 <_Heap_Walk+0x182>      <== ALWAYS TAKEN
    printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
  11015a:	50                   	push   %eax                           <== NOT EXECUTED
  11015b:	50                   	push   %eax                           <== NOT EXECUTED
  11015c:	53                   	push   %ebx                           <== NOT EXECUTED
  11015d:	68 4e bb 11 00       	push   $0x11bb4e                      <== NOT EXECUTED
  110162:	e8 6f 83 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  110167:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  11016c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  11016f:	e9 1e 01 00 00       	jmp    110292 <_Heap_Walk+0x182>      <== NOT EXECUTED
  110174:	8b 46 04             	mov    0x4(%esi),%eax                 
  110177:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  11017a:	83 e0 fe             	and    $0xfffffffe,%eax               
  11017d:	89 45 ec             	mov    %eax,-0x14(%ebp)               
/** @brief _Thread_Is_proxy_blocking                                  
 *                                                                    
 *  status which indicates that a proxy is blocking, and FALSE otherwise.
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (                 
  uint32_t   code                                                     
  110180:	01 f0                	add    %esi,%eax                      
  110182:	89 45 e0             	mov    %eax,-0x20(%ebp)               
        printk(" prev_size %d", the_block->prev_size);                
      else                                                            
        printk(" (prev_size) %d", the_block->prev_size);              
    }                                                                 
                                                                      
    if (!_Heap_Is_block_in(the_heap, next_block)) {                   
  110185:	8b 55 08             	mov    0x8(%ebp),%edx                 
  110188:	3b 42 20             	cmp    0x20(%edx),%eax                
  11018b:	0f 93 c2             	setae  %dl                            
  11018e:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  110191:	3b 47 24             	cmp    0x24(%edi),%eax                
  110194:	0f 96 c0             	setbe  %al                            
  110197:	84 d0                	test   %dl,%al                        
  110199:	75 0f                	jne    1101aa <_Heap_Walk+0x9a>       <== ALWAYS TAKEN
      if (do_dump) printk("\n");                                      
      printk("PASS: %d !block %p is out of heap\n", source, next_block);
  11019b:	50                   	push   %eax                           <== NOT EXECUTED
  11019c:	ff 75 e0             	pushl  -0x20(%ebp)                    <== NOT EXECUTED
  11019f:	53                   	push   %ebx                           <== NOT EXECUTED
  1101a0:	68 80 bb 11 00       	push   $0x11bb80                      <== NOT EXECUTED
  1101a5:	e9 d7 00 00 00       	jmp    110281 <_Heap_Walk+0x171>      <== NOT EXECUTED
      error = 1;                                                      
      break;                                                          
    }                                                                 
                                                                      
    if (!_Heap_Is_prev_used(next_block)) {                            
  1101aa:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  1101ad:	f6 40 04 01          	testb  $0x1,0x4(%eax)                 
  1101b1:	0f 85 85 00 00 00    	jne    11023c <_Heap_Walk+0x12c>      
      if (do_dump)                                                    
        printk( " prev %p next %p", the_block->prev, the_block->next);
      if (_Heap_Block_size(the_block) != next_block->prev_size) {     
  1101b7:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  1101ba:	3b 10                	cmp    (%eax),%edx                    
  1101bc:	74 15                	je     1101d3 <_Heap_Walk+0xc3>       <== ALWAYS TAKEN
        if (do_dump) printk("\n");                                    
        printk("PASS: %d !front and back sizes don't match", source); 
  1101be:	50                   	push   %eax                           <== NOT EXECUTED
  1101bf:	50                   	push   %eax                           <== NOT EXECUTED
  1101c0:	53                   	push   %ebx                           <== NOT EXECUTED
  1101c1:	68 a3 bb 11 00       	push   $0x11bba3                      <== NOT EXECUTED
  1101c6:	e8 0b 83 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  1101cb:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  1101d0:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
        error = 1;                                                    
      }                                                               
      if (!prev_used) {                                               
  1101d3:	f6 45 f0 01          	testb  $0x1,-0x10(%ebp)               
  1101d7:	75 29                	jne    110202 <_Heap_Walk+0xf2>       <== ALWAYS TAKEN
        if (do_dump || error) printk("\n");                           
  1101d9:	85 c9                	test   %ecx,%ecx                      <== NOT EXECUTED
  1101db:	74 10                	je     1101ed <_Heap_Walk+0xdd>       <== NOT EXECUTED
  1101dd:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1101e0:	68 75 b6 11 00       	push   $0x11b675                      <== NOT EXECUTED
  1101e5:	e8 ec 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  1101ea:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
        printk("PASS: %d !two consecutive blocks are free", source);  
  1101ed:	57                   	push   %edi                           <== NOT EXECUTED
  1101ee:	57                   	push   %edi                           <== NOT EXECUTED
  1101ef:	53                   	push   %ebx                           <== NOT EXECUTED
  1101f0:	68 ce bb 11 00       	push   $0x11bbce                      <== NOT EXECUTED
  1101f5:	e8 dc 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  1101fa:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  1101ff:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
}                                                                     
                                                                      
/**                                                                   
  110202:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  110205:	8b 47 08             	mov    0x8(%edi),%eax                 
  110208:	eb 03                	jmp    11020d <_Heap_Walk+0xfd>       
      }                                                               
                                                                      
      { /* Check if 'the_block' is in the free block list */          
        Heap_Block* block = _Heap_First(the_heap);                    
        while(block != the_block && block != tail)                    
          block = block->next;                                        
  11020a:	8b 40 08             	mov    0x8(%eax),%eax                 
        error = 1;                                                    
      }                                                               
                                                                      
      { /* Check if 'the_block' is in the free block list */          
        Heap_Block* block = _Heap_First(the_heap);                    
        while(block != the_block && block != tail)                    
  11020d:	39 f0                	cmp    %esi,%eax                      
  11020f:	74 2b                	je     11023c <_Heap_Walk+0x12c>      
  110211:	3b 45 08             	cmp    0x8(%ebp),%eax                 
  110214:	75 f4                	jne    11020a <_Heap_Walk+0xfa>       <== ALWAYS TAKEN
          block = block->next;                                        
        if(block != the_block) {                                      
          if (do_dump || error) printk("\n");                         
  110216:	85 c9                	test   %ecx,%ecx                      <== NOT EXECUTED
  110218:	74 10                	je     11022a <_Heap_Walk+0x11a>      <== NOT EXECUTED
  11021a:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  11021d:	68 75 b6 11 00       	push   $0x11b675                      <== NOT EXECUTED
  110222:	e8 af 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  110227:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
          printk("PASS: %d !the_block not in the free list", source); 
  11022a:	51                   	push   %ecx                           <== NOT EXECUTED
  11022b:	51                   	push   %ecx                           <== NOT EXECUTED
  11022c:	53                   	push   %ebx                           <== NOT EXECUTED
  11022d:	68 f8 bb 11 00       	push   $0x11bbf8                      <== NOT EXECUTED
  110232:	e8 9f 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  110237:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  11023a:	eb 04                	jmp    110240 <_Heap_Walk+0x130>      <== NOT EXECUTED
          error = 1;                                                  
        }                                                             
      }                                                               
                                                                      
    }                                                                 
    if (do_dump || error) printk("\n");                               
  11023c:	85 c9                	test   %ecx,%ecx                      
  11023e:	74 15                	je     110255 <_Heap_Walk+0x145>      <== ALWAYS TAKEN
  110240:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  110243:	68 75 b6 11 00       	push   $0x11b675                      <== NOT EXECUTED
  110248:	e8 89 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  11024d:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  110252:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
    if (the_size < the_heap->min_block_size) {                        
  110255:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  110258:	8b 45 08             	mov    0x8(%ebp),%eax                 
  11025b:	3b 50 14             	cmp    0x14(%eax),%edx                
  11025e:	73 0a                	jae    11026a <_Heap_Walk+0x15a>      <== ALWAYS TAKEN
      printk("PASS: %d !block size is too small\n", source);          
  110260:	52                   	push   %edx                           <== NOT EXECUTED
  110261:	52                   	push   %edx                           <== NOT EXECUTED
  110262:	53                   	push   %ebx                           <== NOT EXECUTED
  110263:	68 21 bc 11 00       	push   $0x11bc21                      <== NOT EXECUTED
  110268:	eb 17                	jmp    110281 <_Heap_Walk+0x171>      <== NOT EXECUTED
      error = 1;                                                      
      break;                                                          
    }                                                                 
    if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {          
  11026a:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  11026d:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  110270:	31 d2                	xor    %edx,%edx                      
  110272:	f7 77 10             	divl   0x10(%edi)                     
  110275:	85 d2                	test   %edx,%edx                      
  110277:	74 12                	je     11028b <_Heap_Walk+0x17b>      <== ALWAYS TAKEN
      printk("PASS: %d !block size is misaligned\n", source);         
  110279:	50                   	push   %eax                           <== NOT EXECUTED
  11027a:	50                   	push   %eax                           <== NOT EXECUTED
  11027b:	53                   	push   %ebx                           <== NOT EXECUTED
  11027c:	68 44 bc 11 00       	push   $0x11bc44                      <== NOT EXECUTED
  110281:	e8 50 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  110286:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  110289:	eb 12                	jmp    11029d <_Heap_Walk+0x18d>      <== NOT EXECUTED
      error = 1;                                                      
    }                                                                 
                                                                      
    if (++passes > (do_dump ? 10 : 0) && error)                       
  11028b:	85 c9                	test   %ecx,%ecx                      
  11028d:	75 0e                	jne    11029d <_Heap_Walk+0x18d>      <== NEVER TAKEN
      break;                                                          
  11028f:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  if (the_block->prev_size != the_heap->page_size) {                  
    printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
    error = 1;                                                        
  }                                                                   
                                                                      
  while ( the_block != end ) {                                        
  110292:	3b 75 e8             	cmp    -0x18(%ebp),%esi               
  110295:	0f 85 d9 fe ff ff    	jne    110174 <_Heap_Walk+0x64>       
  11029b:	eb 17                	jmp    1102b4 <_Heap_Walk+0x1a4>      
                                                                      
    the_block = next_block;                                           
  }                                                                   
                                                                      
  if (the_block != end) {                                             
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
  11029d:	ff 75 e8             	pushl  -0x18(%ebp)                    <== NOT EXECUTED
  1102a0:	56                   	push   %esi                           <== NOT EXECUTED
  1102a1:	53                   	push   %ebx                           <== NOT EXECUTED
  1102a2:	68 68 bc 11 00       	push   $0x11bc68                      <== NOT EXECUTED
  1102a7:	e8 2a 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  1102ac:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  1102b1:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1102b4:	8b 46 04             	mov    0x4(%esi),%eax                 
  1102b7:	83 e0 fe             	and    $0xfffffffe,%eax               
      source, the_block, end);                                        
    error = 1;                                                        
  }                                                                   
                                                                      
  if (_Heap_Block_size(the_block) != the_heap->page_size) {           
  1102ba:	8b 75 08             	mov    0x8(%ebp),%esi                 
  1102bd:	8b 56 10             	mov    0x10(%esi),%edx                
  1102c0:	39 d0                	cmp    %edx,%eax                      
  1102c2:	74 15                	je     1102d9 <_Heap_Walk+0x1c9>      <== ALWAYS TAKEN
    printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
  1102c4:	52                   	push   %edx                           <== NOT EXECUTED
  1102c5:	50                   	push   %eax                           <== NOT EXECUTED
  1102c6:	53                   	push   %ebx                           <== NOT EXECUTED
  1102c7:	68 a3 bc 11 00       	push   $0x11bca3                      <== NOT EXECUTED
  1102cc:	e8 05 82 ff ff       	call   1084d6 <printk>                <== NOT EXECUTED
  1102d1:	b9 01 00 00 00       	mov    $0x1,%ecx                      <== NOT EXECUTED
  1102d6:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1102d9:	88 c8                	mov    %cl,%al                        
  if(do_dump && error)                                                
    _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
                                                                      
  return error;                                                       
                                                                      
}                                                                     
  1102db:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1102de:	5b                   	pop    %ebx                           
  1102df:	5e                   	pop    %esi                           
  1102e0:	5f                   	pop    %edi                           
  1102e1:	c9                   	leave                                 
  1102e2:	c3                   	ret                                   
                                                                      

0010a1f4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) {
  10a1f4:	55                   	push   %ebp                           
  10a1f5:	89 e5                	mov    %esp,%ebp                      
  10a1f7:	53                   	push   %ebx                           
  10a1f8:	83 ec 08             	sub    $0x8,%esp                      
  10a1fb:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10a1fe:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10a201:	8b 5d 10             	mov    0x10(%ebp),%ebx                
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
  10a204:	89 15 40 d8 11 00    	mov    %edx,0x11d840                  
  _Internal_errors_What_happened.is_internal = is_internal;           
  10a20a:	a2 44 d8 11 00       	mov    %al,0x11d844                   
  _Internal_errors_What_happened.the_error   = the_error;             
  10a20f:	89 1d 48 d8 11 00    	mov    %ebx,0x11d848                  
                                                                      
  _User_extensions_Fatal( the_source, is_internal, the_error );       
  10a215:	53                   	push   %ebx                           
  10a216:	0f b6 c0             	movzbl %al,%eax                       
  10a219:	50                   	push   %eax                           
  10a21a:	52                   	push   %edx                           
  10a21b:	e8 eb 18 00 00       	call   10bb0b <_User_extensions_Fatal>
 *  @param[in] page_size is the size in bytes of the allocation unit  
 *                                                                    
 *  @return This method returns the maximum memory available.  If     
 *          unsuccessful, 0 will be returned.                         
 */                                                                   
static inline uint32_t _Protected_heap_Initialize(                    
  10a220:	c7 05 38 d9 11 00 05 	movl   $0x5,0x11d938                  <== NOT EXECUTED
  10a227:	00 00 00                                                    
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
  10a22a:	fa                   	cli                                   <== NOT EXECUTED
  10a22b:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  10a22d:	f4                   	hlt                                   <== NOT EXECUTED
  10a22e:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10a231:	eb fe                	jmp    10a231 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
                                                                      

0010a288 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) {
  10a288:	55                   	push   %ebp                           
  10a289:	89 e5                	mov    %esp,%ebp                      
  10a28b:	56                   	push   %esi                           
  10a28c:	53                   	push   %ebx                           
  10a28d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
   *  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 )                                       
  10a290:	31 c9                	xor    %ecx,%ecx                      
  10a292:	83 7b 18 00          	cmpl   $0x0,0x18(%ebx)                
  10a296:	74 59                	je     10a2f1 <_Objects_Allocate+0x69><== NEVER TAKEN
                                                                      
  /*                                                                  
   *  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 );
  10a298:	8d 73 20             	lea    0x20(%ebx),%esi                
  10a29b:	83 ec 0c             	sub    $0xc,%esp                      
  10a29e:	56                   	push   %esi                           
  10a29f:	e8 6c f8 ff ff       	call   109b10 <_Chain_Get>            
  10a2a4:	89 c1                	mov    %eax,%ecx                      
                                                                      
  if ( information->auto_extend ) {                                   
  10a2a6:	83 c4 10             	add    $0x10,%esp                     
  10a2a9:	80 7b 12 00          	cmpb   $0x0,0x12(%ebx)                
  10a2ad:	74 42                	je     10a2f1 <_Objects_Allocate+0x69>
    /*                                                                
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
  10a2af:	85 c0                	test   %eax,%eax                      
  10a2b1:	75 1a                	jne    10a2cd <_Objects_Allocate+0x45>
      _Objects_Extend_information( information );                     
  10a2b3:	83 ec 0c             	sub    $0xc,%esp                      
  10a2b6:	53                   	push   %ebx                           
  10a2b7:	e8 64 00 00 00       	call   10a320 <_Objects_Extend_information>
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
  10a2bc:	89 34 24             	mov    %esi,(%esp)                    
  10a2bf:	e8 4c f8 ff ff       	call   109b10 <_Chain_Get>            
  10a2c4:	89 c1                	mov    %eax,%ecx                      
    }                                                                 
                                                                      
    if ( the_object ) {                                               
  10a2c6:	83 c4 10             	add    $0x10,%esp                     
  10a2c9:	85 c0                	test   %eax,%eax                      
  10a2cb:	74 24                	je     10a2f1 <_Objects_Allocate+0x69><== NEVER TAKEN
      uint32_t   block;                                               
                                                                      
      block = _Objects_Get_index( the_object->id ) -                  
  10a2cd:	8b 41 08             	mov    0x8(%ecx),%eax                 
  10a2d0:	25 ff ff 00 00       	and    $0xffff,%eax                   
  10a2d5:	8b 53 08             	mov    0x8(%ebx),%edx                 
  10a2d8:	81 e2 ff ff 00 00    	and    $0xffff,%edx                   
  10a2de:	29 d0                	sub    %edx,%eax                      
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
                                                                      
      information->inactive_per_block[ block ]--;                     
  10a2e0:	31 d2                	xor    %edx,%edx                      
  10a2e2:	f7 73 14             	divl   0x14(%ebx)                     
  10a2e5:	c1 e0 02             	shl    $0x2,%eax                      
  10a2e8:	03 43 30             	add    0x30(%ebx),%eax                
  10a2eb:	ff 08                	decl   (%eax)                         
      information->inactive--;                                        
  10a2ed:	66 ff 4b 2c          	decw   0x2c(%ebx)                     
    }                                                                 
  }                                                                   
                                                                      
  return the_object;                                                  
}                                                                     
  10a2f1:	89 c8                	mov    %ecx,%eax                      
  10a2f3:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a2f6:	5b                   	pop    %ebx                           
  10a2f7:	5e                   	pop    %esi                           
  10a2f8:	c9                   	leave                                 
  10a2f9:	c3                   	ret                                   
                                                                      

0010a320 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) {
  10a320:	55                   	push   %ebp                           
  10a321:	89 e5                	mov    %esp,%ebp                      
  10a323:	57                   	push   %edi                           
  10a324:	56                   	push   %esi                           
  10a325:	53                   	push   %ebx                           
  10a326:	83 ec 5c             	sub    $0x5c,%esp                     
  10a329:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  10a32c:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10a32f:	25 ff ff 00 00       	and    $0xffff,%eax                   
  10a334:	89 45 c8             	mov    %eax,-0x38(%ebp)               
                                                                      
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  if ( information->maximum < minimum_index )                         
  10a337:	0f b7 4b 10          	movzwl 0x10(%ebx),%ecx                
  10a33b:	39 c1                	cmp    %eax,%ecx                      
  10a33d:	73 13                	jae    10a352 <_Objects_Extend_information+0x32>
  10a33f:	89 45 c4             	mov    %eax,-0x3c(%ebp)               
  10a342:	c7 45 bc 00 00 00 00 	movl   $0x0,-0x44(%ebp)               
  10a349:	c7 45 c0 00 00 00 00 	movl   $0x0,-0x40(%ebp)               
  10a350:	eb 35                	jmp    10a387 <_Objects_Extend_information+0x67>
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
  10a352:	8b 7b 14             	mov    0x14(%ebx),%edi                
  10a355:	89 c8                	mov    %ecx,%eax                      
  10a357:	31 d2                	xor    %edx,%edx                      
  10a359:	f7 f7                	div    %edi                           
  10a35b:	89 c6                	mov    %eax,%esi                      
  10a35d:	89 45 bc             	mov    %eax,-0x44(%ebp)               
  10a360:	8b 45 c8             	mov    -0x38(%ebp),%eax               
  10a363:	89 45 c4             	mov    %eax,-0x3c(%ebp)               
  10a366:	c7 45 c0 00 00 00 00 	movl   $0x0,-0x40(%ebp)               
  10a36d:	eb 13                	jmp    10a382 <_Objects_Extend_information+0x62>
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL )              
  10a36f:	8b 43 34             	mov    0x34(%ebx),%eax                
  10a372:	8b 55 c0             	mov    -0x40(%ebp),%edx               
  10a375:	83 3c 90 00          	cmpl   $0x0,(%eax,%edx,4)             
  10a379:	74 0c                	je     10a387 <_Objects_Extend_information+0x67>
        break;                                                        
      else                                                            
        index_base += information->allocation_size;                   
  10a37b:	01 7d c4             	add    %edi,-0x3c(%ebp)               
  if ( information->maximum < minimum_index )                         
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
  10a37e:	42                   	inc    %edx                           
  10a37f:	89 55 c0             	mov    %edx,-0x40(%ebp)               
  10a382:	39 75 c0             	cmp    %esi,-0x40(%ebp)               
  10a385:	72 e8                	jb     10a36f <_Objects_Extend_information+0x4f>
                                                                      
  /*                                                                  
   *  If the index_base is the maximum we need to grow the tables.    
   */                                                                 
                                                                      
  if (index_base >= information->maximum ) {                          
  10a387:	39 4d c4             	cmp    %ecx,-0x3c(%ebp)               
  10a38a:	0f 82 30 01 00 00    	jb     10a4c0 <_Objects_Extend_information+0x1a0>
                                                                      
    /*                                                                
     *  Up the block count and maximum                                
     */                                                               
                                                                      
    block_count++;                                                    
  10a390:	8b 75 bc             	mov    -0x44(%ebp),%esi               
  10a393:	46                   	inc    %esi                           
                                                                      
    maximum = information->maximum + information->allocation_size;    
  10a394:	03 4b 14             	add    0x14(%ebx),%ecx                
  10a397:	89 4d d0             	mov    %ecx,-0x30(%ebp)               
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
                                                                      
    if ( information->auto_extend ) {                                 
  10a39a:	80 7b 12 00          	cmpb   $0x0,0x12(%ebx)                
  10a39e:	8b 7d c8             	mov    -0x38(%ebp),%edi               
  10a3a1:	8d 14 39             	lea    (%ecx,%edi,1),%edx             
  10a3a4:	74 21                	je     10a3c7 <_Objects_Extend_information+0xa7>
      object_blocks = (void**)                                        
  10a3a6:	83 ec 0c             	sub    $0xc,%esp                      
  10a3a9:	8d 04 76             	lea    (%esi,%esi,2),%eax             
  10a3ac:	8d 04 02             	lea    (%edx,%eax,1),%eax             
  10a3af:	c1 e0 02             	shl    $0x2,%eax                      
  10a3b2:	50                   	push   %eax                           
  10a3b3:	e8 71 1a 00 00       	call   10be29 <_Workspace_Allocate>   
  10a3b8:	89 45 a0             	mov    %eax,-0x60(%ebp)               
          block_count *                                               
             (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *))     
          );                                                          
                                                                      
      if ( !object_blocks )                                           
  10a3bb:	83 c4 10             	add    $0x10,%esp                     
  10a3be:	85 c0                	test   %eax,%eax                      
  10a3c0:	75 1d                	jne    10a3df <_Objects_Extend_information+0xbf><== ALWAYS TAKEN
  10a3c2:	e9 c9 01 00 00       	jmp    10a590 <_Objects_Extend_information+0x270><== NOT EXECUTED
        return;                                                       
    }                                                                 
    else {                                                            
      object_blocks = (void**)                                        
  10a3c7:	83 ec 0c             	sub    $0xc,%esp                      
  10a3ca:	8d 04 76             	lea    (%esi,%esi,2),%eax             
  10a3cd:	8d 04 02             	lea    (%edx,%eax,1),%eax             
  10a3d0:	c1 e0 02             	shl    $0x2,%eax                      
  10a3d3:	50                   	push   %eax                           
  10a3d4:	e8 65 1a 00 00       	call   10be3e <_Workspace_Allocate_or_fatal_error>
  10a3d9:	89 45 a0             	mov    %eax,-0x60(%ebp)               
  10a3dc:	83 c4 10             	add    $0x10,%esp                     
    /*                                                                
     *  Break the block into the various sections.                    
     *                                                                
     */                                                               
                                                                      
    inactive_per_block = (uint32_t *) _Addresses_Add_offset(          
  10a3df:	8b 45 a0             	mov    -0x60(%ebp),%eax               
  10a3e2:	8d 04 b0             	lea    (%eax,%esi,4),%eax             
  10a3e5:	89 45 cc             	mov    %eax,-0x34(%ebp)               
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
 *         the heap                                                   
  10a3e8:	8b 55 a0             	mov    -0x60(%ebp),%edx               
  10a3eb:	8d 34 f2             	lea    (%edx,%esi,8),%esi             
  10a3ee:	89 75 d4             	mov    %esi,-0x2c(%ebp)               
     *  in the copies.                                                
     */                                                               
                                                                      
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
  10a3f1:	0f b7 43 10          	movzwl 0x10(%ebx),%eax                
  10a3f5:	31 d2                	xor    %edx,%edx                      
  10a3f7:	3b 45 c8             	cmp    -0x38(%ebp),%eax               
  10a3fa:	76 39                	jbe    10a435 <_Objects_Extend_information+0x115>
      /*                                                              
       *  Copy each section of the table over. This has to be performed as
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
  10a3fc:	8b 45 bc             	mov    -0x44(%ebp),%eax               
  10a3ff:	c1 e0 02             	shl    $0x2,%eax                      
  10a402:	8b 73 34             	mov    0x34(%ebx),%esi                
  10a405:	8b 7d a0             	mov    -0x60(%ebp),%edi               
  10a408:	89 c1                	mov    %eax,%ecx                      
  10a40a:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
  10a40c:	8b 73 30             	mov    0x30(%ebx),%esi                
  10a40f:	8b 7d cc             	mov    -0x34(%ebp),%edi               
  10a412:	89 c1                	mov    %eax,%ecx                      
  10a414:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
  10a416:	0f b7 4b 10          	movzwl 0x10(%ebx),%ecx                
  10a41a:	03 4d c8             	add    -0x38(%ebp),%ecx               
  10a41d:	c1 e1 02             	shl    $0x2,%ecx                      
  10a420:	8b 73 1c             	mov    0x1c(%ebx),%esi                
  10a423:	8b 7d d4             	mov    -0x2c(%ebp),%edi               
  10a426:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
  10a428:	eb 10                	jmp    10a43a <_Objects_Extend_information+0x11a>
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
        local_table[ index ] = NULL;                                  
  10a42a:	8b 45 d4             	mov    -0x2c(%ebp),%eax               
  10a42d:	c7 04 90 00 00 00 00 	movl   $0x0,(%eax,%edx,4)             
    else {                                                            
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
  10a434:	42                   	inc    %edx                           
  10a435:	3b 55 c8             	cmp    -0x38(%ebp),%edx               
  10a438:	72 f0                	jb     10a42a <_Objects_Extend_information+0x10a>
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
                                                                      
    object_blocks[block_count] = NULL;                                
  10a43a:	8b 55 bc             	mov    -0x44(%ebp),%edx               
  10a43d:	8b 4d a0             	mov    -0x60(%ebp),%ecx               
  10a440:	c7 04 91 00 00 00 00 	movl   $0x0,(%ecx,%edx,4)             
    inactive_per_block[block_count] = 0;                              
  10a447:	8b 75 cc             	mov    -0x34(%ebp),%esi               
  10a44a:	c7 04 96 00 00 00 00 	movl   $0x0,(%esi,%edx,4)             
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
  10a451:	8b 4d c4             	mov    -0x3c(%ebp),%ecx               
  10a454:	03 4b 14             	add    0x14(%ebx),%ecx                
  10a457:	8b 7d c4             	mov    -0x3c(%ebp),%edi               
  10a45a:	8b 45 d4             	mov    -0x2c(%ebp),%eax               
  10a45d:	8d 14 b8             	lea    (%eax,%edi,4),%edx             
  10a460:	89 f8                	mov    %edi,%eax                      
  10a462:	eb 0a                	jmp    10a46e <_Objects_Extend_information+0x14e>
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
  10a464:	c7 02 00 00 00 00    	movl   $0x0,(%edx)                    
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
  10a46a:	40                   	inc    %eax                           
  10a46b:	83 c2 04             	add    $0x4,%edx                      
                                                                      
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
  10a46e:	39 c8                	cmp    %ecx,%eax                      
  10a470:	72 f2                	jb     10a464 <_Objects_Extend_information+0x144>
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
  10a472:	9c                   	pushf                                 
  10a473:	fa                   	cli                                   
  10a474:	59                   	pop    %ecx                           
                                                                      
    old_tables = information->object_blocks;                          
  10a475:	8b 73 34             	mov    0x34(%ebx),%esi                
                                                                      
    information->object_blocks = object_blocks;                       
  10a478:	8b 55 a0             	mov    -0x60(%ebp),%edx               
  10a47b:	89 53 34             	mov    %edx,0x34(%ebx)                
    information->inactive_per_block = inactive_per_block;             
  10a47e:	8b 7d cc             	mov    -0x34(%ebp),%edi               
  10a481:	89 7b 30             	mov    %edi,0x30(%ebx)                
    information->local_table = local_table;                           
  10a484:	8b 45 d4             	mov    -0x2c(%ebp),%eax               
  10a487:	89 43 1c             	mov    %eax,0x1c(%ebx)                
    information->maximum = maximum;                                   
  10a48a:	8b 55 d0             	mov    -0x30(%ebp),%edx               
  10a48d:	66 89 53 10          	mov    %dx,0x10(%ebx)                 
    information->maximum_id = _Objects_Build_id(                      
  10a491:	8b 13                	mov    (%ebx),%edx                    
  10a493:	c1 e2 18             	shl    $0x18,%edx                     
  10a496:	81 ca 00 00 01 00    	or     $0x10000,%edx                  
  10a49c:	0f b7 43 04          	movzwl 0x4(%ebx),%eax                 
  10a4a0:	c1 e0 1b             	shl    $0x1b,%eax                     
  10a4a3:	09 c2                	or     %eax,%edx                      
  10a4a5:	0f b7 45 d0          	movzwl -0x30(%ebp),%eax               
  10a4a9:	09 c2                	or     %eax,%edx                      
  10a4ab:	89 53 0c             	mov    %edx,0xc(%ebx)                 
        information->the_class,                                       
        _Objects_Local_node,                                          
        information->maximum                                          
      );                                                              
                                                                      
    _ISR_Enable( level );                                             
  10a4ae:	51                   	push   %ecx                           
  10a4af:	9d                   	popf                                  
                                                                      
    if ( old_tables )                                                 
  10a4b0:	85 f6                	test   %esi,%esi                      
  10a4b2:	74 0c                	je     10a4c0 <_Objects_Extend_information+0x1a0>
      _Workspace_Free( old_tables );                                  
  10a4b4:	83 ec 0c             	sub    $0xc,%esp                      
  10a4b7:	56                   	push   %esi                           
  10a4b8:	e8 57 19 00 00       	call   10be14 <_Workspace_Free>       
  10a4bd:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Allocate the name table, and the objects                        
   */                                                                 
                                                                      
  if ( information->auto_extend ) {                                   
  10a4c0:	80 7b 12 00          	cmpb   $0x0,0x12(%ebx)                
  10a4c4:	8b 43 18             	mov    0x18(%ebx),%eax                
  10a4c7:	74 32                	je     10a4fb <_Objects_Extend_information+0x1db>
    information->object_blocks[ block ] =                             
  10a4c9:	8b 4d c0             	mov    -0x40(%ebp),%ecx               
  10a4cc:	8b 73 34             	mov    0x34(%ebx),%esi                
  10a4cf:	8d 0c 8e             	lea    (%esi,%ecx,4),%ecx             
  10a4d2:	89 4d d8             	mov    %ecx,-0x28(%ebp)               
  10a4d5:	83 ec 0c             	sub    $0xc,%esp                      
  10a4d8:	0f af 43 14          	imul   0x14(%ebx),%eax                
  10a4dc:	50                   	push   %eax                           
  10a4dd:	e8 47 19 00 00       	call   10be29 <_Workspace_Allocate>   
  10a4e2:	8b 7d d8             	mov    -0x28(%ebp),%edi               
  10a4e5:	89 07                	mov    %eax,(%edi)                    
      _Workspace_Allocate(                                            
        (information->allocation_size * information->size)            
      );                                                              
                                                                      
    if ( !information->object_blocks[ block ] )                       
  10a4e7:	8b 43 34             	mov    0x34(%ebx),%eax                
  10a4ea:	83 c4 10             	add    $0x10,%esp                     
  10a4ed:	8b 55 c0             	mov    -0x40(%ebp),%edx               
  10a4f0:	83 3c 90 00          	cmpl   $0x0,(%eax,%edx,4)             
  10a4f4:	75 26                	jne    10a51c <_Objects_Extend_information+0x1fc><== ALWAYS TAKEN
  10a4f6:	e9 95 00 00 00       	jmp    10a590 <_Objects_Extend_information+0x270><== NOT EXECUTED
      return;                                                         
  }                                                                   
  else {                                                              
    information->object_blocks[ block ] =                             
  10a4fb:	8b 4d c0             	mov    -0x40(%ebp),%ecx               
  10a4fe:	8b 73 34             	mov    0x34(%ebx),%esi                
  10a501:	8d 0c 8e             	lea    (%esi,%ecx,4),%ecx             
  10a504:	89 4d dc             	mov    %ecx,-0x24(%ebp)               
  10a507:	83 ec 0c             	sub    $0xc,%esp                      
  10a50a:	0f af 43 14          	imul   0x14(%ebx),%eax                
  10a50e:	50                   	push   %eax                           
  10a50f:	e8 2a 19 00 00       	call   10be3e <_Workspace_Allocate_or_fatal_error>
  10a514:	8b 7d dc             	mov    -0x24(%ebp),%edi               
  10a517:	89 07                	mov    %eax,(%edi)                    
  10a519:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
                                                                      
  _Chain_Initialize(                                                  
  10a51c:	8b 45 c0             	mov    -0x40(%ebp),%eax               
  10a51f:	c1 e0 02             	shl    $0x2,%eax                      
  10a522:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  10a525:	ff 73 18             	pushl  0x18(%ebx)                     
  10a528:	ff 73 14             	pushl  0x14(%ebx)                     
  10a52b:	8b 43 34             	mov    0x34(%ebx),%eax                
  10a52e:	8b 55 c0             	mov    -0x40(%ebp),%edx               
  10a531:	ff 34 90             	pushl  (%eax,%edx,4)                  
  10a534:	8d 7d e8             	lea    -0x18(%ebp),%edi               
  10a537:	57                   	push   %edi                           
  10a538:	e8 1f 38 00 00       	call   10dd5c <_Chain_Initialize>     
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
  10a53d:	8d 4b 20             	lea    0x20(%ebx),%ecx                
  10a540:	89 4d b8             	mov    %ecx,-0x48(%ebp)               
  10a543:	8b 75 c4             	mov    -0x3c(%ebp),%esi               
  10a546:	eb 24                	jmp    10a56c <_Objects_Extend_information+0x24c>
                                                                      
  index = index_base;                                                 
                                                                      
  while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
                                                                      
    the_object->id = _Objects_Build_id(                               
  10a548:	8b 03                	mov    (%ebx),%eax                    
  10a54a:	c1 e0 18             	shl    $0x18,%eax                     
  10a54d:	0d 00 00 01 00       	or     $0x10000,%eax                  
  10a552:	0f b7 53 04          	movzwl 0x4(%ebx),%edx                 
  10a556:	c1 e2 1b             	shl    $0x1b,%edx                     
  10a559:	09 d0                	or     %edx,%eax                      
  10a55b:	09 f0                	or     %esi,%eax                      
  10a55d:	89 41 08             	mov    %eax,0x8(%ecx)                 
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
  10a560:	50                   	push   %eax                           
  10a561:	50                   	push   %eax                           
  10a562:	51                   	push   %ecx                           
  10a563:	ff 75 b8             	pushl  -0x48(%ebp)                    
  10a566:	e8 81 f5 ff ff       	call   109aec <_Chain_Append>         
                                                                      
    index++;                                                          
  10a56b:	46                   	inc    %esi                           
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
                                                                      
  index = index_base;                                                 
                                                                      
  while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
  10a56c:	89 3c 24             	mov    %edi,(%esp)                    
  10a56f:	e8 9c f5 ff ff       	call   109b10 <_Chain_Get>            
  10a574:	89 c1                	mov    %eax,%ecx                      
  10a576:	83 c4 10             	add    $0x10,%esp                     
  10a579:	85 c0                	test   %eax,%eax                      
  10a57b:	75 cb                	jne    10a548 <_Objects_Extend_information+0x228>
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
  10a57d:	8b 43 30             	mov    0x30(%ebx),%eax                
  10a580:	8b 53 14             	mov    0x14(%ebx),%edx                
  10a583:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  10a586:	89 14 30             	mov    %edx,(%eax,%esi,1)             
  information->inactive += information->allocation_size;              
  10a589:	8b 43 14             	mov    0x14(%ebx),%eax                
  10a58c:	66 01 43 2c          	add    %ax,0x2c(%ebx)                 
}                                                                     
  10a590:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a593:	5b                   	pop    %ebx                           
  10a594:	5e                   	pop    %esi                           
  10a595:	5f                   	pop    %edi                           
  10a596:	c9                   	leave                                 
  10a597:	c3                   	ret                                   
                                                                      

0010a62c <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) {
  10a62c:	55                   	push   %ebp                           
  10a62d:	89 e5                	mov    %esp,%ebp                      
  10a62f:	56                   	push   %esi                           
  10a630:	53                   	push   %ebx                           
  10a631:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a634:	8b 75 0c             	mov    0xc(%ebp),%esi                 
/**                                                                   
 *  This function sets @a *size to the size of the block of user memory
 *  which begins at @a starting_address. The size returned in @a *size could
 *  be greater than the size requested for allocation.                
 *  Returns TRUE if the @a starting_address is in the heap, and FALSE 
 *  otherwise.                                                        
  10a637:	8d 43 ff             	lea    -0x1(%ebx),%eax                
  10a63a:	83 f8 03             	cmp    $0x3,%eax                      
  10a63d:	77 2f                	ja     10a66e <_Objects_Get_information+0x42>
  10a63f:	eb 36                	jmp    10a677 <_Objects_Get_information+0x4b>
    return NULL;                                                      
                                                                      
  if ( !the_class )                                                   
    return NULL;                                                      
                                                                      
  the_class_api_maximum = _Objects_API_maximum_class( the_api );      
  10a641:	83 ec 0c             	sub    $0xc,%esp                      
  10a644:	53                   	push   %ebx                           
  10a645:	e8 1a 3b 00 00       	call   10e164 <_Objects_API_maximum_class>
  if ( the_class_api_maximum < 0 ||                                   
  10a64a:	83 c4 10             	add    $0x10,%esp                     
  10a64d:	85 c0                	test   %eax,%eax                      
  10a64f:	78 1d                	js     10a66e <_Objects_Get_information+0x42><== NEVER TAKEN
  10a651:	39 c6                	cmp    %eax,%esi                      
  10a653:	77 19                	ja     10a66e <_Objects_Get_information+0x42><== NEVER TAKEN
       the_class > (uint32_t) the_class_api_maximum )                 
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
  10a655:	8b 04 9d 6c d7 11 00 	mov    0x11d76c(,%ebx,4),%eax         
  10a65c:	85 c0                	test   %eax,%eax                      
  10a65e:	74 0e                	je     10a66e <_Objects_Get_information+0x42><== NEVER TAKEN
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
  10a660:	8b 04 b0             	mov    (%eax,%esi,4),%eax             
  if ( !info )                                                        
  10a663:	85 c0                	test   %eax,%eax                      
  10a665:	74 09                	je     10a670 <_Objects_Get_information+0x44><== NEVER TAKEN
   *  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 )                                         
  10a667:	66 83 78 10 00       	cmpw   $0x0,0x10(%eax)                
  10a66c:	75 02                	jne    10a670 <_Objects_Get_information+0x44>
  10a66e:	31 c0                	xor    %eax,%eax                      
      return NULL;                                                    
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
  10a670:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a673:	5b                   	pop    %ebx                           
  10a674:	5e                   	pop    %esi                           
  10a675:	c9                   	leave                                 
  10a676:	c3                   	ret                                   
  int the_class_api_maximum;                                          
                                                                      
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return NULL;                                                      
                                                                      
  if ( !the_class )                                                   
  10a677:	85 f6                	test   %esi,%esi                      
  10a679:	74 f3                	je     10a66e <_Objects_Get_information+0x42>
  10a67b:	eb c4                	jmp    10a641 <_Objects_Get_information+0x15>
                                                                      

00114fbc <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) {
  114fbc:	55                   	push   %ebp                           
  114fbd:	89 e5                	mov    %esp,%ebp                      
  114fbf:	53                   	push   %ebx                           
  114fc0:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  114fc3:	8b 5d 10             	mov    0x10(%ebp),%ebx                
                                                                      
  /*                                                                  
   * 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;                           
  114fc6:	ba 01 00 00 00       	mov    $0x1,%edx                      
  114fcb:	2b 51 08             	sub    0x8(%ecx),%edx                 
  114fce:	03 55 0c             	add    0xc(%ebp),%edx                 
                                                                      
  if ( information->maximum >= index ) {                              
  114fd1:	0f b7 41 10          	movzwl 0x10(%ecx),%eax                
  114fd5:	39 d0                	cmp    %edx,%eax                      
  114fd7:	72 12                	jb     114feb <_Objects_Get_no_protection+0x2f>
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
  114fd9:	8b 41 1c             	mov    0x1c(%ecx),%eax                
  114fdc:	8b 04 90             	mov    (%eax,%edx,4),%eax             
  114fdf:	85 c0                	test   %eax,%eax                      
  114fe1:	74 08                	je     114feb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
      *location = OBJECTS_LOCAL;                                      
  114fe3:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)                    
  114fe9:	eb 08                	jmp    114ff3 <_Objects_Get_no_protection+0x37>
                                                                      
  /*                                                                  
   *  This isn't supported or required yet for Global objects so      
   *  if it isn't local, we don't find it.                            
   */                                                                 
  *location = OBJECTS_ERROR;                                          
  114feb:	c7 03 01 00 00 00    	movl   $0x1,(%ebx)                    
  114ff1:	31 c0                	xor    %eax,%eax                      
  return NULL;                                                        
}                                                                     
  114ff3:	5b                   	pop    %ebx                           
  114ff4:	c9                   	leave                                 
  114ff5:	c3                   	ret                                   
                                                                      

0010b66c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) {
  10b66c:	55                   	push   %ebp                           
  10b66d:	89 e5                	mov    %esp,%ebp                      
  10b66f:	53                   	push   %ebx                           
  10b670:	83 ec 14             	sub    $0x14,%esp                     
  10b673:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  Objects_Id           tmpId;                                         
  Objects_Information *information;                                   
  Objects_Control     *the_object = (Objects_Control *) 0;            
  Objects_Locations    ignored_location;                              
                                                                      
  if ( !name )                                                        
  10b676:	b8 01 00 00 00       	mov    $0x1,%eax                      
  10b67b:	85 db                	test   %ebx,%ebx                      
  10b67d:	74 59                	je     10b6d8 <_Objects_Id_to_name+0x6c><== NEVER TAKEN
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
  10b67f:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10b682:	85 c9                	test   %ecx,%ecx                      
  10b684:	75 08                	jne    10b68e <_Objects_Id_to_name+0x22>
  10b686:	a1 44 15 12 00       	mov    0x121544,%eax                  
  10b68b:	8b 48 08             	mov    0x8(%eax),%ecx                 
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
  10b68e:	89 ca                	mov    %ecx,%edx                      
  10b690:	c1 ea 18             	shr    $0x18,%edx                     
  10b693:	83 e2 07             	and    $0x7,%edx                      
/**                                                                   
 *  This function sets @a *size to the size of the block of user memory
 *  which begins at @a starting_address. The size returned in @a *size could
 *  be greater than the size requested for allocation.                
 *  Returns TRUE if the @a starting_address is in the heap, and FALSE 
 *  otherwise.                                                        
  10b696:	8d 42 ff             	lea    -0x1(%edx),%eax                
  10b699:	83 f8 03             	cmp    $0x3,%eax                      
  10b69c:	77 35                	ja     10b6d3 <_Objects_Id_to_name+0x67>
  10b69e:	eb 3d                	jmp    10b6dd <_Objects_Id_to_name+0x71>
  if ( !_Objects_Information_table[ the_api ] )                       
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_class = _Objects_Get_class( tmpId );                            
                                                                      
  information = _Objects_Information_table[ the_api ][ the_class ];   
  10b6a0:	89 c8                	mov    %ecx,%eax                      
  10b6a2:	c1 e8 1b             	shr    $0x1b,%eax                     
  10b6a5:	8b 14 82             	mov    (%edx,%eax,4),%edx             
  if ( !information )                                                 
  10b6a8:	85 d2                	test   %edx,%edx                      
  10b6aa:	74 27                	je     10b6d3 <_Objects_Id_to_name+0x67><== NEVER TAKEN
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( information->is_string )                                       
  10b6ac:	80 7a 38 00          	cmpb   $0x0,0x38(%edx)                
  10b6b0:	75 21                	jne    10b6d3 <_Objects_Id_to_name+0x67><== NEVER TAKEN
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
  10b6b2:	50                   	push   %eax                           
  10b6b3:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  10b6b6:	50                   	push   %eax                           
  10b6b7:	51                   	push   %ecx                           
  10b6b8:	52                   	push   %edx                           
  10b6b9:	e8 56 ff ff ff       	call   10b614 <_Objects_Get>          
  if ( !the_object )                                                  
  10b6be:	83 c4 10             	add    $0x10,%esp                     
  10b6c1:	85 c0                	test   %eax,%eax                      
  10b6c3:	74 0e                	je     10b6d3 <_Objects_Id_to_name+0x67>
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
  10b6c5:	8b 40 0c             	mov    0xc(%eax),%eax                 
  10b6c8:	89 03                	mov    %eax,(%ebx)                    
  _Thread_Enable_dispatch();                                          
  10b6ca:	e8 85 07 00 00       	call   10be54 <_Thread_Enable_dispatch>
  10b6cf:	31 c0                	xor    %eax,%eax                      
  10b6d1:	eb 05                	jmp    10b6d8 <_Objects_Id_to_name+0x6c>
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
  10b6d3:	b8 03 00 00 00       	mov    $0x3,%eax                      
}                                                                     
  10b6d8:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b6db:	c9                   	leave                                 
  10b6dc:	c3                   	ret                                   
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
  10b6dd:	8b 14 95 58 14 12 00 	mov    0x121458(,%edx,4),%edx         
  10b6e4:	85 d2                	test   %edx,%edx                      
  10b6e6:	75 b8                	jne    10b6a0 <_Objects_Id_to_name+0x34><== ALWAYS TAKEN
  10b6e8:	eb e9                	jmp    10b6d3 <_Objects_Id_to_name+0x67><== NOT EXECUTED
                                                                      

001132d0 <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) {
  1132d0:	55                   	push   %ebp                           
  1132d1:	89 e5                	mov    %esp,%ebp                      
  1132d3:	57                   	push   %edi                           
  1132d4:	56                   	push   %esi                           
  1132d5:	53                   	push   %ebx                           
  1132d6:	83 ec 0c             	sub    $0xc,%esp                      
  1132d9:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  uint32_t                   index;                                   
  uint32_t                   name_length;                             
                                                                      
  /* ASSERT: information->is_string == TRUE */                        
                                                                      
  if ( !id )                                                          
  1132dc:	b8 02 00 00 00       	mov    $0x2,%eax                      
  1132e1:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  1132e5:	74 59                	je     113340 <_Objects_Name_to_id_string+0x70><== NEVER TAKEN
    return OBJECTS_INVALID_ADDRESS;                                   
                                                                      
  if ( !name )                                                        
  1132e7:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  1132eb:	74 4e                	je     11333b <_Objects_Name_to_id_string+0x6b><== NEVER TAKEN
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  if ( information->maximum != 0 ) {                                  
  1132ed:	8b 47 10             	mov    0x10(%edi),%eax                
  1132f0:	66 85 c0             	test   %ax,%ax                        
  1132f3:	74 46                	je     11333b <_Objects_Name_to_id_string+0x6b><== NEVER TAKEN
  1132f5:	be 01 00 00 00       	mov    $0x1,%esi                      
    name_length = information->name_length;                           
                                                                      
    for ( index = 1; index <= information->maximum; index++ ) {       
  1132fa:	0f b7 c0             	movzwl %ax,%eax                       
  1132fd:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  113300:	eb 34                	jmp    113336 <_Objects_Name_to_id_string+0x66>
      the_object = information->local_table[ index ];                 
  113302:	8b 47 1c             	mov    0x1c(%edi),%eax                
  113305:	8b 1c b0             	mov    (%eax,%esi,4),%ebx             
      if ( !the_object )                                              
  113308:	85 db                	test   %ebx,%ebx                      
  11330a:	74 29                	je     113335 <_Objects_Name_to_id_string+0x65>
        continue;                                                     
                                                                      
      if ( !the_object->name.name_p )                                 
  11330c:	8b 53 0c             	mov    0xc(%ebx),%edx                 
  11330f:	85 d2                	test   %edx,%edx                      
  113311:	74 22                	je     113335 <_Objects_Name_to_id_string+0x65>
        continue;                                                     
                                                                      
      if (!strncmp( name, the_object->name.name_p, information->name_length)) {
  113313:	50                   	push   %eax                           
  113314:	0f b7 47 3a          	movzwl 0x3a(%edi),%eax                
  113318:	50                   	push   %eax                           
  113319:	52                   	push   %edx                           
  11331a:	ff 75 0c             	pushl  0xc(%ebp)                      
  11331d:	e8 5e 25 00 00       	call   115880 <strncmp>               
  113322:	83 c4 10             	add    $0x10,%esp                     
  113325:	85 c0                	test   %eax,%eax                      
  113327:	75 0c                	jne    113335 <_Objects_Name_to_id_string+0x65>
        *id = the_object->id;                                         
  113329:	8b 43 08             	mov    0x8(%ebx),%eax                 
  11332c:	8b 55 10             	mov    0x10(%ebp),%edx                
  11332f:	89 02                	mov    %eax,(%edx)                    
  113331:	31 c0                	xor    %eax,%eax                      
  113333:	eb 0b                	jmp    113340 <_Objects_Name_to_id_string+0x70>
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  if ( information->maximum != 0 ) {                                  
    name_length = information->name_length;                           
                                                                      
    for ( index = 1; index <= information->maximum; index++ ) {       
  113335:	46                   	inc    %esi                           
  113336:	3b 75 f0             	cmp    -0x10(%ebp),%esi               
  113339:	76 c7                	jbe    113302 <_Objects_Name_to_id_string+0x32>
  11333b:	b8 01 00 00 00       	mov    $0x1,%eax                      
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return OBJECTS_INVALID_NAME;                                        
}                                                                     
  113340:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  113343:	5b                   	pop    %ebx                           
  113344:	5e                   	pop    %esi                           
  113345:	5f                   	pop    %edi                           
  113346:	c9                   	leave                                 
  113347:	c3                   	ret                                   
                                                                      

0010a814 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) {
  10a814:	55                   	push   %ebp                           
  10a815:	89 e5                	mov    %esp,%ebp                      
  10a817:	57                   	push   %edi                           
  10a818:	56                   	push   %esi                           
  10a819:	53                   	push   %ebx                           
  10a81a:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10a81d:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10a820:	8b 55 10             	mov    0x10(%ebp),%edx                
  10a823:	8b 75 14             	mov    0x14(%ebp),%esi                
  Objects_Name               name_for_mp;                             
#endif                                                                
                                                                      
  /* ASSERT: information->is_string == FALSE */                       
                                                                      
  if ( !id )                                                          
  10a826:	b8 02 00 00 00       	mov    $0x2,%eax                      
  10a82b:	85 f6                	test   %esi,%esi                      
  10a82d:	74 49                	je     10a878 <_Objects_Name_to_id_u32+0x64>
    return OBJECTS_INVALID_ADDRESS;                                   
                                                                      
  if ( name == 0 )                                                    
  10a82f:	85 db                	test   %ebx,%ebx                      
  10a831:	74 40                	je     10a873 <_Objects_Name_to_id_u32+0x5f>
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  search_local_node = FALSE;                                          
                                                                      
  if ( information->maximum != 0 &&                                   
  10a833:	8b 47 10             	mov    0x10(%edi),%eax                
  10a836:	66 85 c0             	test   %ax,%ax                        
  10a839:	74 38                	je     10a873 <_Objects_Name_to_id_u32+0x5f><== NEVER TAKEN
  10a83b:	85 d2                	test   %edx,%edx                      
  10a83d:	74 28                	je     10a867 <_Objects_Name_to_id_u32+0x53>
  10a83f:	81 fa ff ff ff 7f    	cmp    $0x7fffffff,%edx               
  10a845:	74 20                	je     10a867 <_Objects_Name_to_id_u32+0x53>
  10a847:	4a                   	dec    %edx                           
  10a848:	75 29                	jne    10a873 <_Objects_Name_to_id_u32+0x5f>
  10a84a:	eb 1b                	jmp    10a867 <_Objects_Name_to_id_u32+0x53>
                                                                      
  if ( search_local_node ) {                                          
    name_length = information->name_length;                           
                                                                      
    for ( index = 1; index <= information->maximum; index++ ) {       
      the_object = information->local_table[ index ];                 
  10a84c:	8b 47 1c             	mov    0x1c(%edi),%eax                
  10a84f:	8b 04 90             	mov    (%eax,%edx,4),%eax             
      if ( !the_object )                                              
  10a852:	85 c0                	test   %eax,%eax                      
  10a854:	74 0e                	je     10a864 <_Objects_Name_to_id_u32+0x50>
        continue;                                                     
                                                                      
      if ( name == the_object->name.name_u32 ) {                      
  10a856:	3b 58 0c             	cmp    0xc(%eax),%ebx                 
  10a859:	75 09                	jne    10a864 <_Objects_Name_to_id_u32+0x50>
        *id = the_object->id;                                         
  10a85b:	8b 40 08             	mov    0x8(%eax),%eax                 
  10a85e:	89 06                	mov    %eax,(%esi)                    
  10a860:	31 c0                	xor    %eax,%eax                      
  10a862:	eb 14                	jmp    10a878 <_Objects_Name_to_id_u32+0x64>
   search_local_node = TRUE;                                          
                                                                      
  if ( search_local_node ) {                                          
    name_length = information->name_length;                           
                                                                      
    for ( index = 1; index <= information->maximum; index++ ) {       
  10a864:	42                   	inc    %edx                           
  10a865:	eb 08                	jmp    10a86f <_Objects_Name_to_id_u32+0x5b>
  10a867:	ba 01 00 00 00       	mov    $0x1,%edx                      
  10a86c:	0f b7 c8             	movzwl %ax,%ecx                       
  10a86f:	39 ca                	cmp    %ecx,%edx                      
  10a871:	76 d9                	jbe    10a84c <_Objects_Name_to_id_u32+0x38>
  10a873:	b8 01 00 00 00       	mov    $0x1,%eax                      
  name_for_mp.name_u32 = name;                                        
  return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else                                                                 
  return OBJECTS_INVALID_NAME;                                        
#endif                                                                
}                                                                     
  10a878:	5b                   	pop    %ebx                           
  10a879:	5e                   	pop    %esi                           
  10a87a:	5f                   	pop    %edi                           
  10a87b:	c9                   	leave                                 
  10a87c:	c3                   	ret                                   
                                                                      

0010ae7c <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) {
  10ae7c:	55                   	push   %ebp                           
  10ae7d:	89 e5                	mov    %esp,%ebp                      
  10ae7f:	57                   	push   %edi                           
  10ae80:	56                   	push   %esi                           
  10ae81:	53                   	push   %ebx                           
  10ae82:	83 ec 14             	sub    $0x14,%esp                     
  10ae85:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10ae88:	8b 7d 10             	mov    0x10(%ebp),%edi                
  size_t                 length;                                      
  const char            *s;                                           
                                                                      
  s      = name;                                                      
  length = strnlen( name, information->name_length ) + 1;             
  10ae8b:	0f b7 43 3a          	movzwl 0x3a(%ebx),%eax                
  10ae8f:	50                   	push   %eax                           
  10ae90:	57                   	push   %edi                           
  10ae91:	e8 a6 63 00 00       	call   11123c <strnlen>               
  10ae96:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  10ae99:	89 c6                	mov    %eax,%esi                      
  10ae9b:	46                   	inc    %esi                           
                                                                      
  if ( information->is_string ) {                                     
  10ae9c:	83 c4 10             	add    $0x10,%esp                     
  10ae9f:	80 7b 38 00          	cmpb   $0x0,0x38(%ebx)                
  10aea3:	74 56                	je     10aefb <_Objects_Set_name+0x7f>
    char *d;                                                          
                                                                      
    d = _Workspace_Allocate( length );                                
  10aea5:	83 ec 0c             	sub    $0xc,%esp                      
  10aea8:	56                   	push   %esi                           
  10aea9:	e8 4f 16 00 00       	call   10c4fd <_Workspace_Allocate>   
  10aeae:	89 c3                	mov    %eax,%ebx                      
    if ( !d )                                                         
  10aeb0:	83 c4 10             	add    $0x10,%esp                     
  10aeb3:	31 c0                	xor    %eax,%eax                      
  10aeb5:	85 db                	test   %ebx,%ebx                      
  10aeb7:	0f 84 81 00 00 00    	je     10af3e <_Objects_Set_name+0xc2><== NEVER TAKEN
      return FALSE;                                                   
                                                                      
    if ( the_object->name.name_p ) {                                  
  10aebd:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10aec0:	8b 42 0c             	mov    0xc(%edx),%eax                 
  10aec3:	85 c0                	test   %eax,%eax                      
  10aec5:	74 16                	je     10aedd <_Objects_Set_name+0x61>
      _Workspace_Free( (void *)the_object->name.name_p );             
  10aec7:	83 ec 0c             	sub    $0xc,%esp                      
  10aeca:	50                   	push   %eax                           
  10aecb:	e8 18 16 00 00       	call   10c4e8 <_Workspace_Free>       
      the_object->name.name_p = NULL;                                 
  10aed0:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10aed3:	c7 40 0c 00 00 00 00 	movl   $0x0,0xc(%eax)                 
  10aeda:	83 c4 10             	add    $0x10,%esp                     
    }                                                                 
                                                                      
    strncpy( d, name, length );                                       
  10aedd:	50                   	push   %eax                           
  10aede:	56                   	push   %esi                           
  10aedf:	57                   	push   %edi                           
  10aee0:	53                   	push   %ebx                           
  10aee1:	e8 ce 62 00 00       	call   1111b4 <strncpy>               
    d[ length ] = '\0';                                               
  10aee6:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  10aee9:	c6 44 13 01 00       	movb   $0x0,0x1(%ebx,%edx,1)          
    the_object->name.name_p = d;                                      
  10aeee:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10aef1:	89 58 0c             	mov    %ebx,0xc(%eax)                 
  10aef4:	b0 01                	mov    $0x1,%al                       
  10aef6:	83 c4 10             	add    $0x10,%esp                     
  10aef9:	eb 43                	jmp    10af3e <_Objects_Set_name+0xc2>
  } else {                                                            
    the_object->name.name_u32 =  _Objects_Build_name(                 
  10aefb:	b8 00 00 00 20       	mov    $0x20000000,%eax               
  10af00:	85 f6                	test   %esi,%esi                      
  10af02:	74 4e                	je     10af52 <_Objects_Set_name+0xd6><== NEVER TAKEN
  10af04:	0f be 07             	movsbl (%edi),%eax                    
  10af07:	c1 e0 18             	shl    $0x18,%eax                     
  10af0a:	83 fe 01             	cmp    $0x1,%esi                      
  10af0d:	74 43                	je     10af52 <_Objects_Set_name+0xd6>
  10af0f:	0f be 5f 01          	movsbl 0x1(%edi),%ebx                 
  10af13:	c1 e3 10             	shl    $0x10,%ebx                     
  10af16:	83 fe 02             	cmp    $0x2,%esi                      
  10af19:	76 2b                	jbe    10af46 <_Objects_Set_name+0xca>
  10af1b:	0f be 57 02          	movsbl 0x2(%edi),%edx                 
  10af1f:	c1 e2 08             	shl    $0x8,%edx                      
  10af22:	b9 20 00 00 00       	mov    $0x20,%ecx                     
  10af27:	83 fe 03             	cmp    $0x3,%esi                      
  10af2a:	76 04                	jbe    10af30 <_Objects_Set_name+0xb4>
  10af2c:	0f be 4f 03          	movsbl 0x3(%edi),%ecx                 
  10af30:	09 d8                	or     %ebx,%eax                      
  10af32:	09 d0                	or     %edx,%eax                      
  10af34:	09 c8                	or     %ecx,%eax                      
  10af36:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10af39:	89 42 0c             	mov    %eax,0xc(%edx)                 
  10af3c:	b0 01                	mov    $0x1,%al                       
    );                                                                
                                                                      
  }                                                                   
                                                                      
  return TRUE;                                                        
}                                                                     
  10af3e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10af41:	5b                   	pop    %ebx                           
  10af42:	5e                   	pop    %esi                           
  10af43:	5f                   	pop    %edi                           
  10af44:	c9                   	leave                                 
  10af45:	c3                   	ret                                   
                                                                      
    strncpy( d, name, length );                                       
    d[ length ] = '\0';                                               
    the_object->name.name_p = d;                                      
  } else {                                                            
    the_object->name.name_u32 =  _Objects_Build_name(                 
  10af46:	b9 20 00 00 00       	mov    $0x20,%ecx                     
  10af4b:	ba 00 20 00 00       	mov    $0x2000,%edx                   
  10af50:	eb de                	jmp    10af30 <_Objects_Set_name+0xb4>
  10af52:	bb 00 00 20 00       	mov    $0x200000,%ebx                 
  10af57:	eb ed                	jmp    10af46 <_Objects_Set_name+0xca>
                                                                      

0010a888 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) {
  10a888:	55                   	push   %ebp                           
  10a889:	89 e5                	mov    %esp,%ebp                      
  10a88b:	57                   	push   %edi                           
  10a88c:	56                   	push   %esi                           
  10a88d:	53                   	push   %ebx                           
  10a88e:	83 ec 0c             	sub    $0xc,%esp                      
  10a891:	8b 75 08             	mov    0x8(%ebp),%esi                 
 *  alignments are possible.                                          
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
  10a894:	8b 46 08             	mov    0x8(%esi),%eax                 
  10a897:	0f b7 f8             	movzwl %ax,%edi                       
  /*                                                                  
   * Search the list to find block or chunnk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = ( information->maximum - index_base ) / information->allocation_size;
  10a89a:	8b 4e 14             	mov    0x14(%esi),%ecx                
  10a89d:	0f b7 46 10          	movzwl 0x10(%esi),%eax                
  10a8a1:	29 f8                	sub    %edi,%eax                      
  10a8a3:	31 d2                	xor    %edx,%edx                      
  10a8a5:	f7 f1                	div    %ecx                           
  10a8a7:	89 c3                	mov    %eax,%ebx                      
  10a8a9:	31 d2                	xor    %edx,%edx                      
  10a8ab:	eb 7c                	jmp    10a929 <_Objects_Shrink_information+0xa1>
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
  10a8ad:	8d 04 95 00 00 00 00 	lea    0x0(,%edx,4),%eax              
  10a8b4:	89 45 f0             	mov    %eax,-0x10(%ebp)               
    if ( information->inactive_per_block[ block ] == information->allocation_size ) {
  10a8b7:	8b 46 30             	mov    0x30(%esi),%eax                
  10a8ba:	39 0c 90             	cmp    %ecx,(%eax,%edx,4)             
  10a8bd:	75 67                	jne    10a926 <_Objects_Shrink_information+0x9e>
      /*                                                              
       * XXX - Not to sure how to use a chain where you need to iterate and
       *       and remove elements.                                   
       */                                                             
                                                                      
      the_object = (Objects_Control *) information->Inactive.first;   
  10a8bf:	8b 56 20             	mov    0x20(%esi),%edx                
  10a8c2:	8b 42 08             	mov    0x8(%edx),%eax                 
  10a8c5:	0f b7 c8             	movzwl %ax,%ecx                       
       */                                                             
                                                                      
      do {                                                            
        index = _Objects_Get_index( the_object->id );                 
                                                                      
        if ((index >= index_base) &&                                  
  10a8c8:	39 f9                	cmp    %edi,%ecx                      
  10a8ca:	72 1b                	jb     10a8e7 <_Objects_Shrink_information+0x5f>
  10a8cc:	89 f8                	mov    %edi,%eax                      
  10a8ce:	03 46 14             	add    0x14(%esi),%eax                
  10a8d1:	39 c1                	cmp    %eax,%ecx                      
  10a8d3:	73 12                	jae    10a8e7 <_Objects_Shrink_information+0x5f>
 *  @param[in] start_address is the starting address of the user block
 *         to free                                                    
 *  @return TRUE if successfully freed, FALSE otherwise               
 */                                                                   
bool _Protected_heap_Free(                                            
  Heap_Control *the_heap,                                             
  10a8d5:	8b 1a                	mov    (%edx),%ebx                    
          if ( !_Chain_Is_last( &the_object->Node ) )                 
            the_object = (Objects_Control *) the_object->Node.next;   
          else                                                        
            the_object = NULL;                                        
                                                                      
          _Chain_Extract( &extract_me->Node );                        
  10a8d7:	83 ec 0c             	sub    $0xc,%esp                      
  10a8da:	52                   	push   %edx                           
  10a8db:	e8 64 34 00 00       	call   10dd44 <_Chain_Extract>        
  10a8e0:	89 da                	mov    %ebx,%edx                      
  10a8e2:	83 c4 10             	add    $0x10,%esp                     
  10a8e5:	eb 02                	jmp    10a8e9 <_Objects_Shrink_information+0x61>
        }                                                             
        else {                                                        
          the_object = (Objects_Control *) the_object->Node.next;     
  10a8e7:	8b 12                	mov    (%edx),%edx                    
        }                                                             
      }                                                               
      while ( the_object && !_Chain_Is_last( &the_object->Node ) );   
  10a8e9:	85 d2                	test   %edx,%edx                      
  10a8eb:	74 05                	je     10a8f2 <_Objects_Shrink_information+0x6a><== NEVER TAKEN
  10a8ed:	83 3a 00             	cmpl   $0x0,(%edx)                    
  10a8f0:	75 d0                	jne    10a8c2 <_Objects_Shrink_information+0x3a>
                                                                      
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
  10a8f2:	83 ec 0c             	sub    $0xc,%esp                      
  10a8f5:	8b 46 34             	mov    0x34(%esi),%eax                
  10a8f8:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  10a8fb:	ff 34 10             	pushl  (%eax,%edx,1)                  
  10a8fe:	e8 11 15 00 00       	call   10be14 <_Workspace_Free>       
      information->object_blocks[ block ] = NULL;                     
  10a903:	8b 46 34             	mov    0x34(%esi),%eax                
  10a906:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  10a909:	c7 04 10 00 00 00 00 	movl   $0x0,(%eax,%edx,1)             
      information->inactive_per_block[ block ] = 0;                   
  10a910:	8b 46 30             	mov    0x30(%esi),%eax                
  10a913:	c7 04 10 00 00 00 00 	movl   $0x0,(%eax,%edx,1)             
                                                                      
      information->inactive -= information->allocation_size;          
  10a91a:	8b 46 14             	mov    0x14(%esi),%eax                
  10a91d:	66 29 46 2c          	sub    %ax,0x2c(%esi)                 
  10a921:	83 c4 10             	add    $0x10,%esp                     
  10a924:	eb 07                	jmp    10a92d <_Objects_Shrink_information+0xa5>
                                                                      
      return;                                                         
    }                                                                 
                                                                      
    index_base += information->allocation_size;                       
  10a926:	01 cf                	add    %ecx,%edi                      
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = ( information->maximum - index_base ) / information->allocation_size;
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
  10a928:	42                   	inc    %edx                           
  10a929:	39 da                	cmp    %ebx,%edx                      
  10a92b:	72 80                	jb     10a8ad <_Objects_Shrink_information+0x25>
      return;                                                         
    }                                                                 
                                                                      
    index_base += information->allocation_size;                       
  }                                                                   
}                                                                     
  10a92d:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a930:	5b                   	pop    %ebx                           
  10a931:	5e                   	pop    %esi                           
  10a932:	5f                   	pop    %edi                           
  10a933:	c9                   	leave                                 
  10a934:	c3                   	ret                                   
                                                                      

00109844 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) {
  109844:	55                   	push   %ebp                           
  109845:	89 e5                	mov    %esp,%ebp                      
  109847:	53                   	push   %ebx                           
  109848:	83 ec 04             	sub    $0x4,%esp                      
                                                                      
  /* XXX need to assert here based on size assumptions */             
                                                                      
  assert( sizeof(pthread_t) == sizeof(Objects_Id) );                  
                                                                      
  api_configuration = configuration_table->POSIX_api_configuration;   
  10984b:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10984e:	8b 58 44             	mov    0x44(%eax),%ebx                
  if ( !api_configuration )                                           
  109851:	85 db                	test   %ebx,%ebx                      
  109853:	75 05                	jne    10985a <_POSIX_API_Initialize+0x16><== ALWAYS TAKEN
  109855:	bb e8 72 11 00       	mov    $0x1172e8,%ebx                 <== NOT EXECUTED
    api_configuration = &_POSIX_Default_configuration;                
                                                                      
  _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects;     
  10985a:	c7 05 78 d7 11 00 4c 	movl   $0x11dc4c,0x11d778             
  109861:	dc 11 00                                                    
                                                                      
  _POSIX_signals_Manager_Initialization(                              
  109864:	83 ec 0c             	sub    $0xc,%esp                      
  109867:	ff 73 14             	pushl  0x14(%ebx)                     
  10986a:	e8 f5 3b 00 00       	call   10d464 <_POSIX_signals_Manager_Initialization>
    api_configuration->maximum_queued_signals                         
  );                                                                  
                                                                      
  _POSIX_Threads_Manager_initialization(                              
  10986f:	83 c4 0c             	add    $0xc,%esp                      
  109872:	ff 73 30             	pushl  0x30(%ebx)                     
  109875:	ff 73 2c             	pushl  0x2c(%ebx)                     
  109878:	ff 33                	pushl  (%ebx)                         
  10987a:	e8 67 3d 00 00       	call   10d5e6 <_POSIX_Threads_Manager_initialization>
    api_configuration->maximum_threads,                               
    api_configuration->number_of_initialization_threads,              
    api_configuration->User_initialization_threads_table              
  );                                                                  
                                                                      
  _POSIX_Condition_variables_Manager_initialization(                  
  10987f:	58                   	pop    %eax                           
  109880:	ff 73 08             	pushl  0x8(%ebx)                      
  109883:	e8 cc 3a 00 00       	call   10d354 <_POSIX_Condition_variables_Manager_initialization>
    api_configuration->maximum_condition_variables                    
  );                                                                  
                                                                      
  _POSIX_Key_Manager_initialization( api_configuration->maximum_keys );
  109888:	58                   	pop    %eax                           
  109889:	ff 73 0c             	pushl  0xc(%ebx)                      
  10988c:	e8 eb 3a 00 00       	call   10d37c <_POSIX_Key_Manager_initialization>
                                                                      
  _POSIX_Mutex_Manager_initialization(                                
  109891:	58                   	pop    %eax                           
  109892:	ff 73 04             	pushl  0x4(%ebx)                      
  109895:	e8 52 3b 00 00       	call   10d3ec <_POSIX_Mutex_Manager_initialization>
    api_configuration->maximum_mutexes                                
  );                                                                  
                                                                      
  _POSIX_Message_queue_Manager_initialization(                        
  10989a:	58                   	pop    %eax                           
  10989b:	ff 73 18             	pushl  0x18(%ebx)                     
  10989e:	e8 01 3b 00 00       	call   10d3a4 <_POSIX_Message_queue_Manager_initialization>
    api_configuration->maximum_message_queues                         
  );                                                                  
                                                                      
  _POSIX_Semaphore_Manager_initialization(                            
  1098a3:	58                   	pop    %eax                           
  1098a4:	ff 73 1c             	pushl  0x1c(%ebx)                     
  1098a7:	e8 40 40 00 00       	call   10d8ec <_POSIX_Semaphore_Manager_initialization>
    api_configuration->maximum_semaphores                             
  );                                                                  
                                                                      
  _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers );
  1098ac:	59                   	pop    %ecx                           
  1098ad:	ff 73 10             	pushl  0x10(%ebx)                     
  1098b0:	e8 0f 40 00 00       	call   10d8c4 <_POSIX_Timer_Manager_initialization>
                                                                      
  _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers );
  1098b5:	5a                   	pop    %edx                           
  1098b6:	ff 73 20             	pushl  0x20(%ebx)                     
  1098b9:	e8 56 3b 00 00       	call   10d414 <_POSIX_Barrier_Manager_initialization>
                                                                      
  _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks );
  1098be:	58                   	pop    %eax                           
  1098bf:	ff 73 24             	pushl  0x24(%ebx)                     
  1098c2:	e8 75 3b 00 00       	call   10d43c <_POSIX_RWLock_Manager_initialization>
                                                                      
  _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks);
  1098c7:	83 c4 10             	add    $0x10,%esp                     
  1098ca:	8b 43 28             	mov    0x28(%ebx),%eax                
  1098cd:	89 45 08             	mov    %eax,0x8(%ebp)                 
}                                                                     
  1098d0:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  1098d3:	c9                   	leave                                 
                                                                      
  _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers );
                                                                      
  _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks );
                                                                      
  _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks);
  1098d4:	e9 d3 3c 00 00       	jmp    10d5ac <_POSIX_Spinlock_Manager_initialization>
                                                                      

00109a50 <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) {
  109a50:	55                   	push   %ebp                           
  109a51:	89 e5                	mov    %esp,%ebp                      
  109a53:	56                   	push   %esi                           
  109a54:	53                   	push   %ebx                           
  109a55:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  109a58:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Objects_Id        *id = (Objects_Id *)cond;                         
  int status;                                                         
                                                                      
  if ( !id ) {                                                        
  109a5b:	85 db                	test   %ebx,%ebx                      
  109a5d:	74 16                	je     109a75 <_POSIX_Condition_variables_Get+0x25>
    *location = OBJECTS_ERROR;                                        
    return (POSIX_Condition_variables_Control *) 0;                   
  }                                                                   
                                                                      
  if ( *id == PTHREAD_COND_INITIALIZER ) {                            
  109a5f:	83 3b ff             	cmpl   $0xffffffff,(%ebx)             
  109a62:	75 1b                	jne    109a7f <_POSIX_Condition_variables_Get+0x2f><== ALWAYS TAKEN
    /*                                                                
     *  Do an "auto-create" here.                                     
     */                                                               
                                                                      
    status = pthread_cond_init( (pthread_cond_t *)id, 0 );            
  109a64:	52                   	push   %edx                           <== NOT EXECUTED
  109a65:	52                   	push   %edx                           <== NOT EXECUTED
  109a66:	6a 00                	push   $0x0                           <== NOT EXECUTED
  109a68:	53                   	push   %ebx                           <== NOT EXECUTED
  109a69:	e8 2a 00 00 00       	call   109a98 <pthread_cond_init>     <== NOT EXECUTED
    if ( status ) {                                                   
  109a6e:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  109a71:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  109a73:	74 0a                	je     109a7f <_POSIX_Condition_variables_Get+0x2f><== NOT EXECUTED
      *location = OBJECTS_ERROR;                                      
  109a75:	c7 06 01 00 00 00    	movl   $0x1,(%esi)                    
  109a7b:	31 c0                	xor    %eax,%eax                      
  109a7d:	eb 11                	jmp    109a90 <_POSIX_Condition_variables_Get+0x40>
                                                                      
  /*                                                                  
   *  Now call Objects_Get()                                          
   */                                                                 
                                                                      
  return (POSIX_Condition_variables_Control *)                        
  109a7f:	50                   	push   %eax                           
  109a80:	56                   	push   %esi                           
  109a81:	ff 33                	pushl  (%ebx)                         
  109a83:	68 d4 14 12 00       	push   $0x1214d4                      
  109a88:	e8 3b 29 00 00       	call   10c3c8 <_Objects_Get>          
  109a8d:	83 c4 10             	add    $0x10,%esp                     
    _Objects_Get( &_POSIX_Condition_variables_Information, *id, location );
}                                                                     
  109a90:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  109a93:	5b                   	pop    %ebx                           
  109a94:	5e                   	pop    %esi                           
  109a95:	c9                   	leave                                 
  109a96:	c3                   	ret                                   
                                                                      

00109c00 <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) {
  109c00:	55                   	push   %ebp                           
  109c01:	89 e5                	mov    %esp,%ebp                      
  109c03:	57                   	push   %edi                           
  109c04:	56                   	push   %esi                           
  109c05:	53                   	push   %ebx                           
  109c06:	83 ec 24             	sub    $0x24,%esp                     
  109c09:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  109c0c:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  109c0f:	8a 45 14             	mov    0x14(%ebp),%al                 
  109c12:	88 45 e3             	mov    %al,-0x1d(%ebp)                
  register POSIX_Condition_variables_Control *the_cond;               
  Objects_Locations                           location;               
  int                                         status;                 
  int                                         mutex_status;           
                                                                      
  if ( !_POSIX_Mutex_Get( mutex, &location ) ) {                      
  109c15:	8d 5d f0             	lea    -0x10(%ebp),%ebx               
  109c18:	53                   	push   %ebx                           
  109c19:	56                   	push   %esi                           
  109c1a:	e8 82 01 00 00       	call   109da1 <_POSIX_Mutex_Get>      
  109c1f:	83 c4 10             	add    $0x10,%esp                     
  109c22:	85 c0                	test   %eax,%eax                      
  109c24:	0f 84 af 00 00 00    	je     109cd9 <_POSIX_Condition_variables_Wait_support+0xd9>
  109c2a:	a1 60 10 12 00       	mov    0x121060,%eax                  
  109c2f:	48                   	dec    %eax                           
  109c30:	a3 60 10 12 00       	mov    %eax,0x121060                  
     return EINVAL;                                                   
  }                                                                   
                                                                      
  _Thread_Unnest_dispatch();                                          
                                                                      
  the_cond = _POSIX_Condition_variables_Get( cond, &location );       
  109c35:	52                   	push   %edx                           
  109c36:	52                   	push   %edx                           
  109c37:	53                   	push   %ebx                           
  109c38:	57                   	push   %edi                           
  109c39:	e8 12 fe ff ff       	call   109a50 <_POSIX_Condition_variables_Get>
  109c3e:	89 c3                	mov    %eax,%ebx                      
  switch ( location ) {                                               
  109c40:	83 c4 10             	add    $0x10,%esp                     
  109c43:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  109c47:	0f 85 8c 00 00 00    	jne    109cd9 <_POSIX_Condition_variables_Wait_support+0xd9>
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {       
  109c4d:	8b 40 14             	mov    0x14(%eax),%eax                
  109c50:	85 c0                	test   %eax,%eax                      
  109c52:	74 0b                	je     109c5f <_POSIX_Condition_variables_Wait_support+0x5f>
  109c54:	3b 06                	cmp    (%esi),%eax                    
  109c56:	74 07                	je     109c5f <_POSIX_Condition_variables_Wait_support+0x5f><== ALWAYS TAKEN
        _Thread_Enable_dispatch();                                    
  109c58:	e8 2b 2f 00 00       	call   10cb88 <_Thread_Enable_dispatch><== NOT EXECUTED
  109c5d:	eb 7a                	jmp    109cd9 <_POSIX_Condition_variables_Wait_support+0xd9><== NOT EXECUTED
        return EINVAL;                                                
      }                                                               
                                                                      
      (void) pthread_mutex_unlock( mutex );                           
  109c5f:	83 ec 0c             	sub    $0xc,%esp                      
  109c62:	56                   	push   %esi                           
  109c63:	e8 10 03 00 00       	call   109f78 <pthread_mutex_unlock>  
        _Thread_Enable_dispatch();                                    
        return EINVAL;                                                
      }                                                               
*/                                                                    
                                                                      
      if ( !already_timedout ) {                                      
  109c68:	83 c4 10             	add    $0x10,%esp                     
  109c6b:	80 7d e3 00          	cmpb   $0x0,-0x1d(%ebp)               
  109c6f:	75 4e                	jne    109cbf <_POSIX_Condition_variables_Wait_support+0xbf>
        the_cond->Mutex = *mutex;                                     
  109c71:	8b 06                	mov    (%esi),%eax                    
  109c73:	89 43 14             	mov    %eax,0x14(%ebx)                
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  109c76:	c7 43 48 01 00 00 00 	movl   $0x1,0x48(%ebx)                
                                                                      
        _Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
        _Thread_Executing->Wait.return_code = 0;                      
  109c7d:	8b 15 20 11 12 00    	mov    0x121120,%edx                  
  109c83:	c7 42 34 00 00 00 00 	movl   $0x0,0x34(%edx)                
        _Thread_Executing->Wait.queue       = &the_cond->Wait_queue;  
  109c8a:	8d 4b 18             	lea    0x18(%ebx),%ecx                
  109c8d:	89 4a 44             	mov    %ecx,0x44(%edx)                
        _Thread_Executing->Wait.id          = *cond;                  
  109c90:	8b 07                	mov    (%edi),%eax                    
  109c92:	89 42 20             	mov    %eax,0x20(%edx)                
                                                                      
        _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );      
  109c95:	50                   	push   %eax                           
  109c96:	68 28 d3 10 00       	push   $0x10d328                      
  109c9b:	ff 75 10             	pushl  0x10(%ebp)                     
  109c9e:	51                   	push   %ecx                           
  109c9f:	e8 34 33 00 00       	call   10cfd8 <_Thread_queue_Enqueue_with_handler>
                                                                      
        _Thread_Enable_dispatch();                                    
  109ca4:	e8 df 2e 00 00       	call   10cb88 <_Thread_Enable_dispatch>
        /*                                                            
         *  Switch ourself out because we blocked as a result of the  
         *  _Thread_queue_Enqueue.                                    
         */                                                           
                                                                      
        status = _Thread_Executing->Wait.return_code;                 
  109ca9:	a1 20 11 12 00       	mov    0x121120,%eax                  
  109cae:	8b 58 34             	mov    0x34(%eax),%ebx                
        if ( status && status != ETIMEDOUT )                          
  109cb1:	83 c4 10             	add    $0x10,%esp                     
  109cb4:	85 db                	test   %ebx,%ebx                      
  109cb6:	74 11                	je     109cc9 <_POSIX_Condition_variables_Wait_support+0xc9>
  109cb8:	83 fb 74             	cmp    $0x74,%ebx                     
  109cbb:	75 21                	jne    109cde <_POSIX_Condition_variables_Wait_support+0xde><== NEVER TAKEN
  109cbd:	eb 0a                	jmp    109cc9 <_POSIX_Condition_variables_Wait_support+0xc9>
          return status;                                              
                                                                      
      } else {                                                        
        _Thread_Enable_dispatch();                                    
  109cbf:	e8 c4 2e 00 00       	call   10cb88 <_Thread_Enable_dispatch>
  109cc4:	bb 74 00 00 00       	mov    $0x74,%ebx                     
                                                                      
      /*                                                              
       *  When we get here the dispatch disable level is 0.           
       */                                                             
                                                                      
      mutex_status = pthread_mutex_lock( mutex );                     
  109cc9:	83 ec 0c             	sub    $0xc,%esp                      
  109ccc:	56                   	push   %esi                           
  109ccd:	e8 26 02 00 00       	call   109ef8 <pthread_mutex_lock>    
      if ( mutex_status )                                             
  109cd2:	83 c4 10             	add    $0x10,%esp                     
  109cd5:	85 c0                	test   %eax,%eax                      
  109cd7:	74 05                	je     109cde <_POSIX_Condition_variables_Wait_support+0xde>
  109cd9:	bb 16 00 00 00       	mov    $0x16,%ebx                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
  109cde:	89 d8                	mov    %ebx,%eax                      
  109ce0:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109ce3:	5b                   	pop    %ebx                           
  109ce4:	5e                   	pop    %esi                           
  109ce5:	5f                   	pop    %edi                           
  109ce6:	c9                   	leave                                 
  109ce7:	c3                   	ret                                   
                                                                      

0010ea38 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) {
  10ea38:	55                   	push   %ebp                           
  10ea39:	89 e5                	mov    %esp,%ebp                      
  10ea3b:	57                   	push   %edi                           
  10ea3c:	56                   	push   %esi                           
  10ea3d:	53                   	push   %ebx                           
  10ea3e:	83 ec 0c             	sub    $0xc,%esp                      
  uint32_t             iterations;                                    
  bool                 are_all_null;                                  
  POSIX_Keys_Control  *the_key;                                       
  void                *value;                                         
                                                                      
  thread_index = _Objects_Get_index( thread->Object.id );             
  10ea41:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10ea44:	8b 40 08             	mov    0x8(%eax),%eax                 
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
  10ea47:	89 c2                	mov    %eax,%edx                      
  10ea49:	c1 ea 18             	shr    $0x18,%edx                     
  10ea4c:	83 e2 07             	and    $0x7,%edx                      
                                                                      
      the_key = (POSIX_Keys_Control *)                                
        _POSIX_Keys_Information.local_table[ index ];                 
                                                                      
      if ( the_key && the_key->is_active && the_key->destructor ) {   
        value = the_key->Values[ thread_api ][ thread_index ];        
  10ea4f:	25 ff ff 00 00       	and    $0xffff,%eax                   
  10ea54:	c1 e0 02             	shl    $0x2,%eax                      
  10ea57:	89 45 ec             	mov    %eax,-0x14(%ebp)               
  10ea5a:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)               
  10ea61:	83 c2 04             	add    $0x4,%edx                      
  10ea64:	89 55 e8             	mov    %edx,-0x18(%ebp)               
  10ea67:	be 01 00 00 00       	mov    $0x1,%esi                      
  10ea6c:	bf 01 00 00 00       	mov    $0x1,%edi                      
  10ea71:	eb 49                	jmp    10eabc <_POSIX_Keys_Run_destructors+0x84>
                                                                      
    are_all_null = TRUE;                                              
                                                                      
    for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) {
                                                                      
      the_key = (POSIX_Keys_Control *)                                
  10ea73:	a1 e8 db 11 00       	mov    0x11dbe8,%eax                  
  10ea78:	8b 1c b0             	mov    (%eax,%esi,4),%ebx             
        _POSIX_Keys_Information.local_table[ index ];                 
                                                                      
      if ( the_key && the_key->is_active && the_key->destructor ) {   
  10ea7b:	85 db                	test   %ebx,%ebx                      
  10ea7d:	74 3c                	je     10eabb <_POSIX_Keys_Run_destructors+0x83>
  10ea7f:	80 7b 10 00          	cmpb   $0x0,0x10(%ebx)                
  10ea83:	74 36                	je     10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN
  10ea85:	8b 53 14             	mov    0x14(%ebx),%edx                
  10ea88:	85 d2                	test   %edx,%edx                      
  10ea8a:	74 2f                	je     10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN
        value = the_key->Values[ thread_api ][ thread_index ];        
  10ea8c:	8b 4d e8             	mov    -0x18(%ebp),%ecx               
  10ea8f:	8b 44 8b 08          	mov    0x8(%ebx,%ecx,4),%eax          
  10ea93:	8b 4d ec             	mov    -0x14(%ebp),%ecx               
  10ea96:	8b 04 08             	mov    (%eax,%ecx,1),%eax             
        if ( value ) {                                                
  10ea99:	85 c0                	test   %eax,%eax                      
  10ea9b:	74 1e                	je     10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN
          (*the_key->destructor)( value );                            
  10ea9d:	83 ec 0c             	sub    $0xc,%esp                      
  10eaa0:	50                   	push   %eax                           
  10eaa1:	ff d2                	call   *%edx                          
          if ( the_key->Values[ thread_api ][ thread_index ] )        
  10eaa3:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  10eaa6:	8b 44 93 08          	mov    0x8(%ebx,%edx,4),%eax          
  10eaaa:	83 c4 10             	add    $0x10,%esp                     
  10eaad:	8b 4d ec             	mov    -0x14(%ebp),%ecx               
  10eab0:	83 3c 08 00          	cmpl   $0x0,(%eax,%ecx,1)             
  10eab4:	0f 94 c0             	sete   %al                            
  10eab7:	f7 d8                	neg    %eax                           
  10eab9:	21 c7                	and    %eax,%edi                      
                                                                      
  for ( ; ; ) {                                                       
                                                                      
    are_all_null = TRUE;                                              
                                                                      
    for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) {
  10eabb:	46                   	inc    %esi                           
  10eabc:	0f b7 05 dc db 11 00 	movzwl 0x11dbdc,%eax                  
  10eac3:	39 c6                	cmp    %eax,%esi                      
  10eac5:	76 ac                	jbe    10ea73 <_POSIX_Keys_Run_destructors+0x3b>
            are_all_null = FALSE;                                     
        }                                                             
      }                                                               
    }                                                                 
                                                                      
    if ( are_all_null == TRUE )                                       
  10eac7:	89 f8                	mov    %edi,%eax                      
  10eac9:	84 c0                	test   %al,%al                        
  10eacb:	75 09                	jne    10ead6 <_POSIX_Keys_Run_destructors+0x9e>
      return;                                                         
                                                                      
    iterations++;                                                     
  10eacd:	ff 45 f0             	incl   -0x10(%ebp)                    
     *  loop.  It seems rude to unnecessarily lock up a system.       
     *                                                                
     *  Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.       
     */                                                               
                                                                      
    if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS )                
  10ead0:	83 7d f0 04          	cmpl   $0x4,-0x10(%ebp)               
  10ead4:	75 91                	jne    10ea67 <_POSIX_Keys_Run_destructors+0x2f>
      return;                                                         
  }                                                                   
}                                                                     
  10ead6:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ead9:	5b                   	pop    %ebx                           
  10eada:	5e                   	pop    %esi                           
  10eadb:	5f                   	pop    %edi                           
  10eadc:	c9                   	leave                                 
  10eadd:	c3                   	ret                                   
                                                                      

001123e4 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) {
  1123e4:	55                   	push   %ebp                           
  1123e5:	89 e5                	mov    %esp,%ebp                      
  1123e7:	57                   	push   %edi                           
  1123e8:	56                   	push   %esi                           
  1123e9:	53                   	push   %ebx                           
  1123ea:	83 ec 24             	sub    $0x24,%esp                     
  1123ed:	8b 75 10             	mov    0x10(%ebp),%esi                
  CORE_message_queue_Attributes *the_mq_attr;                         
  struct mq_attr                 attr;                                
  char                          *name;                                
  size_t                         n;                                   
                                                                      
  n = strnlen( name_arg, NAME_MAX );                                  
  1123f0:	68 ff 00 00 00       	push   $0xff                          
  1123f5:	ff 75 08             	pushl  0x8(%ebp)                      
  1123f8:	e8 b7 35 00 00       	call   1159b4 <strnlen>               
  1123fd:	89 c3                	mov    %eax,%ebx                      
  if ( n > NAME_MAX )                                                 
  1123ff:	83 c4 10             	add    $0x10,%esp                     
  112402:	b8 5b 00 00 00       	mov    $0x5b,%eax                     
  112407:	81 fb ff 00 00 00    	cmp    $0xff,%ebx                     
  11240d:	0f 87 34 01 00 00    	ja     112547 <_POSIX_Message_queue_Create_support+0x163><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  112413:	a1 58 63 12 00       	mov    0x126358,%eax                  
  112418:	40                   	inc    %eax                           
  112419:	a3 58 63 12 00       	mov    %eax,0x126358                  
   *  but were not compared against any existing implementation for   
   *  compatibility.  See README.mqueue for an example program we     
   *  think will print out the defaults.  Report anything you find with it.
   */                                                                 
                                                                      
  if ( attr_ptr == NULL ) {                                           
  11241e:	85 f6                	test   %esi,%esi                      
  112420:	75 0d                	jne    11242f <_POSIX_Message_queue_Create_support+0x4b>
  112422:	c7 45 e0 10 00 00 00 	movl   $0x10,-0x20(%ebp)              
  112429:	66 be 0a 00          	mov    $0xa,%si                       
  11242d:	eb 31                	jmp    112460 <_POSIX_Message_queue_Create_support+0x7c>
    attr.mq_maxmsg  = 10;                                             
    attr.mq_msgsize = 16;                                             
  } else {                                                            
    if ( attr_ptr->mq_maxmsg <= 0 ){                                  
  11242f:	83 7e 04 00          	cmpl   $0x0,0x4(%esi)                 
  112433:	7e 06                	jle    11243b <_POSIX_Message_queue_Create_support+0x57>
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    }                                                                 
                                                                      
    if ( attr_ptr->mq_msgsize <= 0 ){                                 
  112435:	83 7e 08 00          	cmpl   $0x0,0x8(%esi)                 
  112439:	7f 12                	jg     11244d <_POSIX_Message_queue_Create_support+0x69>
      _Thread_Enable_dispatch();                                      
  11243b:	e8 f4 d8 ff ff       	call   10fd34 <_Thread_Enable_dispatch>
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  112440:	e8 c7 1f 00 00       	call   11440c <__errno>               
  112445:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  11244b:	eb 39                	jmp    112486 <_POSIX_Message_queue_Create_support+0xa2>
    }                                                                 
                                                                      
    attr = *attr_ptr;                                                 
  11244d:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  112450:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  112455:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  112457:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  11245a:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  11245d:	8b 75 e8             	mov    -0x18(%ebp),%esi               
 *  allocation mutex being used for protection.                       
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
  112460:	83 ec 0c             	sub    $0xc,%esp                      
  112463:	68 c8 66 12 00       	push   $0x1266c8                      
  112468:	e8 77 cc ff ff       	call   10f0e4 <_Objects_Allocate>     
  11246d:	89 c7                	mov    %eax,%edi                      
  }                                                                   
                                                                      
  the_mq = _POSIX_Message_queue_Allocate();                           
  if ( !the_mq ) {                                                    
  11246f:	83 c4 10             	add    $0x10,%esp                     
  112472:	85 c0                	test   %eax,%eax                      
  112474:	75 18                	jne    11248e <_POSIX_Message_queue_Create_support+0xaa><== ALWAYS TAKEN
    _Thread_Enable_dispatch();                                        
  112476:	e8 b9 d8 ff ff       	call   10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENFILE );                   
  11247b:	e8 8c 1f 00 00       	call   11440c <__errno>               <== NOT EXECUTED
  112480:	c7 00 17 00 00 00    	movl   $0x17,(%eax)                   <== NOT EXECUTED
  112486:	83 c8 ff             	or     $0xffffffff,%eax               
  112489:	e9 b9 00 00 00       	jmp    112547 <_POSIX_Message_queue_Create_support+0x163>
  }                                                                   
                                                                      
  the_mq->process_shared  = pshared;                                  
  11248e:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  112491:	89 47 10             	mov    %eax,0x10(%edi)                
  the_mq->named = TRUE;                                               
  112494:	c6 47 14 01          	movb   $0x1,0x14(%edi)                
  the_mq->open_count = 1;                                             
  112498:	c7 47 18 01 00 00 00 	movl   $0x1,0x18(%edi)                
  the_mq->linked = TRUE;                                              
  11249f:	c6 47 15 01          	movb   $0x1,0x15(%edi)                
  /*                                                                  
   * Make a copy of the user's string for name just in case it was    
   * dynamically constructed.                                         
   */                                                                 
                                                                      
  name = _Workspace_Allocate(n);                                      
  1124a3:	83 ec 0c             	sub    $0xc,%esp                      
  1124a6:	53                   	push   %ebx                           
  1124a7:	e8 01 e9 ff ff       	call   110dad <_Workspace_Allocate>   
  1124ac:	89 c3                	mov    %eax,%ebx                      
  if (!name) {                                                        
  1124ae:	83 c4 10             	add    $0x10,%esp                     
  1124b1:	85 c0                	test   %eax,%eax                      
  1124b3:	75 1f                	jne    1124d4 <_POSIX_Message_queue_Create_support+0xf0><== ALWAYS TAKEN
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size,                                                 
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  1124b5:	51                   	push   %ecx                           <== NOT EXECUTED
  1124b6:	51                   	push   %ecx                           <== NOT EXECUTED
  1124b7:	57                   	push   %edi                           <== NOT EXECUTED
  1124b8:	68 c8 66 12 00       	push   $0x1266c8                      <== NOT EXECUTED
  1124bd:	e8 32 cf ff ff       	call   10f3f4 <_Objects_Free>         <== NOT EXECUTED
    _POSIX_Message_queue_Free( the_mq );                              
    _Thread_Enable_dispatch();                                        
  1124c2:	e8 6d d8 ff ff       	call   10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
  1124c7:	e8 40 1f 00 00       	call   11440c <__errno>               <== NOT EXECUTED
  1124cc:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  1124d2:	eb 4f                	jmp    112523 <_POSIX_Message_queue_Create_support+0x13f><== NOT EXECUTED
  }                                                                   
  strcpy( name, name_arg );                                           
  1124d4:	52                   	push   %edx                           
  1124d5:	52                   	push   %edx                           
  1124d6:	ff 75 08             	pushl  0x8(%ebp)                      
  1124d9:	50                   	push   %eax                           
  1124da:	e8 b9 30 00 00       	call   115598 <strcpy>                
   *  Note that thread blocking discipline should be based on the     
   *  current scheduling policy.                                      
   */                                                                 
                                                                      
  the_mq_attr = &the_mq->Message_queue.Attributes;                    
  the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;      
  1124df:	c7 47 5c 00 00 00 00 	movl   $0x0,0x5c(%edi)                
                                                                      
  if ( ! _CORE_message_queue_Initialize(                              
  1124e6:	ff 75 e0             	pushl  -0x20(%ebp)                    
  1124e9:	56                   	push   %esi                           
  1124ea:	8d 47 5c             	lea    0x5c(%edi),%eax                
  1124ed:	50                   	push   %eax                           
  1124ee:	8d 47 1c             	lea    0x1c(%edi),%eax                
  1124f1:	50                   	push   %eax                           
  1124f2:	e8 d1 09 00 00       	call   112ec8 <_CORE_message_queue_Initialize>
  1124f7:	83 c4 20             	add    $0x20,%esp                     
  1124fa:	84 c0                	test   %al,%al                        
  1124fc:	75 2d                	jne    11252b <_POSIX_Message_queue_Create_support+0x147><== ALWAYS TAKEN
  1124fe:	50                   	push   %eax                           <== NOT EXECUTED
  1124ff:	50                   	push   %eax                           <== NOT EXECUTED
  112500:	57                   	push   %edi                           <== NOT EXECUTED
  112501:	68 c8 66 12 00       	push   $0x1266c8                      <== NOT EXECUTED
  112506:	e8 e9 ce ff ff       	call   10f3f4 <_Objects_Free>         <== NOT EXECUTED
           attr.mq_maxmsg,                                            
           attr.mq_msgsize                                            
      ) ) {                                                           
                                                                      
    _POSIX_Message_queue_Free( the_mq );                              
    _Workspace_Free(name);                                            
  11250b:	89 1c 24             	mov    %ebx,(%esp)                    <== NOT EXECUTED
  11250e:	e8 85 e8 ff ff       	call   110d98 <_Workspace_Free>       <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
  112513:	e8 1c d8 ff ff       	call   10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOSPC );                   
  112518:	e8 ef 1e 00 00       	call   11440c <__errno>               <== NOT EXECUTED
  11251d:	c7 00 1c 00 00 00    	movl   $0x1c,(%eax)                   <== NOT EXECUTED
  112523:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  112526:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  112529:	eb 1c                	jmp    112547 <_POSIX_Message_queue_Create_support+0x163><== NOT EXECUTED
  11252b:	0f b7 47 08          	movzwl 0x8(%edi),%eax                 
  11252f:	8b 15 e4 66 12 00    	mov    0x1266e4,%edx                  
  112535:	89 3c 82             	mov    %edi,(%edx,%eax,4)             
  112538:	89 5f 0c             	mov    %ebx,0xc(%edi)                 
    &_POSIX_Message_queue_Information,                                
    &the_mq->Object,                                                  
    name                                                              
  );                                                                  
                                                                      
  *message_queue = the_mq;                                            
  11253b:	8b 45 14             	mov    0x14(%ebp),%eax                
  11253e:	89 38                	mov    %edi,(%eax)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  112540:	e8 ef d7 ff ff       	call   10fd34 <_Thread_Enable_dispatch>
  112545:	31 c0                	xor    %eax,%eax                      
  return 0;                                                           
}                                                                     
  112547:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  11254a:	5b                   	pop    %ebx                           
  11254b:	5e                   	pop    %esi                           
  11254c:	5f                   	pop    %edi                           
  11254d:	c9                   	leave                                 
  11254e:	c3                   	ret                                   
                                                                      

0010c4fc <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) {
  10c4fc:	55                   	push   %ebp                           
  10c4fd:	89 e5                	mov    %esp,%ebp                      
  10c4ff:	53                   	push   %ebx                           
  10c500:	83 ec 04             	sub    $0x4,%esp                      
  10c503:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  if ( !the_mq->linked && !the_mq->open_count ) {                     
  10c506:	80 7b 15 00          	cmpb   $0x0,0x15(%ebx)                
  10c50a:	75 46                	jne    10c552 <_POSIX_Message_queue_Delete+0x56>
  10c50c:	83 7b 18 00          	cmpl   $0x0,0x18(%ebx)                
  10c510:	75 40                	jne    10c552 <_POSIX_Message_queue_Delete+0x56>
      /* the name memory may have been freed by unlink. */            
      Objects_Control *the_object = &the_mq->Object;                  
                                                                      
      if ( the_object->name.name_p )                                  
  10c512:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  10c515:	85 c0                	test   %eax,%eax                      
  10c517:	74 0c                	je     10c525 <_POSIX_Message_queue_Delete+0x29><== ALWAYS TAKEN
        _Workspace_Free( (void *)the_object->name.name_p );           
  10c519:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10c51c:	50                   	push   %eax                           <== NOT EXECUTED
  10c51d:	e8 76 48 00 00       	call   110d98 <_Workspace_Free>       <== NOT EXECUTED
  10c522:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
      _Objects_Close( &_POSIX_Message_queue_Information, the_object );
  10c525:	51                   	push   %ecx                           
  10c526:	51                   	push   %ecx                           
  10c527:	53                   	push   %ebx                           
  10c528:	68 c8 66 12 00       	push   $0x1266c8                      
  10c52d:	e8 26 2c 00 00       	call   10f158 <_Objects_Close>        
                                                                      
      _CORE_message_queue_Close(                                      
  10c532:	83 c4 0c             	add    $0xc,%esp                      
  10c535:	6a 05                	push   $0x5                           
  10c537:	6a 00                	push   $0x0                           
  10c539:	8d 43 1c             	lea    0x1c(%ebx),%eax                
  10c53c:	50                   	push   %eax                           
  10c53d:	e8 32 22 00 00       	call   10e774 <_CORE_message_queue_Close>
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size,                                                 
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  10c542:	58                   	pop    %eax                           
  10c543:	5a                   	pop    %edx                           
  10c544:	53                   	push   %ebx                           
  10c545:	68 c8 66 12 00       	push   $0x1266c8                      
  10c54a:	e8 a5 2e 00 00       	call   10f3f4 <_Objects_Free>         
  10c54f:	83 c4 10             	add    $0x10,%esp                     
      );                                                              
                                                                      
    _POSIX_Message_queue_Free( the_mq );                              
                                                                      
  }                                                                   
}                                                                     
  10c552:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10c555:	c9                   	leave                                 
  10c556:	c3                   	ret                                   
                                                                      

0010c820 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) {
  10c820:	55                   	push   %ebp                           
  10c821:	89 e5                	mov    %esp,%ebp                      
  10c823:	57                   	push   %edi                           
  10c824:	56                   	push   %esi                           
  10c825:	53                   	push   %ebx                           
  10c826:	83 ec 20             	sub    $0x20,%esp                     
  10c829:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10c82c:	8b 75 14             	mov    0x14(%ebp),%esi                
  10c82f:	8a 5d 18             	mov    0x18(%ebp),%bl                 
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
);                                                                    
  10c832:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10c835:	50                   	push   %eax                           
  10c836:	57                   	push   %edi                           
  10c837:	68 44 68 12 00       	push   $0x126844                      
  10c83c:	e8 e7 2c 00 00       	call   10f528 <_Objects_Get>          
  10c841:	89 c1                	mov    %eax,%ecx                      
  Objects_Locations                location;                          
  size_t                           length_out;                        
  bool                             do_wait;                           
                                                                      
  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );        
  switch ( location ) {                                               
  10c843:	83 c4 10             	add    $0x10,%esp                     
  10c846:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10c84a:	0f 85 b0 00 00 00    	jne    10c900 <_POSIX_Message_queue_Receive_support+0xe0>
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {             
  10c850:	8b 50 14             	mov    0x14(%eax),%edx                
  10c853:	89 d0                	mov    %edx,%eax                      
  10c855:	83 e0 03             	and    $0x3,%eax                      
  10c858:	48                   	dec    %eax                           
  10c859:	75 0a                	jne    10c865 <_POSIX_Message_queue_Receive_support+0x45>
        _Thread_Enable_dispatch();                                    
  10c85b:	e8 d4 34 00 00       	call   10fd34 <_Thread_Enable_dispatch>
  10c860:	e9 9b 00 00 00       	jmp    10c900 <_POSIX_Message_queue_Receive_support+0xe0>
        rtems_set_errno_and_return_minus_one( EBADF );                
      }                                                               
                                                                      
      the_mq = the_mq_fd->Queue;                                      
  10c865:	8b 49 10             	mov    0x10(%ecx),%ecx                
                                                                      
      if ( msg_len < the_mq->Message_queue.maximum_message_size ) {   
  10c868:	8b 45 10             	mov    0x10(%ebp),%eax                
  10c86b:	3b 41 68             	cmp    0x68(%ecx),%eax                
  10c86e:	73 15                	jae    10c885 <_POSIX_Message_queue_Receive_support+0x65>
        _Thread_Enable_dispatch();                                    
  10c870:	e8 bf 34 00 00       	call   10fd34 <_Thread_Enable_dispatch>
        rtems_set_errno_and_return_minus_one( EMSGSIZE );             
  10c875:	e8 92 7b 00 00       	call   11440c <__errno>               
  10c87a:	c7 00 7a 00 00 00    	movl   $0x7a,(%eax)                   
  10c880:	e9 86 00 00 00       	jmp    10c90b <_POSIX_Message_queue_Receive_support+0xeb>
      length_out = -1;                                                
                                                                      
      /*                                                              
       *  A timed receive with a bad time will do a poll regardless.  
       */                                                             
      if ( wait )                                                     
  10c885:	31 c0                	xor    %eax,%eax                      
  10c887:	84 db                	test   %bl,%bl                        
  10c889:	74 0b                	je     10c896 <_POSIX_Message_queue_Receive_support+0x76><== NEVER TAKEN
        do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE;     
  10c88b:	c1 ea 0e             	shr    $0xe,%edx                      
  10c88e:	83 f2 01             	xor    $0x1,%edx                      
  10c891:	88 d0                	mov    %dl,%al                        
  10c893:	83 e0 01             	and    $0x1,%eax                      
      /*                                                              
       *  Now if something goes wrong, we return a "length" of -1     
       *  to indicate an error.                                       
       */                                                             
                                                                      
      length_out = -1;                                                
  10c896:	c7 45 ec ff ff ff ff 	movl   $0xffffffff,-0x14(%ebp)        
        do_wait = wait;                                               
                                                                      
      /*                                                              
       *  Now perform the actual message receive                      
       */                                                             
      _CORE_message_queue_Seize(                                      
  10c89d:	52                   	push   %edx                           
  10c89e:	52                   	push   %edx                           
  10c89f:	ff 75 1c             	pushl  0x1c(%ebp)                     
  10c8a2:	0f b6 c0             	movzbl %al,%eax                       
  10c8a5:	50                   	push   %eax                           
  10c8a6:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10c8a9:	50                   	push   %eax                           
  10c8aa:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c8ad:	57                   	push   %edi                           
  10c8ae:	8d 41 1c             	lea    0x1c(%ecx),%eax                
  10c8b1:	50                   	push   %eax                           
  10c8b2:	e8 41 1f 00 00       	call   10e7f8 <_CORE_message_queue_Seize>
        &length_out,                                                  
        do_wait,                                                      
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
  10c8b7:	83 c4 20             	add    $0x20,%esp                     
  10c8ba:	e8 75 34 00 00       	call   10fd34 <_Thread_Enable_dispatch>
      *msg_prio =                                                     
  10c8bf:	8b 0d 18 64 12 00    	mov    0x126418,%ecx                  
  10c8c5:	8b 41 24             	mov    0x24(%ecx),%eax                
  10c8c8:	c1 f8 1f             	sar    $0x1f,%eax                     
  10c8cb:	89 c2                	mov    %eax,%edx                      
  10c8cd:	33 51 24             	xor    0x24(%ecx),%edx                
  10c8d0:	89 16                	mov    %edx,(%esi)                    
  10c8d2:	29 06                	sub    %eax,(%esi)                    
        _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
                                                                      
      if ( !_Thread_Executing->Wait.return_code )                     
  10c8d4:	83 79 34 00          	cmpl   $0x0,0x34(%ecx)                
  10c8d8:	75 05                	jne    10c8df <_POSIX_Message_queue_Receive_support+0xbf>
        return length_out;                                            
  10c8da:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10c8dd:	eb 2f                	jmp    10c90e <_POSIX_Message_queue_Receive_support+0xee>
                                                                      
      rtems_set_errno_and_return_minus_one(                           
  10c8df:	e8 28 7b 00 00       	call   11440c <__errno>               
  10c8e4:	89 c3                	mov    %eax,%ebx                      
  10c8e6:	83 ec 0c             	sub    $0xc,%esp                      
  10c8e9:	a1 18 64 12 00       	mov    0x126418,%eax                  
  10c8ee:	ff 70 34             	pushl  0x34(%eax)                     
  10c8f1:	e8 fa 01 00 00       	call   10caf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
  10c8f6:	89 03                	mov    %eax,(%ebx)                    
  10c8f8:	83 c8 ff             	or     $0xffffffff,%eax               
  10c8fb:	83 c4 10             	add    $0x10,%esp                     
  10c8fe:	eb 0e                	jmp    10c90e <_POSIX_Message_queue_Receive_support+0xee>
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EBADF );                      
  10c900:	e8 07 7b 00 00       	call   11440c <__errno>               
  10c905:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    
  10c90b:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  10c90e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10c911:	5b                   	pop    %ebx                           
  10c912:	5e                   	pop    %esi                           
  10c913:	5f                   	pop    %edi                           
  10c914:	c9                   	leave                                 
  10c915:	c3                   	ret                                   
                                                                      

0010c938 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) {
  10c938:	55                   	push   %ebp                           
  10c939:	89 e5                	mov    %esp,%ebp                      
  10c93b:	56                   	push   %esi                           
  10c93c:	53                   	push   %ebx                           
  10c93d:	83 ec 20             	sub    $0x20,%esp                     
  10c940:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10c943:	8b 5d 14             	mov    0x14(%ebp),%ebx                
  10c946:	8a 45 18             	mov    0x18(%ebp),%al                 
  10c949:	88 45 e7             	mov    %al,-0x19(%ebp)                
  /*                                                                  
   * Validate the priority.                                           
   * XXX - Do not validate msg_prio is not less than 0.               
   */                                                                 
                                                                      
  if ( msg_prio > MQ_PRIO_MAX )                                       
  10c94c:	83 fb 20             	cmp    $0x20,%ebx                     
  10c94f:	76 10                	jbe    10c961 <_POSIX_Message_queue_Send_support+0x29>
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10c951:	e8 b6 7a 00 00       	call   11440c <__errno>               
  10c956:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10c95c:	e9 9c 00 00 00       	jmp    10c9fd <_POSIX_Message_queue_Send_support+0xc5>
  10c961:	50                   	push   %eax                           
  10c962:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10c965:	50                   	push   %eax                           
  10c966:	56                   	push   %esi                           
  10c967:	68 44 68 12 00       	push   $0x126844                      
  10c96c:	e8 b7 2b 00 00       	call   10f528 <_Objects_Get>          
                                                                      
  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );        
  switch ( location ) {                                               
  10c971:	83 c4 10             	add    $0x10,%esp                     
  10c974:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10c978:	75 78                	jne    10c9f2 <_POSIX_Message_queue_Send_support+0xba>
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {             
  10c97a:	8b 50 14             	mov    0x14(%eax),%edx                
  10c97d:	f6 c2 03             	test   $0x3,%dl                       
  10c980:	75 07                	jne    10c989 <_POSIX_Message_queue_Send_support+0x51>
        _Thread_Enable_dispatch();                                    
  10c982:	e8 ad 33 00 00       	call   10fd34 <_Thread_Enable_dispatch>
  10c987:	eb 69                	jmp    10c9f2 <_POSIX_Message_queue_Send_support+0xba>
        rtems_set_errno_and_return_minus_one( EBADF );                
      }                                                               
                                                                      
      the_mq = the_mq_fd->Queue;                                      
  10c989:	8b 48 10             	mov    0x10(%eax),%ecx                
                                                                      
      /*                                                              
       *  A timed receive with a bad time will do a poll regardless.  
       */                                                             
      if ( wait )                                                     
  10c98c:	31 c0                	xor    %eax,%eax                      
  10c98e:	80 7d e7 00          	cmpb   $0x0,-0x19(%ebp)               
  10c992:	74 0b                	je     10c99f <_POSIX_Message_queue_Send_support+0x67><== NEVER TAKEN
        do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE;     
  10c994:	c1 ea 0e             	shr    $0xe,%edx                      
  10c997:	83 f2 01             	xor    $0x1,%edx                      
  10c99a:	88 d0                	mov    %dl,%al                        
  10c99c:	83 e0 01             	and    $0x1,%eax                      
        do_wait = wait;                                               
                                                                      
      /*                                                              
       *  Now perform the actual message receive                      
       */                                                             
      msg_status = _CORE_message_queue_Submit(                        
  10c99f:	ff 75 1c             	pushl  0x1c(%ebp)                     
  10c9a2:	0f b6 c0             	movzbl %al,%eax                       
  10c9a5:	50                   	push   %eax                           
  10c9a6:	f7 db                	neg    %ebx                           
  10c9a8:	53                   	push   %ebx                           
  10c9a9:	6a 00                	push   $0x0                           
  10c9ab:	56                   	push   %esi                           
  10c9ac:	ff 75 10             	pushl  0x10(%ebp)                     
  10c9af:	ff 75 0c             	pushl  0xc(%ebp)                      
  10c9b2:	8d 41 1c             	lea    0x1c(%ecx),%eax                
  10c9b5:	50                   	push   %eax                           
  10c9b6:	e8 85 1f 00 00       	call   10e940 <_CORE_message_queue_Submit>
  10c9bb:	89 c6                	mov    %eax,%esi                      
        _POSIX_Message_queue_Priority_to_core( msg_prio ),            
        do_wait,                                                      
        timeout    /* no timeout */                                   
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
  10c9bd:	83 c4 20             	add    $0x20,%esp                     
  10c9c0:	e8 6f 33 00 00       	call   10fd34 <_Thread_Enable_dispatch>
       *  after it wakes up.  The returned status is correct for      
       *  non-blocking operations but if we blocked, then we need     
       *  to look at the status in our TCB.                           
       */                                                             
                                                                      
      if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 
  10c9c5:	83 fe 07             	cmp    $0x7,%esi                      
  10c9c8:	75 08                	jne    10c9d2 <_POSIX_Message_queue_Send_support+0x9a>
        msg_status = _Thread_Executing->Wait.return_code;             
  10c9ca:	a1 18 64 12 00       	mov    0x126418,%eax                  
  10c9cf:	8b 70 34             	mov    0x34(%eax),%esi                
                                                                      
      if ( !msg_status )                                              
  10c9d2:	31 c0                	xor    %eax,%eax                      
  10c9d4:	85 f6                	test   %esi,%esi                      
  10c9d6:	74 28                	je     10ca00 <_POSIX_Message_queue_Send_support+0xc8>
        return msg_status;                                            
                                                                      
      rtems_set_errno_and_return_minus_one(                           
  10c9d8:	e8 2f 7a 00 00       	call   11440c <__errno>               
  10c9dd:	89 c3                	mov    %eax,%ebx                      
  10c9df:	83 ec 0c             	sub    $0xc,%esp                      
  10c9e2:	56                   	push   %esi                           
  10c9e3:	e8 08 01 00 00       	call   10caf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
  10c9e8:	89 03                	mov    %eax,(%ebx)                    
  10c9ea:	83 c8 ff             	or     $0xffffffff,%eax               
  10c9ed:	83 c4 10             	add    $0x10,%esp                     
  10c9f0:	eb 0e                	jmp    10ca00 <_POSIX_Message_queue_Send_support+0xc8>
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EBADF );                      
  10c9f2:	e8 15 7a 00 00       	call   11440c <__errno>               
  10c9f7:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    
  10c9fd:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  10ca00:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10ca03:	5b                   	pop    %ebx                           
  10ca04:	5e                   	pop    %esi                           
  10ca05:	c9                   	leave                                 
  10ca06:	c3                   	ret                                   
                                                                      

0010a80d <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) {
  10a80d:	55                   	push   %ebp                           
  10a80e:	89 e5                	mov    %esp,%ebp                      
  10a810:	56                   	push   %esi                           
  10a811:	53                   	push   %ebx                           
  10a812:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a815:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Objects_Id *id = (Objects_Id *)mutex;                               
                                                                      
  ___POSIX_Mutex_Get_support( id, location );                         
  10a818:	85 db                	test   %ebx,%ebx                      
  10a81a:	74 16                	je     10a832 <_POSIX_Mutex_Get+0x25> 
  10a81c:	83 3b ff             	cmpl   $0xffffffff,(%ebx)             
  10a81f:	75 1b                	jne    10a83c <_POSIX_Mutex_Get+0x2f> <== ALWAYS TAKEN
  10a821:	51                   	push   %ecx                           <== NOT EXECUTED
  10a822:	51                   	push   %ecx                           <== NOT EXECUTED
  10a823:	6a 00                	push   $0x0                           <== NOT EXECUTED
  10a825:	53                   	push   %ebx                           <== NOT EXECUTED
  10a826:	e8 6d 00 00 00       	call   10a898 <pthread_mutex_init>    <== NOT EXECUTED
  10a82b:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10a82e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10a830:	74 0a                	je     10a83c <_POSIX_Mutex_Get+0x2f> <== NOT EXECUTED
  10a832:	c7 06 01 00 00 00    	movl   $0x1,(%esi)                    
  10a838:	31 c0                	xor    %eax,%eax                      
  10a83a:	eb 11                	jmp    10a84d <_POSIX_Mutex_Get+0x40> 
                                                                      
  return (POSIX_Mutex_Control *)                                      
  10a83c:	52                   	push   %edx                           
  10a83d:	56                   	push   %esi                           
  10a83e:	ff 33                	pushl  (%ebx)                         
  10a840:	68 18 2f 12 00       	push   $0x122f18                      
  10a845:	e8 1a 29 00 00       	call   10d164 <_Objects_Get>          
  10a84a:	83 c4 10             	add    $0x10,%esp                     
    _Objects_Get( &_POSIX_Mutex_Information, *id, location );         
}                                                                     
  10a84d:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a850:	5b                   	pop    %ebx                           
  10a851:	5e                   	pop    %esi                           
  10a852:	c9                   	leave                                 
  10a853:	c3                   	ret                                   
                                                                      

0010a7c4 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) {
  10a7c4:	55                   	push   %ebp                           
  10a7c5:	89 e5                	mov    %esp,%ebp                      
  10a7c7:	56                   	push   %esi                           
  10a7c8:	53                   	push   %ebx                           
  10a7c9:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a7cc:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Objects_Id *id = (Objects_Id *)mutex;                               
                                                                      
  ___POSIX_Mutex_Get_support( id, location );                         
  10a7cf:	85 db                	test   %ebx,%ebx                      
  10a7d1:	74 16                	je     10a7e9 <_POSIX_Mutex_Get_interrupt_disable+0x25><== NEVER TAKEN
  10a7d3:	83 3b ff             	cmpl   $0xffffffff,(%ebx)             
  10a7d6:	75 1b                	jne    10a7f3 <_POSIX_Mutex_Get_interrupt_disable+0x2f><== ALWAYS TAKEN
  10a7d8:	50                   	push   %eax                           <== NOT EXECUTED
  10a7d9:	50                   	push   %eax                           <== NOT EXECUTED
  10a7da:	6a 00                	push   $0x0                           <== NOT EXECUTED
  10a7dc:	53                   	push   %ebx                           <== NOT EXECUTED
  10a7dd:	e8 b6 00 00 00       	call   10a898 <pthread_mutex_init>    <== NOT EXECUTED
  10a7e2:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10a7e5:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10a7e7:	74 0a                	je     10a7f3 <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NOT EXECUTED
  10a7e9:	c7 06 01 00 00 00    	movl   $0x1,(%esi)                    <== NOT EXECUTED
  10a7ef:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  10a7f1:	eb 13                	jmp    10a806 <_POSIX_Mutex_Get_interrupt_disable+0x42><== NOT EXECUTED
                                                                      
  return (POSIX_Mutex_Control *)                                      
  10a7f3:	ff 75 10             	pushl  0x10(%ebp)                     
  10a7f6:	56                   	push   %esi                           
  10a7f7:	ff 33                	pushl  (%ebx)                         
  10a7f9:	68 18 2f 12 00       	push   $0x122f18                      
  10a7fe:	e8 15 29 00 00       	call   10d118 <_Objects_Get_isr_disable>
  10a803:	83 c4 10             	add    $0x10,%esp                     
    _Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level );
}                                                                     
  10a806:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a809:	5b                   	pop    %ebx                           
  10a80a:	5e                   	pop    %esi                           
  10a80b:	c9                   	leave                                 
  10a80c:	c3                   	ret                                   
                                                                      

00110ae0 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) {
  110ae0:	55                   	push   %ebp                           
  110ae1:	89 e5                	mov    %esp,%ebp                      
  110ae3:	57                   	push   %edi                           
  110ae4:	56                   	push   %esi                           
  110ae5:	53                   	push   %ebx                           
  110ae6:	83 ec 0c             	sub    $0xc,%esp                      
  110ae9:	8b 75 08             	mov    0x8(%ebp),%esi                 
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  110aec:	a1 10 35 12 00       	mov    0x123510,%eax                  
  110af1:	40                   	inc    %eax                           
  110af2:	a3 10 35 12 00       	mov    %eax,0x123510                  
  char                      *name_p = (char *)name;                   
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  /* Sharing semaphores among processes is not currently supported */ 
  if (pshared != 0) {                                                 
  110af7:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  110afb:	74 12                	je     110b0f <_POSIX_Semaphore_Create_support+0x2f>
    _Thread_Enable_dispatch();                                        
  110afd:	e8 e6 d1 ff ff       	call   10dce8 <_Thread_Enable_dispatch>
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
  110b02:	e8 5d 1b 00 00       	call   112664 <__errno>               
  110b07:	c7 00 58 00 00 00    	movl   $0x58,(%eax)                   
  110b0d:	eb 28                	jmp    110b37 <_POSIX_Semaphore_Create_support+0x57>
  }                                                                   
                                                                      
  if ( name ) {                                                       
  110b0f:	85 f6                	test   %esi,%esi                      
  110b11:	74 2c                	je     110b3f <_POSIX_Semaphore_Create_support+0x5f>
    if( strlen(name) > PATH_MAX ) {                                   
  110b13:	31 c0                	xor    %eax,%eax                      
  110b15:	83 c9 ff             	or     $0xffffffff,%ecx               
  110b18:	89 f7                	mov    %esi,%edi                      
  110b1a:	f2 ae                	repnz scas %es:(%edi),%al             
  110b1c:	f7 d1                	not    %ecx                           
  110b1e:	49                   	dec    %ecx                           
  110b1f:	81 f9 ff 00 00 00    	cmp    $0xff,%ecx                     
  110b25:	76 18                	jbe    110b3f <_POSIX_Semaphore_Create_support+0x5f><== ALWAYS TAKEN
      _Thread_Enable_dispatch();                                      
  110b27:	e8 bc d1 ff ff       	call   10dce8 <_Thread_Enable_dispatch><== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENAMETOOLONG );           
  110b2c:	e8 33 1b 00 00       	call   112664 <__errno>               <== NOT EXECUTED
  110b31:	c7 00 5b 00 00 00    	movl   $0x5b,(%eax)                   <== NOT EXECUTED
  110b37:	83 c8 ff             	or     $0xffffffff,%eax               
  110b3a:	e9 90 00 00 00       	jmp    110bcf <_POSIX_Semaphore_Create_support+0xef>
 *  It is a simple wrapper for the help with the addition of the      
 *  allocation mutex being used for protection.                       
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
  110b3f:	83 ec 0c             	sub    $0xc,%esp                      
  110b42:	68 00 38 12 00       	push   $0x123800                      
  110b47:	e8 98 c5 ff ff       	call   10d0e4 <_Objects_Allocate>     
  110b4c:	89 c3                	mov    %eax,%ebx                      
    }                                                                 
  }                                                                   
                                                                      
  the_semaphore = _POSIX_Semaphore_Allocate();                        
                                                                      
  if ( !the_semaphore ) {                                             
  110b4e:	83 c4 10             	add    $0x10,%esp                     
  110b51:	85 c0                	test   %eax,%eax                      
  110b53:	75 12                	jne    110b67 <_POSIX_Semaphore_Create_support+0x87>
    _Thread_Enable_dispatch();                                        
  110b55:	e8 8e d1 ff ff       	call   10dce8 <_Thread_Enable_dispatch>
    rtems_set_errno_and_return_minus_one( ENOSPC );                   
  110b5a:	e8 05 1b 00 00       	call   112664 <__errno>               
  110b5f:	c7 00 1c 00 00 00    	movl   $0x1c,(%eax)                   
  110b65:	eb d0                	jmp    110b37 <_POSIX_Semaphore_Create_support+0x57>
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
  110b67:	c7 40 10 00 00 00 00 	movl   $0x0,0x10(%eax)                
                                                                      
  if ( name ) {                                                       
  110b6e:	85 f6                	test   %esi,%esi                      
  110b70:	74 11                	je     110b83 <_POSIX_Semaphore_Create_support+0xa3>
    the_semaphore->named = TRUE;                                      
  110b72:	c6 40 14 01          	movb   $0x1,0x14(%eax)                
    the_semaphore->open_count = 1;                                    
  110b76:	c7 40 18 01 00 00 00 	movl   $0x1,0x18(%eax)                
    the_semaphore->linked = TRUE;                                     
  110b7d:	c6 40 15 01          	movb   $0x1,0x15(%eax)                
  110b81:	eb 0f                	jmp    110b92 <_POSIX_Semaphore_Create_support+0xb2>
  } else {                                                            
    the_semaphore->named = FALSE;                                     
  110b83:	c6 40 14 00          	movb   $0x0,0x14(%eax)                
    the_semaphore->open_count = 0;                                    
  110b87:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)                
    the_semaphore->linked = FALSE;                                    
  110b8e:	c6 40 15 00          	movb   $0x0,0x15(%eax)                
   *  be derived from the current scheduling policy.  One             
   *  thing is certain, no matter what we decide, it won't be         
   *  the same as  all other POSIX implementations. :)                
   */                                                                 
                                                                      
  the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;         
  110b92:	c7 43 60 00 00 00 00 	movl   $0x0,0x60(%ebx)                
                                                                      
  /*                                                                  
   *  This effectively disables limit checking.                       
   */                                                                 
                                                                      
  the_sem_attr->maximum_count = 0xFFFFFFFF;                           
  110b99:	c7 43 5c ff ff ff ff 	movl   $0xffffffff,0x5c(%ebx)         
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
  110ba0:	50                   	push   %eax                           
  110ba1:	ff 75 10             	pushl  0x10(%ebp)                     
  110ba4:	8d 43 5c             	lea    0x5c(%ebx),%eax                
  110ba7:	50                   	push   %eax                           
  110ba8:	8d 43 1c             	lea    0x1c(%ebx),%eax                
  110bab:	50                   	push   %eax                           
  110bac:	e8 6f c1 ff ff       	call   10cd20 <_CORE_semaphore_Initialize>
  110bb1:	0f b7 53 08          	movzwl 0x8(%ebx),%edx                 
  110bb5:	a1 1c 38 12 00       	mov    0x12381c,%eax                  
  110bba:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  110bbd:	89 73 0c             	mov    %esi,0xc(%ebx)                 
    &_POSIX_Semaphore_Information,                                    
    &the_semaphore->Object,                                           
    name_p                                                            
  );                                                                  
                                                                      
  *the_sem = the_semaphore;                                           
  110bc0:	8b 45 14             	mov    0x14(%ebp),%eax                
  110bc3:	89 18                	mov    %ebx,(%eax)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  110bc5:	e8 1e d1 ff ff       	call   10dce8 <_Thread_Enable_dispatch>
  110bca:	31 c0                	xor    %eax,%eax                      
  110bcc:	83 c4 10             	add    $0x10,%esp                     
  return 0;                                                           
}                                                                     
  110bcf:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  110bd2:	5b                   	pop    %ebx                           
  110bd3:	5e                   	pop    %esi                           
  110bd4:	5f                   	pop    %edi                           
  110bd5:	c9                   	leave                                 
  110bd6:	c3                   	ret                                   
                                                                      

0010d6cd <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) {
  10d6cd:	55                   	push   %ebp                           
  10d6ce:	89 e5                	mov    %esp,%ebp                      
  10d6d0:	57                   	push   %edi                           
  10d6d1:	56                   	push   %esi                           
  10d6d2:	53                   	push   %ebx                           
  10d6d3:	83 ec 18             	sub    $0x18,%esp                     
  POSIX_API_Control *api;                                             
  POSIX_API_Control *executing_api;                                   
                                                                      
  api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );           
  10d6d6:	68 e4 00 00 00       	push   $0xe4                          
  10d6db:	e8 49 e7 ff ff       	call   10be29 <_Workspace_Allocate>   
  10d6e0:	89 c3                	mov    %eax,%ebx                      
                                                                      
  if ( !api )                                                         
  10d6e2:	83 c4 10             	add    $0x10,%esp                     
  10d6e5:	31 c0                	xor    %eax,%eax                      
  10d6e7:	85 db                	test   %ebx,%ebx                      
  10d6e9:	0f 84 05 01 00 00    	je     10d7f4 <_POSIX_Threads_Create_extension+0x127><== NEVER TAKEN
    return false;                                                     
                                                                      
  created->API_Extensions[ THREAD_API_POSIX ] = api;                  
  10d6ef:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10d6f2:	89 98 f8 00 00 00    	mov    %ebx,0xf8(%eax)                
                                                                      
  /* XXX check all fields are touched */                              
  api->Attributes  = _POSIX_Threads_Default_attributes;               
  10d6f8:	be 38 79 11 00       	mov    $0x117938,%esi                 
  10d6fd:	b9 0e 00 00 00       	mov    $0xe,%ecx                      
  10d702:	89 df                	mov    %ebx,%edi                      
  10d704:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  api->detachstate = _POSIX_Threads_Default_attributes.detachstate;   
  10d706:	c7 43 38 01 00 00 00 	movl   $0x1,0x38(%ebx)                
  api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;   
  10d70d:	c7 43 7c 01 00 00 00 	movl   $0x1,0x7c(%ebx)                
  api->schedparam  = _POSIX_Threads_Default_attributes.schedparam;    
  10d714:	be 50 79 11 00       	mov    $0x117950,%esi                 
  10d719:	8d bb 80 00 00 00    	lea    0x80(%ebx),%edi                
  10d71f:	b1 06                	mov    $0x6,%cl                       
  10d721:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  api->schedparam.sched_priority =                                    
  10d723:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  10d728:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10d72b:	2b 42 14             	sub    0x14(%edx),%eax                
  10d72e:	89 83 80 00 00 00    	mov    %eax,0x80(%ebx)                
     _POSIX_Priority_From_core( created->current_priority );          
                                                                      
  /*                                                                  
   *  POSIX 1003.1 1996, 18.2.2.2                                     
   */                                                                 
  api->cancelation_requested = 0;                                     
  10d734:	c7 83 d4 00 00 00 00 	movl   $0x0,0xd4(%ebx)                
  10d73b:	00 00 00                                                    
  api->cancelability_state = PTHREAD_CANCEL_ENABLE;                   
  10d73e:	c7 83 cc 00 00 00 00 	movl   $0x0,0xcc(%ebx)                
  10d745:	00 00 00                                                    
  api->cancelability_type = PTHREAD_CANCEL_DEFERRED;                  
  10d748:	c7 83 d0 00 00 00 00 	movl   $0x0,0xd0(%ebx)                
  10d74f:	00 00 00                                                    
  10d752:	8d 83 dc 00 00 00    	lea    0xdc(%ebx),%eax                
  10d758:	89 83 d8 00 00 00    	mov    %eax,0xd8(%ebx)                
  10d75e:	c7 83 dc 00 00 00 00 	movl   $0x0,0xdc(%ebx)                
  10d765:	00 00 00                                                    
  10d768:	8d 83 d8 00 00 00    	lea    0xd8(%ebx),%eax                
  10d76e:	89 83 e0 00 00 00    	mov    %eax,0xe0(%ebx)                
   *  If the thread is not a posix thread, then all posix signals are blocked
   *  by default.                                                     
   */                                                                 
                                                                      
  /* XXX use signal constants */                                      
  api->signals_pending = 0;                                           
  10d774:	c7 83 c8 00 00 00 00 	movl   $0x0,0xc8(%ebx)                
  10d77b:	00 00 00                                                    
  if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 
  10d77e:	8b 52 08             	mov    0x8(%edx),%edx                 
  10d781:	89 d0                	mov    %edx,%eax                      
  10d783:	c1 e8 18             	shr    $0x18,%eax                     
  10d786:	83 e0 07             	and    $0x7,%eax                      
  10d789:	83 f8 03             	cmp    $0x3,%eax                      
  10d78c:	75 1f                	jne    10d7ad <_POSIX_Threads_Create_extension+0xe0>
  10d78e:	c1 ea 1b             	shr    $0x1b,%edx                     
  10d791:	4a                   	dec    %edx                           
  10d792:	75 19                	jne    10d7ad <_POSIX_Threads_Create_extension+0xe0><== NEVER TAKEN
       _Objects_Get_class( created->Object.id ) == 1 ) {              
    executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
    api->signals_blocked = executing_api->signals_blocked;            
  10d794:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  10d799:	8b 80 f8 00 00 00    	mov    0xf8(%eax),%eax                
  10d79f:	8b 80 c4 00 00 00    	mov    0xc4(%eax),%eax                
  10d7a5:	89 83 c4 00 00 00    	mov    %eax,0xc4(%ebx)                
  10d7ab:	eb 0a                	jmp    10d7b7 <_POSIX_Threads_Create_extension+0xea>
  } else {                                                            
    api->signals_blocked = 0xffffffff;                                
  10d7ad:	c7 83 c4 00 00 00 ff 	movl   $0xffffffff,0xc4(%ebx)         
  10d7b4:	ff ff ff                                                    
  }                                                                   
                                                                      
  _Thread_queue_Initialize(                                           
  10d7b7:	6a 00                	push   $0x0                           
  10d7b9:	68 00 10 00 00       	push   $0x1000                        
  10d7be:	6a 00                	push   $0x0                           
  10d7c0:	8d 43 3c             	lea    0x3c(%ebx),%eax                
  10d7c3:	50                   	push   %eax                           
  10d7c4:	e8 47 dd ff ff       	call   10b510 <_Thread_queue_Initialize>
    THREAD_QUEUE_DISCIPLINE_FIFO,                                     
    STATES_WAITING_FOR_JOIN_AT_EXIT,                                  
    0                                                                 
  );                                                                  
                                                                      
  _Watchdog_Initialize(                                               
  10d7c9:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10d7cc:	8b 42 08             	mov    0x8(%edx),%eax                 
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10d7cf:	c7 83 a4 00 00 00 00 	movl   $0x0,0xa4(%ebx)                
  10d7d6:	00 00 00                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  10d7d9:	c7 83 b8 00 00 00 3a 	movl   $0x10d83a,0xb8(%ebx)           
  10d7e0:	d8 10 00                                                    
 *  @param[in] starting_address is the starting address of the memory for
  10d7e3:	89 83 bc 00 00 00    	mov    %eax,0xbc(%ebx)                
 *         the heap                                                   
  10d7e9:	89 93 c0 00 00 00    	mov    %edx,0xc0(%ebx)                
  10d7ef:	b0 01                	mov    $0x1,%al                       
  10d7f1:	83 c4 10             	add    $0x10,%esp                     
    created->Object.id,                                               
    created                                                           
  );                                                                  
                                                                      
  return true;                                                        
}                                                                     
  10d7f4:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10d7f7:	5b                   	pop    %ebx                           
  10d7f8:	5e                   	pop    %esi                           
  10d7f9:	5f                   	pop    %edi                           
  10d7fa:	c9                   	leave                                 
  10d7fb:	c3                   	ret                                   
                                                                      

00109d4c <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) {
  109d4c:	55                   	push   %ebp                           
  109d4d:	89 e5                	mov    %esp,%ebp                      
  109d4f:	57                   	push   %edi                           
  109d50:	56                   	push   %esi                           
  109d51:	53                   	push   %ebx                           
  109d52:	83 ec 4c             	sub    $0x4c,%esp                     
  uint32_t                            maximum;                        
  posix_initialization_threads_table *user_threads;                   
  pthread_t                           thread_id;                      
  pthread_attr_t                      attr;                           
                                                                      
  user_threads = _POSIX_Threads_User_initialization_threads;          
  109d55:	8b 35 20 15 12 00    	mov    0x121520,%esi                  
  maximum      = _POSIX_Threads_Number_of_initialization_threads;     
  109d5b:	a1 d8 15 12 00       	mov    0x1215d8,%eax                  
  109d60:	89 45 b0             	mov    %eax,-0x50(%ebp)               
                                                                      
  if ( !user_threads || maximum == 0 )                                
  109d63:	85 f6                	test   %esi,%esi                      
  109d65:	74 51                	je     109db8 <_POSIX_Threads_Initialize_user_threads_body+0x6c><== NEVER TAKEN
  109d67:	85 c0                	test   %eax,%eax                      
  109d69:	74 4d                	je     109db8 <_POSIX_Threads_Initialize_user_threads_body+0x6c><== NEVER TAKEN
    return;                                                           
  109d6b:	31 db                	xor    %ebx,%ebx                      
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
    /*                                                                
     * There is no way for these calls to fail in this situation.     
     */                                                               
    (void) pthread_attr_init( &attr );                                
  109d6d:	8d 7d b8             	lea    -0x48(%ebp),%edi               
  109d70:	eb 41                	jmp    109db3 <_POSIX_Threads_Initialize_user_threads_body+0x67>
  109d72:	83 ec 0c             	sub    $0xc,%esp                      
  109d75:	57                   	push   %edi                           
  109d76:	e8 cd 54 00 00       	call   10f248 <pthread_attr_init>     
    (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
  109d7b:	58                   	pop    %eax                           
  109d7c:	5a                   	pop    %edx                           
  109d7d:	6a 02                	push   $0x2                           
  109d7f:	57                   	push   %edi                           
  109d80:	e8 eb 54 00 00       	call   10f270 <pthread_attr_setinheritsched>
    (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
  109d85:	59                   	pop    %ecx                           
  109d86:	58                   	pop    %eax                           
  109d87:	ff 74 de 04          	pushl  0x4(%esi,%ebx,8)               
  109d8b:	57                   	push   %edi                           
  109d8c:	e8 13 55 00 00       	call   10f2a4 <pthread_attr_setstacksize>
                                                                      
    status = pthread_create(                                          
  109d91:	6a 00                	push   $0x0                           
  109d93:	ff 34 de             	pushl  (%esi,%ebx,8)                  
  109d96:	57                   	push   %edi                           
  109d97:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  109d9a:	50                   	push   %eax                           
  109d9b:	e8 84 fc ff ff       	call   109a24 <pthread_create>        
      &thread_id,                                                     
      &attr,                                                          
      user_threads[ index ].thread_entry,                             
      NULL                                                            
    );                                                                
    if ( status )                                                     
  109da0:	83 c4 20             	add    $0x20,%esp                     
  109da3:	85 c0                	test   %eax,%eax                      
  109da5:	74 0b                	je     109db2 <_POSIX_Threads_Initialize_user_threads_body+0x66>
      _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status );
  109da7:	52                   	push   %edx                           
  109da8:	50                   	push   %eax                           
  109da9:	6a 01                	push   $0x1                           
  109dab:	6a 02                	push   $0x2                           
  109dad:	e8 36 1e 00 00       	call   10bbe8 <_Internal_error_Occurred>
   *                                                                  
   *  Setting the attributes explicitly is critical, since we don't want
   *  to inherit the idle tasks attributes.                           
   */                                                                 
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
  109db2:	43                   	inc    %ebx                           
  109db3:	3b 5d b0             	cmp    -0x50(%ebp),%ebx               
  109db6:	72 ba                	jb     109d72 <_POSIX_Threads_Initialize_user_threads_body+0x26>
      NULL                                                            
    );                                                                
    if ( status )                                                     
      _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status );
  }                                                                   
}                                                                     
  109db8:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109dbb:	5b                   	pop    %ebx                           
  109dbc:	5e                   	pop    %esi                           
  109dbd:	5f                   	pop    %edi                           
  109dbe:	c9                   	leave                                 
  109dbf:	c3                   	ret                                   
                                                                      

0010d83a <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) {
  10d83a:	55                   	push   %ebp                           
  10d83b:	89 e5                	mov    %esp,%ebp                      
  10d83d:	56                   	push   %esi                           
  10d83e:	53                   	push   %ebx                           
  10d83f:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  Thread_Control     *the_thread;                                     
  POSIX_API_Control  *api;                                            
                                                                      
  the_thread = argument;                                              
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  10d842:	8b b3 f8 00 00 00    	mov    0xf8(%ebx),%esi                
                                                                      
  ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget );   
  10d848:	83 ec 0c             	sub    $0xc,%esp                      
  10d84b:	8d 86 90 00 00 00    	lea    0x90(%esi),%eax                
  10d851:	50                   	push   %eax                           
  10d852:	e8 99 0c 00 00       	call   10e4f0 <_Timespec_To_ticks>    
                                                                      
  if ( !ticks )                                                       
  10d857:	83 c4 10             	add    $0x10,%esp                     
  10d85a:	85 c0                	test   %eax,%eax                      
  10d85c:	75 02                	jne    10d860 <_POSIX_Threads_Sporadic_budget_TSR+0x26><== ALWAYS TAKEN
  10d85e:	b0 01                	mov    $0x1,%al                       <== NOT EXECUTED
    ticks = 1;                                                        
                                                                      
  the_thread->cpu_time_budget = ticks;                                
  10d860:	89 43 78             	mov    %eax,0x78(%ebx)                
  10d863:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  10d868:	2b 86 98 00 00 00    	sub    0x98(%esi),%eax                
                                                                      
  new_priority = _POSIX_Priority_To_core( api->ss_high_priority );    
  the_thread->real_priority = new_priority;                           
  10d86e:	89 43 18             	mov    %eax,0x18(%ebx)                
                                                                      
  if ( the_thread->resource_count == 0 ||                             
  10d871:	83 7b 1c 00          	cmpl   $0x0,0x1c(%ebx)                
  10d875:	74 05                	je     10d87c <_POSIX_Threads_Sporadic_budget_TSR+0x42>
  10d877:	39 43 14             	cmp    %eax,0x14(%ebx)                
  10d87a:	76 0d                	jbe    10d889 <_POSIX_Threads_Sporadic_budget_TSR+0x4f><== NEVER TAKEN
       the_thread->current_priority > new_priority )                  
    _Thread_Change_priority( the_thread, new_priority, TRUE );        
  10d87c:	52                   	push   %edx                           
  10d87d:	6a 01                	push   $0x1                           
  10d87f:	50                   	push   %eax                           
  10d880:	53                   	push   %ebx                           
  10d881:	e8 66 d1 ff ff       	call   10a9ec <_Thread_Change_priority>
  10d886:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 
  10d889:	83 ec 0c             	sub    $0xc,%esp                      
  10d88c:	8d 86 88 00 00 00    	lea    0x88(%esi),%eax                
  10d892:	50                   	push   %eax                           
  10d893:	e8 58 0c 00 00       	call   10e4f0 <_Timespec_To_ticks>    
                                                                      
  if ( !ticks )                                                       
  10d898:	83 c4 10             	add    $0x10,%esp                     
  10d89b:	85 c0                	test   %eax,%eax                      
  10d89d:	75 02                	jne    10d8a1 <_POSIX_Threads_Sporadic_budget_TSR+0x67><== ALWAYS TAKEN
  10d89f:	b0 01                	mov    $0x1,%al                       <== NOT EXECUTED
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10d8a1:	89 86 a8 00 00 00    	mov    %eax,0xa8(%esi)                
  void                *starting_address,                              
  size_t              *size                                           
  10d8a7:	8d 86 9c 00 00 00    	lea    0x9c(%esi),%eax                
  10d8ad:	89 45 0c             	mov    %eax,0xc(%ebp)                 
  10d8b0:	c7 45 08 78 d8 11 00 	movl   $0x11d878,0x8(%ebp)            
    ticks = 1;                                                        
                                                                      
  _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );              
}                                                                     
  10d8b7:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10d8ba:	5b                   	pop    %ebx                           
  10d8bb:	5e                   	pop    %esi                           
  10d8bc:	c9                   	leave                                 
  10d8bd:	e9 66 e3 ff ff       	jmp    10bc28 <_Watchdog_Insert>      
                                                                      

0010d7fc <_POSIX_Threads_Sporadic_budget_callout>: */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) {
  10d7fc:	55                   	push   %ebp                           
  10d7fd:	89 e5                	mov    %esp,%ebp                      
  10d7ff:	83 ec 08             	sub    $0x8,%esp                      
  10d802:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  POSIX_API_Control *api;                                             
  uint32_t           new_priority;                                    
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  10d805:	8b 81 f8 00 00 00    	mov    0xf8(%ecx),%eax                
   *  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 */
  10d80b:	c7 41 78 ff ff ff ff 	movl   $0xffffffff,0x78(%ecx)         
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
  10d812:	ba ff 00 00 00       	mov    $0xff,%edx                     
  10d817:	2b 90 84 00 00 00    	sub    0x84(%eax),%edx                
                                                                      
  new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority );
  the_thread->real_priority = new_priority;                           
  10d81d:	89 51 18             	mov    %edx,0x18(%ecx)                
                                                                      
 if ( the_thread->resource_count == 0 ||                              
  10d820:	83 79 1c 00          	cmpl   $0x0,0x1c(%ecx)                
  10d824:	74 05                	je     10d82b <_POSIX_Threads_Sporadic_budget_callout+0x2f><== ALWAYS TAKEN
  10d826:	39 51 14             	cmp    %edx,0x14(%ecx)                <== NOT EXECUTED
  10d829:	76 0d                	jbe    10d838 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NOT EXECUTED
      the_thread->current_priority > new_priority )                   
    _Thread_Change_priority( the_thread, new_priority, TRUE );        
  10d82b:	50                   	push   %eax                           
  10d82c:	6a 01                	push   $0x1                           
  10d82e:	52                   	push   %edx                           
  10d82f:	51                   	push   %ecx                           
  10d830:	e8 b7 d1 ff ff       	call   10a9ec <_Thread_Change_priority>
  10d835:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  10d838:	c9                   	leave                                 
  10d839:	c3                   	ret                                   
                                                                      

0010e9dc <_POSIX_Threads_cancel_run>: #include <rtems/posix/threadsup.h> void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) {
  10e9dc:	55                   	push   %ebp                           
  10e9dd:	89 e5                	mov    %esp,%ebp                      
  10e9df:	57                   	push   %edi                           
  10e9e0:	56                   	push   %esi                           
  10e9e1:	53                   	push   %ebx                           
  10e9e2:	83 ec 0c             	sub    $0xc,%esp                      
  POSIX_Cancel_Handler_control      *handler;                         
  Chain_Control                     *handler_stack;                   
  POSIX_API_Control                 *thread_support;                  
  ISR_Level                          level;                           
                                                                      
  thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];    
  10e9e5:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10e9e8:	8b b0 f8 00 00 00    	mov    0xf8(%eax),%esi                
                                                                      
  handler_stack = &thread_support->Cancellation_Handlers;             
                                                                      
  thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;       
  10e9ee:	c7 86 cc 00 00 00 01 	movl   $0x1,0xcc(%esi)                
  10e9f5:	00 00 00                                                    
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  10e9f8:	8d be dc 00 00 00    	lea    0xdc(%esi),%edi                
  10e9fe:	eb 26                	jmp    10ea26 <_POSIX_Threads_cancel_run+0x4a>
                                                                      
  while ( !_Chain_Is_empty( handler_stack ) ) {                       
    _ISR_Disable( level );                                            
  10ea00:	9c                   	pushf                                 <== NOT EXECUTED
  10ea01:	fa                   	cli                                   <== NOT EXECUTED
  10ea02:	59                   	pop    %ecx                           <== NOT EXECUTED
      handler = (POSIX_Cancel_Handler_control *)                      
  10ea03:	8b 5f 04             	mov    0x4(%edi),%ebx                 <== NOT EXECUTED
  10ea06:	8b 13                	mov    (%ebx),%edx                    <== NOT EXECUTED
  10ea08:	8b 43 04             	mov    0x4(%ebx),%eax                 <== NOT EXECUTED
  10ea0b:	89 42 04             	mov    %eax,0x4(%edx)                 <== NOT EXECUTED
  10ea0e:	89 10                	mov    %edx,(%eax)                    <== NOT EXECUTED
           _Chain_Tail( handler_stack )->previous;                    
      _Chain_Extract_unprotected( &handler->Node );                   
    _ISR_Enable( level );                                             
  10ea10:	51                   	push   %ecx                           <== NOT EXECUTED
  10ea11:	9d                   	popf                                  <== NOT EXECUTED
                                                                      
    (*handler->routine)( handler->arg );                              
  10ea12:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10ea15:	ff 73 0c             	pushl  0xc(%ebx)                      <== NOT EXECUTED
  10ea18:	ff 53 08             	call   *0x8(%ebx)                     <== NOT EXECUTED
                                                                      
    _Workspace_Free( handler );                                       
  10ea1b:	89 1c 24             	mov    %ebx,(%esp)                    <== NOT EXECUTED
  10ea1e:	e8 f1 d3 ff ff       	call   10be14 <_Workspace_Free>       <== NOT EXECUTED
  10ea23:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
  handler_stack = &thread_support->Cancellation_Handlers;             
                                                                      
  thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;       
                                                                      
  while ( !_Chain_Is_empty( handler_stack ) ) {                       
  10ea26:	39 be d8 00 00 00    	cmp    %edi,0xd8(%esi)                
  10ea2c:	75 d2                	jne    10ea00 <_POSIX_Threads_cancel_run+0x24><== NEVER TAKEN
                                                                      
    (*handler->routine)( handler->arg );                              
                                                                      
    _Workspace_Free( handler );                                       
  }                                                                   
}                                                                     
  10ea2e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ea31:	5b                   	pop    %ebx                           
  10ea32:	5e                   	pop    %esi                           
  10ea33:	5f                   	pop    %edi                           
  10ea34:	c9                   	leave                                 
  10ea35:	c3                   	ret                                   
                                                                      

0010f508 <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) {
  10f508:	55                   	push   %ebp                           
  10f509:	89 e5                	mov    %esp,%ebp                      
  10f50b:	56                   	push   %esi                           
  10f50c:	53                   	push   %ebx                           
  10f50d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  ISR_Level            level;                                         
                                                                      
  (void) _Watchdog_Remove( timer );                                   
  10f510:	83 ec 0c             	sub    $0xc,%esp                      
  10f513:	53                   	push   %ebx                           
  10f514:	e8 4b e2 ff ff       	call   10d764 <_Watchdog_Remove>      
  _ISR_Disable( level );                                              
  10f519:	9c                   	pushf                                 
  10f51a:	fa                   	cli                                   
  10f51b:	5e                   	pop    %esi                           
                                                                      
    /*                                                                
     *  Check to see if the watchdog has just been inserted by a      
     *  higher priority interrupt.  If so, abandon this insert.       
     */                                                               
    if ( timer->state != WATCHDOG_INACTIVE ) {                        
  10f51c:	83 c4 10             	add    $0x10,%esp                     
  10f51f:	83 7b 08 00          	cmpl   $0x0,0x8(%ebx)                 
  10f523:	74 06                	je     10f52b <_POSIX_Timer_Insert_helper+0x23><== ALWAYS TAKEN
      _ISR_Enable( level );                                           
  10f525:	56                   	push   %esi                           <== NOT EXECUTED
  10f526:	9d                   	popf                                  <== NOT EXECUTED
  10f527:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  10f529:	eb 33                	jmp    10f55e <_POSIX_Timer_Insert_helper+0x56><== NOT EXECUTED
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10f52b:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)                 
 *  @param[in] the_heap is the heap to operate upon                   
  10f532:	8b 45 14             	mov    0x14(%ebp),%eax                
  10f535:	89 43 1c             	mov    %eax,0x1c(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  10f538:	8b 45 10             	mov    0x10(%ebp),%eax                
  10f53b:	89 43 20             	mov    %eax,0x20(%ebx)                
 *         the heap                                                   
  10f53e:	8b 45 18             	mov    0x18(%ebp),%eax                
  10f541:	89 43 24             	mov    %eax,0x24(%ebx)                
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10f544:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10f547:	89 43 0c             	mov    %eax,0xc(%ebx)                 
  void                *starting_address,                              
  size_t              *size                                           
  10f54a:	50                   	push   %eax                           
  10f54b:	50                   	push   %eax                           
  10f54c:	53                   	push   %ebx                           
  10f54d:	68 30 1b 12 00       	push   $0x121b30                      
  10f552:	e8 f5 e0 ff ff       	call   10d64c <_Watchdog_Insert>      
     *  OK.  Now we now the timer was not rescheduled by an interrupt 
     *  so we can atomically initialize it as in use.                 
     */                                                               
    _Watchdog_Initialize( timer, TSR, id, arg );                      
    _Watchdog_Insert_ticks( timer, ticks );                           
  _ISR_Enable( level );                                               
  10f557:	56                   	push   %esi                           
  10f558:	9d                   	popf                                  
  10f559:	b0 01                	mov    $0x1,%al                       
  10f55b:	83 c4 10             	add    $0x10,%esp                     
  return true;                                                        
}                                                                     
  10f55e:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10f561:	5b                   	pop    %ebx                           
  10f562:	5e                   	pop    %esi                           
  10f563:	c9                   	leave                                 
  10f564:	c3                   	ret                                   
                                                                      

0010a310 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR(Objects_Id timer, void *data) {
  10a310:	55                   	push   %ebp                           
  10a311:	89 e5                	mov    %esp,%ebp                      
  10a313:	53                   	push   %ebx                           
  10a314:	83 ec 04             	sub    $0x4,%esp                      
  10a317:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  bool                 activated;                                     
                                                                      
  ptimer = (POSIX_Timer_Control *)data;                               
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
  10a31a:	ff 43 68             	incl   0x68(%ebx)                     
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
  10a31d:	83 7b 54 00          	cmpl   $0x0,0x54(%ebx)                
  10a321:	75 06                	jne    10a329 <_POSIX_Timer_TSR+0x19> <== ALWAYS TAKEN
  10a323:	83 7b 58 00          	cmpl   $0x0,0x58(%ebx)                <== NOT EXECUTED
  10a327:	74 34                	je     10a35d <_POSIX_Timer_TSR+0x4d> <== NOT EXECUTED
       ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {            
    activated = _POSIX_Timer_Insert_helper(                           
  10a329:	83 ec 0c             	sub    $0xc,%esp                      
  10a32c:	53                   	push   %ebx                           
  10a32d:	68 10 a3 10 00       	push   $0x10a310                      
  10a332:	ff 73 08             	pushl  0x8(%ebx)                      
  10a335:	ff 73 64             	pushl  0x64(%ebx)                     
  10a338:	8d 43 10             	lea    0x10(%ebx),%eax                
  10a33b:	50                   	push   %eax                           
  10a33c:	e8 c7 51 00 00       	call   10f508 <_POSIX_Timer_Insert_helper>
      ptimer->ticks,                                                  
      ptimer->Object.id,                                              
      _POSIX_Timer_TSR,                                               
      ptimer                                                          
    );                                                                
    if ( !activated )                                                 
  10a341:	83 c4 20             	add    $0x20,%esp                     
  10a344:	84 c0                	test   %al,%al                        
  10a346:	74 30                	je     10a378 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
      return;                                                         
                                                                      
    /* Store the time when the timer was started again */             
    _TOD_Get( &ptimer->time );                                        
  10a348:	83 ec 0c             	sub    $0xc,%esp                      
  10a34b:	8d 43 6c             	lea    0x6c(%ebx),%eax                
  10a34e:	50                   	push   %eax                           
  10a34f:	e8 28 15 00 00       	call   10b87c <_TOD_Get>              
                                                                      
    /* The state really did not change but just to be safe */         
    ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                     
  10a354:	c6 43 3c 03          	movb   $0x3,0x3c(%ebx)                
  10a358:	83 c4 10             	add    $0x10,%esp                     
  10a35b:	eb 04                	jmp    10a361 <_POSIX_Timer_TSR+0x51> 
  } else {                                                            
   /* Indicates that the timer is stopped */                          
   ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;                     
  10a35d:	c6 43 3c 04          	movb   $0x4,0x3c(%ebx)                <== NOT EXECUTED
  /*                                                                  
   * The sending of the signal to the process running the handling function
   * specified for that signal is simulated                           
   */                                                                 
                                                                      
  if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
  10a361:	50                   	push   %eax                           
  10a362:	50                   	push   %eax                           
  10a363:	ff 73 44             	pushl  0x44(%ebx)                     
  10a366:	ff 73 38             	pushl  0x38(%ebx)                     
  10a369:	e8 0a 4f 00 00       	call   10f278 <pthread_kill>          
  }                                                                   
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
  10a36e:	c7 43 68 00 00 00 00 	movl   $0x0,0x68(%ebx)                
  10a375:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  10a378:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10a37b:	c9                   	leave                                 
  10a37c:	c3                   	ret                                   
                                                                      

0010eae0 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) {
  10eae0:	55                   	push   %ebp                           
  10eae1:	89 e5                	mov    %esp,%ebp                      
  10eae3:	57                   	push   %edi                           
  10eae4:	56                   	push   %esi                           
  10eae5:	53                   	push   %ebx                           
  10eae6:	83 ec 28             	sub    $0x28,%esp                     
  10eae9:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10eaec:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  siginfo_t                   siginfo_struct;                         
  sigset_t                    saved_signals_blocked;                  
                                                                      
  if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,   
  10eaef:	6a 01                	push   $0x1                           
  10eaf1:	0f b6 45 10          	movzbl 0x10(%ebp),%eax                
  10eaf5:	50                   	push   %eax                           
  10eaf6:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  10eaf9:	50                   	push   %eax                           
  10eafa:	56                   	push   %esi                           
  10eafb:	57                   	push   %edi                           
  10eafc:	e8 5f 00 00 00       	call   10eb60 <_POSIX_signals_Clear_signals>
  10eb01:	83 c4 20             	add    $0x20,%esp                     
  10eb04:	84 c0                	test   %al,%al                        
  10eb06:	74 4e                	je     10eb56 <_POSIX_signals_Check_signal+0x76>
  #endif                                                              
                                                                      
  /*                                                                  
   *  Just to prevent sending a signal which is currently being ignored.
   */                                                                 
  if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )        
  10eb08:	6b d6 0c             	imul   $0xc,%esi,%edx                 
  10eb0b:	8b 8a 44 dd 11 00    	mov    0x11dd44(%edx),%ecx            
  10eb11:	83 f9 01             	cmp    $0x1,%ecx                      
  10eb14:	74 40                	je     10eb56 <_POSIX_signals_Check_signal+0x76><== NEVER TAKEN
    return false;                                                     
                                                                      
  /*                                                                  
   *  Block the signals requested in sa_mask                          
   */                                                                 
  saved_signals_blocked = api->signals_blocked;                       
  10eb16:	8b 9f c4 00 00 00    	mov    0xc4(%edi),%ebx                
  api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;    
  10eb1c:	89 d8                	mov    %ebx,%eax                      
  10eb1e:	0b 82 40 dd 11 00    	or     0x11dd40(%edx),%eax            
  10eb24:	89 87 c4 00 00 00    	mov    %eax,0xc4(%edi)                
                                                                      
  /*                                                                  
   *  Here, the signal handler function executes                      
   */                                                                 
  switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {               
  10eb2a:	83 ba 3c dd 11 00 02 	cmpl   $0x2,0x11dd3c(%edx)            
  10eb31:	75 10                	jne    10eb43 <_POSIX_signals_Check_signal+0x63>
    case SA_SIGINFO:                                                  
      (*_POSIX_signals_Vectors[ signo ].sa_sigaction)(                
  10eb33:	50                   	push   %eax                           
  10eb34:	6a 00                	push   $0x0                           
  10eb36:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  10eb39:	50                   	push   %eax                           
  10eb3a:	56                   	push   %esi                           
  10eb3b:	ff 92 44 dd 11 00    	call   *0x11dd44(%edx)                
  10eb41:	eb 06                	jmp    10eb49 <_POSIX_signals_Check_signal+0x69>
        &siginfo_struct,                                              
        NULL        /* context is undefined per 1003.1b-1993, p. 66 */
      );                                                              
      break;                                                          
    default:                                                          
      (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );         
  10eb43:	83 ec 0c             	sub    $0xc,%esp                      
  10eb46:	56                   	push   %esi                           
  10eb47:	ff d1                	call   *%ecx                          
  10eb49:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
  10eb4c:	89 9f c4 00 00 00    	mov    %ebx,0xc4(%edi)                
  10eb52:	b0 01                	mov    $0x1,%al                       
  10eb54:	eb 02                	jmp    10eb58 <_POSIX_signals_Check_signal+0x78>
                                                                      
  return true;                                                        
  10eb56:	31 c0                	xor    %eax,%eax                      
}                                                                     
  10eb58:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10eb5b:	5b                   	pop    %ebx                           
  10eb5c:	5e                   	pop    %esi                           
  10eb5d:	5f                   	pop    %edi                           
  10eb5e:	c9                   	leave                                 
  10eb5f:	c3                   	ret                                   
                                                                      

0010f0ec <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( sigset_t mask ) {
  10f0ec:	55                   	push   %ebp                           
  10f0ed:	89 e5                	mov    %esp,%ebp                      
  10f0ef:	8b 45 08             	mov    0x8(%ebp),%eax                 
  ISR_Level  level;                                                   
                                                                      
  _ISR_Disable( level );                                              
  10f0f2:	9c                   	pushf                                 
  10f0f3:	fa                   	cli                                   
  10f0f4:	5a                   	pop    %edx                           
    _POSIX_signals_Pending &= ~mask;                                  
  10f0f5:	f7 d0                	not    %eax                           
  10f0f7:	23 05 08 df 11 00    	and    0x11df08,%eax                  
  10f0fd:	a3 08 df 11 00       	mov    %eax,0x11df08                  
    if ( !_POSIX_signals_Pending )                                    
  10f102:	85 c0                	test   %eax,%eax                      
  10f104:	75 06                	jne    10f10c <_POSIX_signals_Clear_process_signals+0x20><== NEVER TAKEN
      _Thread_Do_post_task_switch_extension--;                        
  10f106:	ff 0d 3c d8 11 00    	decl   0x11d83c                       
  _ISR_Enable( level );                                               
  10f10c:	52                   	push   %edx                           
  10f10d:	9d                   	popf                                  
}                                                                     
  10f10e:	c9                   	leave                                 
  10f10f:	c3                   	ret                                   
                                                                      

0010eb60 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) {
  10eb60:	55                   	push   %ebp                           
  10eb61:	89 e5                	mov    %esp,%ebp                      
  10eb63:	57                   	push   %edi                           
  10eb64:	56                   	push   %esi                           
  10eb65:	53                   	push   %ebx                           
  10eb66:	83 ec 0c             	sub    $0xc,%esp                      
  10eb69:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10eb6c:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  10eb6f:	8a 45 14             	mov    0x14(%ebp),%al                 
  sigset_t                    signals_blocked;                        
  ISR_Level                   level;                                  
  bool                        do_callout;                             
  POSIX_signals_Siginfo_node *psiginfo;                               
                                                                      
  mask = signo_to_mask( signo );                                      
  10eb72:	8d 4f ff             	lea    -0x1(%edi),%ecx                
  10eb75:	be 01 00 00 00       	mov    $0x1,%esi                      
  10eb7a:	d3 e6                	shl    %cl,%esi                       
                                                                      
  /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
   * insures that no signals are blocked and all are checked.         
   */                                                                 
                                                                      
  if ( check_blocked )                                                
  10eb7c:	83 ca ff             	or     $0xffffffff,%edx               
  10eb7f:	80 7d 18 00          	cmpb   $0x0,0x18(%ebp)                
  10eb83:	74 08                	je     10eb8d <_POSIX_signals_Clear_signals+0x2d>
    signals_blocked = ~api->signals_blocked;                          
  10eb85:	8b 93 c4 00 00 00    	mov    0xc4(%ebx),%edx                
  10eb8b:	f7 d2                	not    %edx                           
    signals_blocked = SIGNAL_ALL_MASK;                                
                                                                      
  /* XXX this is not right for siginfo type signals yet */            
  /* XXX since they can't be cleared the same way */                  
                                                                      
  _ISR_Disable( level );                                              
  10eb8d:	9c                   	pushf                                 
  10eb8e:	fa                   	cli                                   
  10eb8f:	8f 45 f0             	popl   -0x10(%ebp)                    
    if ( is_global ) {                                                
  10eb92:	84 c0                	test   %al,%al                        
  10eb94:	0f 84 8d 00 00 00    	je     10ec27 <_POSIX_signals_Clear_signals+0xc7>
       if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {     
  10eb9a:	89 f0                	mov    %esi,%eax                      
  10eb9c:	23 05 08 df 11 00    	and    0x11df08,%eax                  
  10eba2:	85 d0                	test   %edx,%eax                      
  10eba4:	0f 84 9b 00 00 00    	je     10ec45 <_POSIX_signals_Clear_signals+0xe5>
         if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
  10ebaa:	6b d7 0c             	imul   $0xc,%edi,%edx                 
  10ebad:	83 ba 3c dd 11 00 02 	cmpl   $0x2,0x11dd3c(%edx)            
  10ebb4:	75 61                	jne    10ec17 <_POSIX_signals_Clear_signals+0xb7>
           psiginfo = (POSIX_signals_Siginfo_node *)                  
  10ebb6:	8d 8a 0c df 11 00    	lea    0x11df0c(%edx),%ecx            
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  10ebbc:	8b 9a 0c df 11 00    	mov    0x11df0c(%edx),%ebx            
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  10ebc2:	8d 79 04             	lea    0x4(%ecx),%edi                 
  10ebc5:	39 fb                	cmp    %edi,%ebx                      
  10ebc7:	75 04                	jne    10ebcd <_POSIX_signals_Clear_signals+0x6d><== ALWAYS TAKEN
  10ebc9:	31 db                	xor    %ebx,%ebx                      
  10ebcb:	eb 0b                	jmp    10ebd8 <_POSIX_signals_Clear_signals+0x78><== NOT EXECUTED
  10ebcd:	8b 03                	mov    (%ebx),%eax                    
  10ebcf:	89 82 0c df 11 00    	mov    %eax,0x11df0c(%edx)            
  10ebd5:	89 48 04             	mov    %ecx,0x4(%eax)                 
             _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
           if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 
  10ebd8:	39 ba 0c df 11 00    	cmp    %edi,0x11df0c(%edx)            
  10ebde:	75 0c                	jne    10ebec <_POSIX_signals_Clear_signals+0x8c><== NEVER TAKEN
             _POSIX_signals_Clear_process_signals( mask );            
  10ebe0:	83 ec 0c             	sub    $0xc,%esp                      
  10ebe3:	56                   	push   %esi                           
  10ebe4:	e8 03 05 00 00       	call   10f0ec <_POSIX_signals_Clear_process_signals>
  10ebe9:	83 c4 10             	add    $0x10,%esp                     
           if ( psiginfo ) {                                          
  10ebec:	b0 01                	mov    $0x1,%al                       
  10ebee:	85 db                	test   %ebx,%ebx                      
  10ebf0:	74 55                	je     10ec47 <_POSIX_signals_Clear_signals+0xe7><== NEVER TAKEN
             *info = psiginfo->Info;                                  
  10ebf2:	8d 73 08             	lea    0x8(%ebx),%esi                 
  10ebf5:	b9 03 00 00 00       	mov    $0x3,%ecx                      
  10ebfa:	8b 7d 10             	mov    0x10(%ebp),%edi                
  10ebfd:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  10ebff:	c7 03 c0 de 11 00    	movl   $0x11dec0,(%ebx)               
  10ec05:	a1 c4 de 11 00       	mov    0x11dec4,%eax                  
  10ec0a:	89 1d c4 de 11 00    	mov    %ebx,0x11dec4                  
  10ec10:	89 18                	mov    %ebx,(%eax)                    
  10ec12:	89 43 04             	mov    %eax,0x4(%ebx)                 
  10ec15:	eb 2a                	jmp    10ec41 <_POSIX_signals_Clear_signals+0xe1>
               &psiginfo->Node                                        
             );                                                       
           } else                                                     
             do_callout = false;                                      
         } else                                                       
           _POSIX_signals_Clear_process_signals( mask );              
  10ec17:	83 ec 0c             	sub    $0xc,%esp                      
  10ec1a:	56                   	push   %esi                           
  10ec1b:	e8 cc 04 00 00       	call   10f0ec <_POSIX_signals_Clear_process_signals>
  10ec20:	b0 01                	mov    $0x1,%al                       
  10ec22:	83 c4 10             	add    $0x10,%esp                     
  10ec25:	eb 20                	jmp    10ec47 <_POSIX_signals_Clear_signals+0xe7>
         do_callout = true;                                           
       }                                                              
    } else {                                                          
      if ( mask & (api->signals_pending & signals_blocked) ) {        
  10ec27:	8b 8b c8 00 00 00    	mov    0xc8(%ebx),%ecx                
  10ec2d:	89 f0                	mov    %esi,%eax                      
  10ec2f:	21 c8                	and    %ecx,%eax                      
  10ec31:	85 d0                	test   %edx,%eax                      
  10ec33:	74 10                	je     10ec45 <_POSIX_signals_Clear_signals+0xe5>
        api->signals_pending &= ~mask;                                
  10ec35:	89 f0                	mov    %esi,%eax                      
  10ec37:	f7 d0                	not    %eax                           
  10ec39:	21 c8                	and    %ecx,%eax                      
  10ec3b:	89 83 c8 00 00 00    	mov    %eax,0xc8(%ebx)                
  10ec41:	b0 01                	mov    $0x1,%al                       
  10ec43:	eb 02                	jmp    10ec47 <_POSIX_signals_Clear_signals+0xe7>
  10ec45:	31 c0                	xor    %eax,%eax                      
        do_callout = true;                                            
      }                                                               
    }                                                                 
  _ISR_Enable( level );                                               
  10ec47:	ff 75 f0             	pushl  -0x10(%ebp)                    
  10ec4a:	9d                   	popf                                  
  return do_callout;                                                  
}                                                                     
  10ec4b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ec4e:	5b                   	pop    %ebx                           
  10ec4f:	5e                   	pop    %esi                           
  10ec50:	5f                   	pop    %edi                           
  10ec51:	c9                   	leave                                 
  10ec52:	c3                   	ret                                   
                                                                      

001099f8 <_POSIX_signals_Get_highest>: #include <rtems/score/isr.h> int _POSIX_signals_Get_highest( sigset_t set ) {
  1099f8:	55                   	push   %ebp                           
  1099f9:	89 e5                	mov    %esp,%ebp                      
  1099fb:	56                   	push   %esi                           
  1099fc:	53                   	push   %ebx                           
  1099fd:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  109a00:	b8 1b 00 00 00       	mov    $0x1b,%eax                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
    if ( set & signo_to_mask( signo ) )                               
  109a05:	ba 01 00 00 00       	mov    $0x1,%edx                      
  109a0a:	8d 48 ff             	lea    -0x1(%eax),%ecx                
  109a0d:	89 d6                	mov    %edx,%esi                      
  109a0f:	d3 e6                	shl    %cl,%esi                       
  109a11:	85 de                	test   %ebx,%esi                      
  109a13:	75 20                	jne    109a35 <_POSIX_signals_Get_highest+0x3d><== NEVER TAKEN
  sigset_t   set                                                      
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
  109a15:	40                   	inc    %eax                           
  109a16:	83 f8 20             	cmp    $0x20,%eax                     
  109a19:	75 ef                	jne    109a0a <_POSIX_signals_Get_highest+0x12>
  109a1b:	b0 01                	mov    $0x1,%al                       
  }                                                                   
                                                                      
/* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
                                                                      
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
    if ( set & signo_to_mask( signo ) )                               
  109a1d:	ba 01 00 00 00       	mov    $0x1,%edx                      
  109a22:	8d 48 ff             	lea    -0x1(%eax),%ecx                
  109a25:	89 d6                	mov    %edx,%esi                      
  109a27:	d3 e6                	shl    %cl,%esi                       
  109a29:	85 de                	test   %ebx,%esi                      
  109a2b:	75 08                	jne    109a35 <_POSIX_signals_Get_highest+0x3d>
      return signo;                                                   
  }                                                                   
                                                                      
/* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
                                                                      
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
  109a2d:	40                   	inc    %eax                           
  109a2e:	83 f8 1b             	cmp    $0x1b,%eax                     
  109a31:	75 ef                	jne    109a22 <_POSIX_signals_Get_highest+0x2a><== ALWAYS TAKEN
  109a33:	30 c0                	xor    %al,%al                        <== NOT EXECUTED
    if ( set & signo_to_mask( signo ) )                               
      return signo;                                                   
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  109a35:	5b                   	pop    %ebx                           
  109a36:	5e                   	pop    %esi                           
  109a37:	c9                   	leave                                 
  109a38:	c3                   	ret                                   
                                                                      

0010d509 <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) {
  10d509:	55                   	push   %ebp                           
  10d50a:	89 e5                	mov    %esp,%ebp                      
  10d50c:	56                   	push   %esi                           
  10d50d:	53                   	push   %ebx                           
  POSIX_API_Control  *api;                                            
  int                 signo;                                          
  ISR_Level           level;                                          
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  10d50e:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10d511:	8b b0 f8 00 00 00    	mov    0xf8(%eax),%esi                
  if ( !api )                                                         
  10d517:	85 f6                	test   %esi,%esi                      
  10d519:	74 7a                	je     10d595 <_POSIX_signals_Post_switch_extension+0x8c><== NEVER TAKEN
   *  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) {                                                         
  restart:                                                            
    _ISR_Disable( level );                                            
  10d51b:	9c                   	pushf                                 
  10d51c:	fa                   	cli                                   
  10d51d:	59                   	pop    %ecx                           
      if ( !(~api->signals_blocked &                                  
  10d51e:	8b 15 08 df 11 00    	mov    0x11df08,%edx                  
  10d524:	0b 96 c8 00 00 00    	or     0xc8(%esi),%edx                
  10d52a:	8b 86 c4 00 00 00    	mov    0xc4(%esi),%eax                
  10d530:	f7 d0                	not    %eax                           
  10d532:	85 c2                	test   %eax,%edx                      
  10d534:	75 04                	jne    10d53a <_POSIX_signals_Post_switch_extension+0x31>
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
  10d536:	51                   	push   %ecx                           
  10d537:	9d                   	popf                                  
  10d538:	eb 5b                	jmp    10d595 <_POSIX_signals_Post_switch_extension+0x8c>
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
  10d53a:	51                   	push   %ecx                           
  10d53b:	9d                   	popf                                  
  10d53c:	bb 1b 00 00 00       	mov    $0x1b,%ebx                     
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
                                                                      
      if ( _POSIX_signals_Check_signal( api, signo, false ) )         
  10d541:	50                   	push   %eax                           
  10d542:	6a 00                	push   $0x0                           
  10d544:	53                   	push   %ebx                           
  10d545:	56                   	push   %esi                           
  10d546:	e8 95 15 00 00       	call   10eae0 <_POSIX_signals_Check_signal>
  10d54b:	83 c4 10             	add    $0x10,%esp                     
  10d54e:	84 c0                	test   %al,%al                        
  10d550:	75 c9                	jne    10d51b <_POSIX_signals_Post_switch_extension+0x12><== NEVER TAKEN
        goto restart;                                                 
                                                                      
      if ( _POSIX_signals_Check_signal( api, signo, true ) )          
  10d552:	51                   	push   %ecx                           
  10d553:	6a 01                	push   $0x1                           
  10d555:	53                   	push   %ebx                           
  10d556:	56                   	push   %esi                           
  10d557:	e8 84 15 00 00       	call   10eae0 <_POSIX_signals_Check_signal>
  10d55c:	83 c4 10             	add    $0x10,%esp                     
  10d55f:	84 c0                	test   %al,%al                        
  10d561:	75 b8                	jne    10d51b <_POSIX_signals_Post_switch_extension+0x12><== NEVER TAKEN
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
  10d563:	43                   	inc    %ebx                           
  10d564:	83 fb 20             	cmp    $0x20,%ebx                     
  10d567:	75 d8                	jne    10d541 <_POSIX_signals_Post_switch_extension+0x38>
  10d569:	b3 01                	mov    $0x1,%bl                       
                                                                      
    /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
                                                                      
    for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {      
                                                                      
      if ( _POSIX_signals_Check_signal( api, signo, false ) )         
  10d56b:	52                   	push   %edx                           
  10d56c:	6a 00                	push   $0x0                           
  10d56e:	53                   	push   %ebx                           
  10d56f:	56                   	push   %esi                           
  10d570:	e8 6b 15 00 00       	call   10eae0 <_POSIX_signals_Check_signal>
  10d575:	83 c4 10             	add    $0x10,%esp                     
  10d578:	84 c0                	test   %al,%al                        
  10d57a:	75 9f                	jne    10d51b <_POSIX_signals_Post_switch_extension+0x12>
        goto restart;                                                 
                                                                      
      if ( _POSIX_signals_Check_signal( api, signo, true ) )          
  10d57c:	50                   	push   %eax                           
  10d57d:	6a 01                	push   $0x1                           
  10d57f:	53                   	push   %ebx                           
  10d580:	56                   	push   %esi                           
  10d581:	e8 5a 15 00 00       	call   10eae0 <_POSIX_signals_Check_signal>
  10d586:	83 c4 10             	add    $0x10,%esp                     
  10d589:	84 c0                	test   %al,%al                        
  10d58b:	75 8e                	jne    10d51b <_POSIX_signals_Post_switch_extension+0x12>
                                                                      
    }                                                                 
                                                                      
    /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
                                                                      
    for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {      
  10d58d:	43                   	inc    %ebx                           
  10d58e:	83 fb 1b             	cmp    $0x1b,%ebx                     
  10d591:	75 d8                	jne    10d56b <_POSIX_signals_Post_switch_extension+0x62><== ALWAYS TAKEN
  10d593:	eb 86                	jmp    10d51b <_POSIX_signals_Post_switch_extension+0x12><== NOT EXECUTED
        goto restart;                                                 
                                                                      
    }                                                                 
  }                                                                   
  return;                                                             
}                                                                     
  10d595:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10d598:	5b                   	pop    %ebx                           
  10d599:	5e                   	pop    %esi                           
  10d59a:	c9                   	leave                                 
  10d59b:	c3                   	ret                                   
                                                                      

0011868c <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) {
  11868c:	55                   	push   %ebp                           
  11868d:	89 e5                	mov    %esp,%ebp                      
  11868f:	57                   	push   %edi                           
  118690:	56                   	push   %esi                           
  118691:	53                   	push   %ebx                           
  118692:	83 ec 0c             	sub    $0xc,%esp                      
  118695:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  118698:	8b 75 10             	mov    0x10(%ebp),%esi                
  POSIX_API_Control  *api;                                            
  sigset_t            mask;                                           
  siginfo_t          *the_info = NULL;                                
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  11869b:	8b bb f8 00 00 00    	mov    0xf8(%ebx),%edi                
                                                                      
  mask = signo_to_mask( signo );                                      
  1186a1:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  1186a4:	49                   	dec    %ecx                           
  1186a5:	ba 01 00 00 00       	mov    $0x1,%edx                      
  1186aa:	d3 e2                	shl    %cl,%edx                       
                                                                      
  /*                                                                  
   *  Is the thread is specifically waiting for a signal?             
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
  1186ac:	8b 4b 10             	mov    0x10(%ebx),%ecx                
  1186af:	89 c8                	mov    %ecx,%eax                      
  1186b1:	25 00 80 00 10       	and    $0x10008000,%eax               
  1186b6:	3d 00 80 00 10       	cmp    $0x10008000,%eax               
  1186bb:	75 4c                	jne    118709 <_POSIX_signals_Unblock_thread+0x7d>
                                                                      
    if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
  1186bd:	85 53 30             	test   %edx,0x30(%ebx)                
  1186c0:	75 10                	jne    1186d2 <_POSIX_signals_Unblock_thread+0x46>
  1186c2:	8b 87 c4 00 00 00    	mov    0xc4(%edi),%eax                
  1186c8:	f7 d0                	not    %eax                           
  1186ca:	85 c2                	test   %eax,%edx                      
  1186cc:	0f 84 a0 00 00 00    	je     118772 <_POSIX_signals_Unblock_thread+0xe6><== ALWAYS TAKEN
      the_thread->Wait.return_code = EINTR;                           
  1186d2:	c7 43 34 04 00 00 00 	movl   $0x4,0x34(%ebx)                
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
  1186d9:	8b 7b 28             	mov    0x28(%ebx),%edi                
                                                                      
      if ( !info ) {                                                  
  1186dc:	85 f6                	test   %esi,%esi                      
  1186de:	75 15                	jne    1186f5 <_POSIX_signals_Unblock_thread+0x69>
        the_info->si_signo = signo;                                   
  1186e0:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1186e3:	89 07                	mov    %eax,(%edi)                    
        the_info->si_code = SI_USER;                                  
  1186e5:	c7 47 04 01 00 00 00 	movl   $0x1,0x4(%edi)                 
        the_info->si_value.sival_int = 0;                             
  1186ec:	c7 47 08 00 00 00 00 	movl   $0x0,0x8(%edi)                 
  1186f3:	eb 07                	jmp    1186fc <_POSIX_signals_Unblock_thread+0x70>
      } else {                                                        
        *the_info = *info;                                            
  1186f5:	b9 03 00 00 00       	mov    $0x3,%ecx                      
  1186fa:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
      }                                                               
                                                                      
      _Thread_queue_Extract_with_proxy( the_thread );                 
  1186fc:	83 ec 0c             	sub    $0xc,%esp                      
  1186ff:	53                   	push   %ebx                           
  118700:	e8 67 41 ff ff       	call   10c86c <_Thread_queue_Extract_with_proxy>
  118705:	b0 01                	mov    $0x1,%al                       
  118707:	eb 48                	jmp    118751 <_POSIX_signals_Unblock_thread+0xc5>
  }                                                                   
                                                                      
  /*                                                                  
   *  Thread is not waiting due to a sigwait.                         
   */                                                                 
  if ( ~api->signals_blocked & mask ) {                               
  118709:	8b 87 c4 00 00 00    	mov    0xc4(%edi),%eax                
  11870f:	f7 d0                	not    %eax                           
  118711:	85 c2                	test   %eax,%edx                      
  118713:	74 5d                	je     118772 <_POSIX_signals_Unblock_thread+0xe6>
     *      it is not blocked, THEN                                   
     *        we need to dispatch at the end of this ISR.             
     *    + Any other combination, do nothing.                        
     */                                                               
                                                                      
    the_thread->do_post_task_switch_extension = true;                 
  118715:	c6 43 75 01          	movb   $0x1,0x75(%ebx)                
                                                                      
    if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) {
  118719:	f7 c1 00 00 00 10    	test   $0x10000000,%ecx               
  11871f:	74 35                	je     118756 <_POSIX_signals_Unblock_thread+0xca>
      the_thread->Wait.return_code = EINTR;                           
  118721:	c7 43 34 04 00 00 00 	movl   $0x4,0x34(%ebx)                
      #if 0                                                           
	if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 
	  _Thread_queue_Extract_with_proxy( the_thread );                    
	else                                                                 
      #endif                                                          
	  if ( _States_Is_delaying(the_thread->current_state) ){             
  118728:	80 e1 08             	and    $0x8,%cl                       
  11872b:	74 45                	je     118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN
	    if ( _Watchdog_Is_active( &the_thread->Timer ) )                 
  11872d:	83 7b 50 02          	cmpl   $0x2,0x50(%ebx)                
  118731:	75 0f                	jne    118742 <_POSIX_signals_Unblock_thread+0xb6><== NEVER TAKEN
	      (void) _Watchdog_Remove( &the_thread->Timer );                 
  118733:	83 ec 0c             	sub    $0xc,%esp                      
  118736:	8d 43 48             	lea    0x48(%ebx),%eax                
  118739:	50                   	push   %eax                           
  11873a:	e8 a5 4c ff ff       	call   10d3e4 <_Watchdog_Remove>      
  11873f:	83 c4 10             	add    $0x10,%esp                     
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
  118742:	50                   	push   %eax                           
  118743:	50                   	push   %eax                           
  118744:	68 f8 ff 03 10       	push   $0x1003fff8                    
  118749:	53                   	push   %ebx                           
  11874a:	e8 3d 37 ff ff       	call   10be8c <_Thread_Clear_state>   
  11874f:	31 c0                	xor    %eax,%eax                      
  118751:	83 c4 10             	add    $0x10,%esp                     
  118754:	eb 1e                	jmp    118774 <_POSIX_signals_Unblock_thread+0xe8>
	    _Thread_Unblock( the_thread );                                   
	  }                                                                  
    } else if ( the_thread->current_state == STATES_READY ) {         
  118756:	85 c9                	test   %ecx,%ecx                      
  118758:	75 18                	jne    118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
  11875a:	a1 30 93 12 00       	mov    0x129330,%eax                  
  11875f:	85 c0                	test   %eax,%eax                      
  118761:	74 0f                	je     118772 <_POSIX_signals_Unblock_thread+0xe6>
  118763:	3b 1d 54 93 12 00    	cmp    0x129354,%ebx                  
  118769:	75 07                	jne    118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN
	_ISR_Signals_to_thread_executing = TRUE;                             
  11876b:	c6 05 e8 93 12 00 01 	movb   $0x1,0x1293e8                  
  118772:	31 c0                	xor    %eax,%eax                      
    }                                                                 
  }                                                                   
  return false;                                                       
}                                                                     
  118774:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  118777:	5b                   	pop    %ebx                           
  118778:	5e                   	pop    %esi                           
  118779:	5f                   	pop    %edi                           
  11877a:	c9                   	leave                                 
  11877b:	c3                   	ret                                   
                                                                      

0010c788 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) {
  10c788:	55                   	push   %ebp                           
  10c789:	89 e5                	mov    %esp,%ebp                      
  10c78b:	56                   	push   %esi                           
  10c78c:	53                   	push   %ebx                           
  10c78d:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10c790:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  Heap_Get_information_status status;                                 
                                                                      
  if ( !the_heap )                                                    
  10c793:	85 f6                	test   %esi,%esi                      
  10c795:	74 33                	je     10c7ca <_Protected_heap_Get_information+0x42><== NEVER TAKEN
    return false;                                                     
                                                                      
  if ( !the_info )                                                    
  10c797:	85 db                	test   %ebx,%ebx                      
  10c799:	74 2f                	je     10c7ca <_Protected_heap_Get_information+0x42><== NEVER TAKEN
    return false;                                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
  10c79b:	83 ec 0c             	sub    $0xc,%esp                      
  10c79e:	ff 35 3c 2b 12 00    	pushl  0x122b3c                       
  10c7a4:	e8 3f ea ff ff       	call   10b1e8 <_API_Mutex_Lock>       
    status = _Heap_Get_information( the_heap, the_info );             
  10c7a9:	5a                   	pop    %edx                           
  10c7aa:	59                   	pop    %ecx                           
  10c7ab:	53                   	push   %ebx                           
  10c7ac:	56                   	push   %esi                           
  10c7ad:	e8 6e 38 00 00       	call   110020 <_Heap_Get_information> 
  10c7b2:	89 c3                	mov    %eax,%ebx                      
  _RTEMS_Unlock_allocator();                                          
  10c7b4:	58                   	pop    %eax                           
  10c7b5:	ff 35 3c 2b 12 00    	pushl  0x122b3c                       
  10c7bb:	e8 70 ea ff ff       	call   10b230 <_API_Mutex_Unlock>     
                                                                      
  if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )                    
  10c7c0:	83 c4 10             	add    $0x10,%esp                     
  10c7c3:	85 db                	test   %ebx,%ebx                      
  10c7c5:	0f 94 c0             	sete   %al                            
  10c7c8:	eb 02                	jmp    10c7cc <_Protected_heap_Get_information+0x44>
  10c7ca:	31 c0                	xor    %eax,%eax                      
    return true;                                                      
                                                                      
  return false;                                                       
}                                                                     
  10c7cc:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10c7cf:	5b                   	pop    %ebx                           
  10c7d0:	5e                   	pop    %esi                           
  10c7d1:	c9                   	leave                                 
  10c7d2:	c3                   	ret                                   
                                                                      

0010dbf3 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) {
  10dbf3:	55                   	push   %ebp                           
  10dbf4:	89 e5                	mov    %esp,%ebp                      
  10dbf6:	53                   	push   %ebx                           
  10dbf7:	83 ec 10             	sub    $0x10,%esp                     
  10dbfa:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  /*                                                                  
   *  Notepads must be the last entry in the structure and they       
   *  can be left off if disabled in the configuration.               
   */                                                                 
  to_allocate = sizeof( RTEMS_API_Control );                          
  if ( !rtems_configuration_get_notepads_enabled() )                  
  10dbfd:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10dc02:	8b 40 40             	mov    0x40(%eax),%eax                
  10dc05:	80 78 04 01          	cmpb   $0x1,0x4(%eax)                 
  10dc09:	19 c0                	sbb    %eax,%eax                      
  10dc0b:	83 e0 c0             	and    $0xffffffc0,%eax               
  10dc0e:	83 c0 60             	add    $0x60,%eax                     
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));        
                                                                      
  api = _Workspace_Allocate( to_allocate );                           
  10dc11:	50                   	push   %eax                           
  10dc12:	e8 12 e2 ff ff       	call   10be29 <_Workspace_Allocate>   
  10dc17:	89 c2                	mov    %eax,%edx                      
                                                                      
  if ( !api )                                                         
  10dc19:	83 c4 10             	add    $0x10,%esp                     
  10dc1c:	31 c0                	xor    %eax,%eax                      
  10dc1e:	85 d2                	test   %edx,%edx                      
  10dc20:	74 5d                	je     10dc7f <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN
    return false;                                                     
                                                                      
  created->API_Extensions[ THREAD_API_RTEMS ] = api;                  
  10dc22:	89 93 f4 00 00 00    	mov    %edx,0xf4(%ebx)                
                                                                      
  api->pending_events = EVENT_SETS_NONE_PENDING;                      
  10dc28:	c7 02 00 00 00 00    	movl   $0x0,(%edx)                    
#endif                                                                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
  10dc2e:	c6 42 08 01          	movb   $0x1,0x8(%edx)                 
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
  10dc32:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)                 
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
  10dc39:	c7 42 10 00 00 00 00 	movl   $0x0,0x10(%edx)                
 *                                                                    
  10dc40:	c7 42 14 00 00 00 00 	movl   $0x0,0x14(%edx)                
 *  @param[in] the_heap is the heap to operate upon                   
  10dc47:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)                
 *  @param[in] starting_address is the starting address of the memory for
  10dc4e:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)                
  _ASR_Initialize( &api->Signal );                                    
  created->task_variables = NULL;                                     
  10dc55:	c7 83 04 01 00 00 00 	movl   $0x0,0x104(%ebx)               
  10dc5c:	00 00 00                                                    
                                                                      
  if ( rtems_configuration_get_notepads_enabled() ) {                 
  10dc5f:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10dc64:	8b 40 40             	mov    0x40(%eax),%eax                
  10dc67:	80 78 04 00          	cmpb   $0x0,0x4(%eax)                 
  10dc6b:	74 10                	je     10dc7d <_RTEMS_tasks_Create_extension+0x8a>
  10dc6d:	31 c0                	xor    %eax,%eax                      
    for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)                         
      api->Notepads[i] = 0;                                           
  10dc6f:	c7 44 82 20 00 00 00 	movl   $0x0,0x20(%edx,%eax,4)         
  10dc76:	00                                                          
  api->pending_events = EVENT_SETS_NONE_PENDING;                      
  _ASR_Initialize( &api->Signal );                                    
  created->task_variables = NULL;                                     
                                                                      
  if ( rtems_configuration_get_notepads_enabled() ) {                 
    for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)                         
  10dc77:	40                   	inc    %eax                           
  10dc78:	83 f8 10             	cmp    $0x10,%eax                     
  10dc7b:	75 f2                	jne    10dc6f <_RTEMS_tasks_Create_extension+0x7c>
  10dc7d:	b0 01                	mov    $0x1,%al                       
      api->Notepads[i] = 0;                                           
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
  10dc7f:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10dc82:	c9                   	leave                                 
  10dc83:	c3                   	ret                                   
                                                                      

001094e4 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) {
  1094e4:	55                   	push   %ebp                           
  1094e5:	89 e5                	mov    %esp,%ebp                      
  1094e7:	57                   	push   %edi                           
  1094e8:	56                   	push   %esi                           
  1094e9:	53                   	push   %ebx                           
  1094ea:	83 ec 1c             	sub    $0x1c,%esp                     
  rtems_status_code                 return_value;                     
  rtems_initialization_tasks_table *user_tasks;                       
  rtems_api_configuration_table    *api_configuration;                
                                                                      
                                                                      
  api_configuration = _Configuration_Table->RTEMS_api_configuration;  
  1094ed:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  1094f2:	8b 40 40             	mov    0x40(%eax),%eax                
                                                                      
  /*                                                                  
   *  NOTE:  This is slightly different from the Ada implementation.  
   */                                                                 
                                                                      
  user_tasks = api_configuration->User_initialization_tasks_table;    
  1094f5:	8b 50 2c             	mov    0x2c(%eax),%edx                
  maximum    = api_configuration->number_of_initialization_tasks;     
  1094f8:	8b 78 28             	mov    0x28(%eax),%edi                
                                                                      
  if ( !user_tasks || maximum == 0 )                                  
  1094fb:	85 d2                	test   %edx,%edx                      
  1094fd:	74 53                	je     109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN
  1094ff:	85 ff                	test   %edi,%edi                      
  109501:	74 4f                	je     109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN
    return;                                                           
  109503:	89 d3                	mov    %edx,%ebx                      
  109505:	31 f6                	xor    %esi,%esi                      
  109507:	eb 45                	jmp    10954e <_RTEMS_tasks_Initialize_user_tasks_body+0x6a>
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
    return_value = rtems_task_create(                                 
  109509:	50                   	push   %eax                           
  10950a:	50                   	push   %eax                           
  10950b:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10950e:	50                   	push   %eax                           
  10950f:	ff 73 0c             	pushl  0xc(%ebx)                      
  109512:	ff 73 14             	pushl  0x14(%ebx)                     
  109515:	ff 73 04             	pushl  0x4(%ebx)                      
  109518:	ff 73 08             	pushl  0x8(%ebx)                      
  10951b:	ff 33                	pushl  (%ebx)                         
  10951d:	e8 ca fd ff ff       	call   1092ec <rtems_task_create>     
      user_tasks[ index ].mode_set,                                   
      user_tasks[ index ].attribute_set,                              
      &id                                                             
    );                                                                
                                                                      
    if ( !rtems_is_status_successful( return_value ) )                
  109522:	83 c4 20             	add    $0x20,%esp                     
  109525:	85 c0                	test   %eax,%eax                      
  109527:	75 19                	jne    109542 <_RTEMS_tasks_Initialize_user_tasks_body+0x5e>
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
                                                                      
    return_value = rtems_task_start(                                  
  109529:	51                   	push   %ecx                           
  10952a:	ff 73 18             	pushl  0x18(%ebx)                     
  10952d:	ff 73 10             	pushl  0x10(%ebx)                     
  109530:	ff 75 f0             	pushl  -0x10(%ebp)                    
  109533:	e8 24 00 00 00       	call   10955c <rtems_task_start>      
  109538:	83 c3 1c             	add    $0x1c,%ebx                     
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
                                                                      
    if ( !rtems_is_status_successful( return_value ) )                
  10953b:	83 c4 10             	add    $0x10,%esp                     
  10953e:	85 c0                	test   %eax,%eax                      
  109540:	74 0b                	je     10954d <_RTEMS_tasks_Initialize_user_tasks_body+0x69>
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
  109542:	52                   	push   %edx                           
  109543:	50                   	push   %eax                           
  109544:	6a 01                	push   $0x1                           
  109546:	6a 01                	push   $0x1                           
  109548:	e8 a7 0c 00 00       	call   10a1f4 <_Internal_error_Occurred>
  maximum    = api_configuration->number_of_initialization_tasks;     
                                                                      
  if ( !user_tasks || maximum == 0 )                                  
    return;                                                           
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
  10954d:	46                   	inc    %esi                           
  10954e:	39 fe                	cmp    %edi,%esi                      
  109550:	72 b7                	jb     109509 <_RTEMS_tasks_Initialize_user_tasks_body+0x25>
    );                                                                
                                                                      
    if ( !rtems_is_status_successful( return_value ) )                
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
  }                                                                   
}                                                                     
  109552:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109555:	5b                   	pop    %ebx                           
  109556:	5e                   	pop    %esi                           
  109557:	5f                   	pop    %edi                           
  109558:	c9                   	leave                                 
  109559:	c3                   	ret                                   
                                                                      

0010db40 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) {
  10db40:	55                   	push   %ebp                           
  10db41:	89 e5                	mov    %esp,%ebp                      
  10db43:	57                   	push   %edi                           
  10db44:	56                   	push   %esi                           
  10db45:	53                   	push   %ebx                           
  10db46:	83 ec 1c             	sub    $0x1c,%esp                     
  RTEMS_API_Control *api;                                             
  ASR_Information   *asr;                                             
  rtems_signal_set   signal_set;                                      
  Modes_Control      prev_mode;                                       
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  10db49:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10db4c:	8b b0 f4 00 00 00    	mov    0xf4(%eax),%esi                
  if ( !api )                                                         
  10db52:	85 f6                	test   %esi,%esi                      
  10db54:	74 45                	je     10db9b <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
  10db56:	9c                   	pushf                                 
  10db57:	fa                   	cli                                   
  10db58:	58                   	pop    %eax                           
    signal_set = asr->signals_posted;                                 
  10db59:	8b 7e 14             	mov    0x14(%esi),%edi                
    asr->signals_posted = 0;                                          
  10db5c:	c7 46 14 00 00 00 00 	movl   $0x0,0x14(%esi)                
  _ISR_Enable( level );                                               
  10db63:	50                   	push   %eax                           
  10db64:	9d                   	popf                                  
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
  10db65:	85 ff                	test   %edi,%edi                      
  10db67:	74 32                	je     10db9b <_RTEMS_tasks_Post_switch_extension+0x5b>
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
  10db69:	ff 46 1c             	incl   0x1c(%esi)                     
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
  10db6c:	50                   	push   %eax                           
  10db6d:	8d 5d f0             	lea    -0x10(%ebp),%ebx               
  10db70:	53                   	push   %ebx                           
  10db71:	68 ff ff 00 00       	push   $0xffff                        
  10db76:	ff 76 10             	pushl  0x10(%esi)                     
  10db79:	e8 56 11 00 00       	call   10ecd4 <rtems_task_mode>       
                                                                      
  (*asr->handler)( signal_set );                                      
  10db7e:	89 3c 24             	mov    %edi,(%esp)                    
  10db81:	ff 56 0c             	call   *0xc(%esi)                     
                                                                      
  asr->nest_level -= 1;                                               
  10db84:	ff 4e 1c             	decl   0x1c(%esi)                     
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
  10db87:	83 c4 0c             	add    $0xc,%esp                      
  10db8a:	53                   	push   %ebx                           
  10db8b:	68 ff ff 00 00       	push   $0xffff                        
  10db90:	ff 75 f0             	pushl  -0x10(%ebp)                    
  10db93:	e8 3c 11 00 00       	call   10ecd4 <rtems_task_mode>       
  10db98:	83 c4 10             	add    $0x10,%esp                     
                                                                      
}                                                                     
  10db9b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10db9e:	5b                   	pop    %ebx                           
  10db9f:	5e                   	pop    %esi                           
  10dba0:	5f                   	pop    %edi                           
  10dba1:	c9                   	leave                                 
  10dba2:	c3                   	ret                                   
                                                                      

0010a314 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) {
  10a314:	55                   	push   %ebp                           
  10a315:	89 e5                	mov    %esp,%ebp                      
  10a317:	53                   	push   %ebx                           
  10a318:	83 ec 18             	sub    $0x18,%esp                     
  10a31b:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  10a31e:	50                   	push   %eax                           
  10a31f:	ff 75 08             	pushl  0x8(%ebp)                      
  10a322:	68 44 1b 12 00       	push   $0x121b44                      
  10a327:	e8 98 1a 00 00       	call   10bdc4 <_Objects_Get>          
  10a32c:	89 c3                	mov    %eax,%ebx                      
  /*                                                                  
   *  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 ) {                                               
  10a32e:	83 c4 10             	add    $0x10,%esp                     
  10a331:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  10a335:	75 64                	jne    10a39b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
  10a337:	8b 50 50             	mov    0x50(%eax),%edx                
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
  10a33a:	f6 42 11 40          	testb  $0x40,0x11(%edx)               
  10a33e:	74 18                	je     10a358 <_Rate_monotonic_Timeout+0x44>
  10a340:	8b 42 20             	mov    0x20(%edx),%eax                
  10a343:	3b 43 08             	cmp    0x8(%ebx),%eax                 
  10a346:	75 10                	jne    10a358 <_Rate_monotonic_Timeout+0x44><== NEVER TAKEN
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  10a348:	50                   	push   %eax                           
  10a349:	50                   	push   %eax                           
  10a34a:	68 f8 ff 03 10       	push   $0x1003fff8                    
  10a34f:	52                   	push   %edx                           
  10a350:	e8 af 1e 00 00       	call   10c204 <_Thread_Clear_state>   
            the_thread->Wait.id == the_period->Object.id ) {          
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
  10a355:	59                   	pop    %ecx                           
  10a356:	eb 10                	jmp    10a368 <_Rate_monotonic_Timeout+0x54>
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
  10a358:	83 7b 38 01          	cmpl   $0x1,0x38(%ebx)                
  10a35c:	75 2b                	jne    10a389 <_Rate_monotonic_Timeout+0x75><== ALWAYS TAKEN
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
  10a35e:	c7 43 38 03 00 00 00 	movl   $0x3,0x38(%ebx)                <== NOT EXECUTED
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
  10a365:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10a368:	53                   	push   %ebx                           
  10a369:	e8 6a fa ff ff       	call   109dd8 <_Rate_monotonic_Initiate_statistics>
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10a36e:	8b 43 4c             	mov    0x4c(%ebx),%eax                
  10a371:	89 43 1c             	mov    %eax,0x1c(%ebx)                
  void                *starting_address,                              
  size_t              *size                                           
  10a374:	58                   	pop    %eax                           
  10a375:	5a                   	pop    %edx                           
  10a376:	8d 43 10             	lea    0x10(%ebx),%eax                
  10a379:	50                   	push   %eax                           
  10a37a:	68 1c 1d 12 00       	push   $0x121d1c                      
  10a37f:	e8 5c 31 00 00       	call   10d4e0 <_Watchdog_Insert>      
  10a384:	83 c4 10             	add    $0x10,%esp                     
  10a387:	eb 07                	jmp    10a390 <_Rate_monotonic_Timeout+0x7c>
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
  10a389:	c7 43 38 04 00 00 00 	movl   $0x4,0x38(%ebx)                
  10a390:	a1 3c 1c 12 00       	mov    0x121c3c,%eax                  
  10a395:	48                   	dec    %eax                           
  10a396:	a3 3c 1c 12 00       	mov    %eax,0x121c3c                  
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
}                                                                     
  10a39b:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10a39e:	c9                   	leave                                 
  10a39f:	c3                   	ret                                   
                                                                      

00109a64 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) {
  109a64:	55                   	push   %ebp                           
  109a65:	89 e5                	mov    %esp,%ebp                      
  109a67:	53                   	push   %ebx                           
  109a68:	83 ec 04             	sub    $0x4,%esp                      
  109a6b:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  uint32_t   days_in_month;                                           
                                                                      
  if ((!the_tod)                                  ||                  
  109a6e:	85 db                	test   %ebx,%ebx                      
  109a70:	74 5d                	je     109acf <_TOD_Validate+0x6b>    <== NEVER TAKEN
  109a72:	b8 40 42 0f 00       	mov    $0xf4240,%eax                  
  109a77:	31 d2                	xor    %edx,%edx                      
  109a79:	f7 35 30 94 12 00    	divl   0x129430                       
  109a7f:	39 43 18             	cmp    %eax,0x18(%ebx)                
  109a82:	73 4b                	jae    109acf <_TOD_Validate+0x6b>    
  109a84:	83 7b 14 3b          	cmpl   $0x3b,0x14(%ebx)               
  109a88:	77 45                	ja     109acf <_TOD_Validate+0x6b>    
  109a8a:	83 7b 10 3b          	cmpl   $0x3b,0x10(%ebx)               
  109a8e:	77 3f                	ja     109acf <_TOD_Validate+0x6b>    
  109a90:	83 7b 0c 17          	cmpl   $0x17,0xc(%ebx)                
  109a94:	77 39                	ja     109acf <_TOD_Validate+0x6b>    
  109a96:	8b 43 04             	mov    0x4(%ebx),%eax                 
  109a99:	85 c0                	test   %eax,%eax                      
  109a9b:	74 32                	je     109acf <_TOD_Validate+0x6b>    <== NEVER TAKEN
  109a9d:	83 f8 0c             	cmp    $0xc,%eax                      
  109aa0:	77 2d                	ja     109acf <_TOD_Validate+0x6b>    
  109aa2:	8b 0b                	mov    (%ebx),%ecx                    
  109aa4:	81 f9 c3 07 00 00    	cmp    $0x7c3,%ecx                    
  109aaa:	76 23                	jbe    109acf <_TOD_Validate+0x6b>    
  109aac:	8b 53 08             	mov    0x8(%ebx),%edx                 
  109aaf:	85 d2                	test   %edx,%edx                      
  109ab1:	74 1c                	je     109acf <_TOD_Validate+0x6b>    <== NEVER TAKEN
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
  109ab3:	80 e1 03             	and    $0x3,%cl                       
  109ab6:	75 09                	jne    109ac1 <_TOD_Validate+0x5d>    
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
  109ab8:	8b 04 85 64 a7 11 00 	mov    0x11a764(,%eax,4),%eax         
  109abf:	eb 07                	jmp    109ac8 <_TOD_Validate+0x64>    
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
  109ac1:	8b 04 85 30 a7 11 00 	mov    0x11a730(,%eax,4),%eax         
  109ac8:	39 c2                	cmp    %eax,%edx                      
  109aca:	0f 96 c0             	setbe  %al                            
  109acd:	eb 02                	jmp    109ad1 <_TOD_Validate+0x6d>    
  109acf:	31 c0                	xor    %eax,%eax                      
                                                                      
  if ( the_tod->day > days_in_month )                                 
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
  109ad1:	5a                   	pop    %edx                           
  109ad2:	5b                   	pop    %ebx                           
  109ad3:	c9                   	leave                                 
  109ad4:	c3                   	ret                                   
                                                                      

0010a9ec <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) {
  10a9ec:	55                   	push   %ebp                           
  10a9ed:	89 e5                	mov    %esp,%ebp                      
  10a9ef:	57                   	push   %edi                           
  10a9f0:	56                   	push   %esi                           
  10a9f1:	53                   	push   %ebx                           
  10a9f2:	83 ec 18             	sub    $0x18,%esp                     
  10a9f5:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a9f8:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  10a9fb:	8a 45 10             	mov    0x10(%ebp),%al                 
  10a9fe:	88 45 f3             	mov    %al,-0xd(%ebp)                 
*/                                                                    
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
  10aa01:	8b 7b 10             	mov    0x10(%ebx),%edi                
  /*                                                                  
   * 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 );                                
  10aa04:	53                   	push   %ebx                           
  10aa05:	e8 3e 0d 00 00       	call   10b748 <_Thread_Set_transient> 
                                                                      
  /*                                                                  
   *  Do not bother recomputing all the priority related information if
   *  we are not REALLY changing priority.                            
   */                                                                 
 if ( the_thread->current_priority != new_priority )                  
  10aa0a:	83 c4 10             	add    $0x10,%esp                     
  10aa0d:	39 73 14             	cmp    %esi,0x14(%ebx)                
  10aa10:	74 0c                	je     10aa1e <_Thread_Change_priority+0x32>
    _Thread_Set_priority( the_thread, new_priority );                 
  10aa12:	50                   	push   %eax                           
  10aa13:	50                   	push   %eax                           
  10aa14:	56                   	push   %esi                           
  10aa15:	53                   	push   %ebx                           
  10aa16:	e8 f9 0b 00 00       	call   10b614 <_Thread_Set_priority>  
  10aa1b:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  _ISR_Disable( level );                                              
  10aa1e:	9c                   	pushf                                 
  10aa1f:	fa                   	cli                                   
  10aa20:	5e                   	pop    %esi                           
                                                                      
  /*                                                                  
   *  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;                                  
  10aa21:	8b 53 10             	mov    0x10(%ebx),%edx                
  if ( state != STATES_TRANSIENT ) {                                  
  10aa24:	83 fa 04             	cmp    $0x4,%edx                      
  10aa27:	74 30                	je     10aa59 <_Thread_Change_priority+0x6d>
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
  10aa29:	83 e7 04             	and    $0x4,%edi                      
  10aa2c:	75 08                	jne    10aa36 <_Thread_Change_priority+0x4a><== NEVER TAKEN
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
  10aa2e:	89 d0                	mov    %edx,%eax                      
  10aa30:	83 e0 fb             	and    $0xfffffffb,%eax               
  10aa33:	89 43 10             	mov    %eax,0x10(%ebx)                
    _ISR_Enable( level );                                             
  10aa36:	56                   	push   %esi                           
  10aa37:	9d                   	popf                                  
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
  10aa38:	81 e2 e0 be 03 00    	and    $0x3bee0,%edx                  
  10aa3e:	0f 84 c0 00 00 00    	je     10ab04 <_Thread_Change_priority+0x118>
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
  10aa44:	89 5d 0c             	mov    %ebx,0xc(%ebp)                 
  10aa47:	8b 43 44             	mov    0x44(%ebx),%eax                
  10aa4a:	89 45 08             	mov    %eax,0x8(%ebp)                 
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
       _Thread_Executing->is_preemptible )                            
    _Context_Switch_necessary = TRUE;                                 
  _ISR_Enable( level );                                               
}                                                                     
  10aa4d:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10aa50:	5b                   	pop    %ebx                           
  10aa51:	5e                   	pop    %esi                           
  10aa52:	5f                   	pop    %edi                           
  10aa53:	c9                   	leave                                 
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
    _ISR_Enable( level );                                             
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
  10aa54:	e9 33 0b 00 00       	jmp    10b58c <_Thread_queue_Requeue> 
    }                                                                 
    return;                                                           
  }                                                                   
                                                                      
  /* Only clear the transient state if it wasn't set already */       
  if ( ! _States_Is_transient( original_state ) ) {                   
  10aa59:	83 e7 04             	and    $0x4,%edi                      
  10aa5c:	75 53                	jne    10aab1 <_Thread_Change_priority+0xc5><== NEVER TAKEN
     *  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 );
  10aa5e:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%ebx)                
 *  otherwise.                                                        
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the user block
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
  10aa65:	8b 93 90 00 00 00    	mov    0x90(%ebx),%edx                
  10aa6b:	66 8b 83 96 00 00 00 	mov    0x96(%ebx),%ax                 
  10aa72:	66 09 02             	or     %ax,(%edx)                     
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
  10aa75:	66 a1 4c d8 11 00    	mov    0x11d84c,%ax                   
  10aa7b:	0b 83 94 00 00 00    	or     0x94(%ebx),%eax                
  10aa81:	66 a3 4c d8 11 00    	mov    %ax,0x11d84c                   
                                                                      
    _Priority_Add_to_bit_map( &the_thread->Priority_map );            
    if ( prepend_it )                                                 
  10aa87:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  10aa8b:	8b 93 8c 00 00 00    	mov    0x8c(%ebx),%edx                
  10aa91:	74 0e                	je     10aaa1 <_Thread_Change_priority+0xb5>
  10aa93:	89 53 04             	mov    %edx,0x4(%ebx)                 
  10aa96:	8b 02                	mov    (%edx),%eax                    
  10aa98:	89 1a                	mov    %ebx,(%edx)                    
  10aa9a:	89 03                	mov    %eax,(%ebx)                    
  10aa9c:	89 58 04             	mov    %ebx,0x4(%eax)                 
  10aa9f:	eb 10                	jmp    10aab1 <_Thread_Change_priority+0xc5>
  10aaa1:	8d 42 04             	lea    0x4(%edx),%eax                 
  10aaa4:	89 03                	mov    %eax,(%ebx)                    
  10aaa6:	8b 42 08             	mov    0x8(%edx),%eax                 
  10aaa9:	89 5a 08             	mov    %ebx,0x8(%edx)                 
  10aaac:	89 18                	mov    %ebx,(%eax)                    
  10aaae:	89 43 04             	mov    %eax,0x4(%ebx)                 
      _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
    else                                                              
      _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
  10aab1:	56                   	push   %esi                           
  10aab2:	9d                   	popf                                  
  10aab3:	fa                   	cli                                   
  void         *starting_address,                                     
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
 *  This routine returns the block of memory which begins             
  10aab4:	66 8b 0d 4c d8 11 00 	mov    0x11d84c,%cx                   
  10aabb:	31 d2                	xor    %edx,%edx                      
  10aabd:	89 d0                	mov    %edx,%eax                      
  10aabf:	66 0f bc c1          	bsf    %cx,%ax                        
 *  at @a starting_address to @a the_heap.  Any coalescing which is   
  10aac3:	0f b7 c0             	movzwl %ax,%eax                       
  10aac6:	66 8b 8c 00 c4 d8 11 	mov    0x11d8c4(%eax,%eax,1),%cx      
  10aacd:	00                                                          
  10aace:	66 0f bc d1          	bsf    %cx,%dx                        
/**                                                                   
 *  This function sets @a *size to the size of the block of user memory
 *  which begins at @a starting_address. The size returned in @a *size could
 *  be greater than the size requested for allocation.                
 *  Returns TRUE if the @a starting_address is in the heap, and FALSE 
 *  otherwise.                                                        
  10aad2:	c1 e0 04             	shl    $0x4,%eax                      
  10aad5:	0f b7 d2             	movzwl %dx,%edx                       
  10aad8:	01 d0                	add    %edx,%eax                      
  10aada:	6b c0 0c             	imul   $0xc,%eax,%eax                 
  10aadd:	8b 15 60 d7 11 00    	mov    0x11d760,%edx                  
  10aae3:	8b 04 10             	mov    (%eax,%edx,1),%eax             
  10aae6:	a3 24 d8 11 00       	mov    %eax,0x11d824                  
  void         *starting_address,                                     
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
 *  This function attempts to allocate a block of @a size bytes from  
  10aaeb:	8b 15 58 d8 11 00    	mov    0x11d858,%edx                  
   *  We altered the set of thread priorities.  So let's figure out   
   *  who is the heir and if we need to switch to them.               
   */                                                                 
  _Thread_Calculate_heir();                                           
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
  10aaf1:	39 c2                	cmp    %eax,%edx                      
  10aaf3:	74 0d                	je     10ab02 <_Thread_Change_priority+0x116>
  10aaf5:	80 7a 76 00          	cmpb   $0x0,0x76(%edx)                
  10aaf9:	74 07                	je     10ab02 <_Thread_Change_priority+0x116><== NEVER TAKEN
       _Thread_Executing->is_preemptible )                            
    _Context_Switch_necessary = TRUE;                                 
  10aafb:	c6 05 68 d8 11 00 01 	movb   $0x1,0x11d868                  
  _ISR_Enable( level );                                               
  10ab02:	56                   	push   %esi                           
  10ab03:	9d                   	popf                                  
}                                                                     
  10ab04:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ab07:	5b                   	pop    %ebx                           
  10ab08:	5e                   	pop    %esi                           
  10ab09:	5f                   	pop    %edi                           
  10ab0a:	c9                   	leave                                 
  10ab0b:	c3                   	ret                                   
                                                                      

0010ab0c <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) {
  10ab0c:	55                   	push   %ebp                           
  10ab0d:	89 e5                	mov    %esp,%ebp                      
  10ab0f:	53                   	push   %ebx                           
  10ab10:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10ab13:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
  10ab16:	9c                   	pushf                                 
  10ab17:	fa                   	cli                                   
  10ab18:	5b                   	pop    %ebx                           
    current_state = the_thread->current_state;                        
  10ab19:	8b 51 10             	mov    0x10(%ecx),%edx                
                                                                      
    if ( current_state & state ) {                                    
  10ab1c:	85 d0                	test   %edx,%eax                      
  10ab1e:	74 6f                	je     10ab8f <_Thread_Clear_state+0x83>
 *  @param[in] page_size is the size in bytes of the allocation unit  
 *                                                                    
 *  @return This method returns the maximum memory available.  If     
 *          unsuccessful, 0 will be returned.                         
 */                                                                   
static inline uint32_t _Protected_heap_Initialize(                    
  10ab20:	f7 d0                	not    %eax                           
  10ab22:	21 d0                	and    %edx,%eax                      
      current_state =                                                 
  10ab24:	89 41 10             	mov    %eax,0x10(%ecx)                
      the_thread->current_state = _States_Clear( state, current_state );
                                                                      
      if ( _States_Is_ready( current_state ) ) {                      
  10ab27:	85 c0                	test   %eax,%eax                      
  10ab29:	75 64                	jne    10ab8f <_Thread_Clear_state+0x83>
 *  otherwise.                                                        
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the user block
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
  10ab2b:	8b 91 90 00 00 00    	mov    0x90(%ecx),%edx                
  10ab31:	66 8b 81 96 00 00 00 	mov    0x96(%ecx),%ax                 
  10ab38:	66 09 02             	or     %ax,(%edx)                     
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
  10ab3b:	66 a1 4c d8 11 00    	mov    0x11d84c,%ax                   
  10ab41:	0b 81 94 00 00 00    	or     0x94(%ecx),%eax                
  10ab47:	66 a3 4c d8 11 00    	mov    %ax,0x11d84c                   
                                                                      
        _Priority_Add_to_bit_map( &the_thread->Priority_map );        
                                                                      
        _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
  10ab4d:	8b 81 8c 00 00 00    	mov    0x8c(%ecx),%eax                
  10ab53:	8d 50 04             	lea    0x4(%eax),%edx                 
  10ab56:	89 11                	mov    %edx,(%ecx)                    
  10ab58:	8b 50 08             	mov    0x8(%eax),%edx                 
  10ab5b:	89 48 08             	mov    %ecx,0x8(%eax)                 
  10ab5e:	89 0a                	mov    %ecx,(%edx)                    
  10ab60:	89 51 04             	mov    %edx,0x4(%ecx)                 
                                                                      
        _ISR_Flash( level );                                          
  10ab63:	53                   	push   %ebx                           
  10ab64:	9d                   	popf                                  
  10ab65:	fa                   	cli                                   
         *    a context switch.                                       
         *  Pseudo-ISR case:                                          
         *    Even if the thread isn't preemptible, if the new heir is
         *    a pseudo-ISR system task, we need to do a context switch.
         */                                                           
        if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
  10ab66:	8b 51 14             	mov    0x14(%ecx),%edx                
  10ab69:	a1 24 d8 11 00       	mov    0x11d824,%eax                  
  10ab6e:	3b 50 14             	cmp    0x14(%eax),%edx                
  10ab71:	73 1c                	jae    10ab8f <_Thread_Clear_state+0x83>
          _Thread_Heir = the_thread;                                  
  10ab73:	89 0d 24 d8 11 00    	mov    %ecx,0x11d824                  
          if ( _Thread_Executing->is_preemptible ||                   
  10ab79:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  10ab7e:	80 78 76 00          	cmpb   $0x0,0x76(%eax)                
  10ab82:	75 04                	jne    10ab88 <_Thread_Clear_state+0x7c>
  10ab84:	85 d2                	test   %edx,%edx                      
  10ab86:	75 07                	jne    10ab8f <_Thread_Clear_state+0x83><== ALWAYS TAKEN
               the_thread->current_priority == 0 )                    
            _Context_Switch_necessary = TRUE;                         
  10ab88:	c6 05 68 d8 11 00 01 	movb   $0x1,0x11d868                  
        }                                                             
      }                                                               
  }                                                                   
  _ISR_Enable( level );                                               
  10ab8f:	53                   	push   %ebx                           
  10ab90:	9d                   	popf                                  
}                                                                     
  10ab91:	5b                   	pop    %ebx                           
  10ab92:	c9                   	leave                                 
  10ab93:	c3                   	ret                                   
                                                                      

0010ac74 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) {
  10ac74:	55                   	push   %ebp                           
  10ac75:	89 e5                	mov    %esp,%ebp                      
  10ac77:	83 ec 14             	sub    $0x14,%esp                     
  10ac7a:	68 f4 d8 11 00       	push   $0x11d8f4                      
  10ac7f:	e8 04 f6 ff ff       	call   10a288 <_Objects_Allocate>     
  /*                                                                  
   *  The entire workspace is zeroed during its initialization.  Thus, all
   *  fields not explicitly assigned were explicitly zeroed by        
   *  _Workspace_Initialization.                                      
   */                                                                 
  _Thread_Idle = _Thread_Internal_allocate();                         
  10ac84:	a3 40 d9 11 00       	mov    %eax,0x11d940                  
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10ac89:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  10ac8e:	40                   	inc    %eax                           
  10ac8f:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
   *  that when _Thread_Initialize unnests dispatch that we do not    
   *  do anything stupid.                                             
   */                                                                 
  _Thread_Disable_dispatch();                                         
                                                                      
  _Thread_Initialize(                                                 
  10ac94:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10ac99:	8b 50 18             	mov    0x18(%eax),%edx                
  10ac9c:	83 c4 0c             	add    $0xc,%esp                      
  10ac9f:	68 40 73 11 00       	push   $0x117340                      
  10aca4:	6a 00                	push   $0x0                           
  10aca6:	6a 00                	push   $0x0                           
  10aca8:	6a 00                	push   $0x0                           
  10acaa:	6a 01                	push   $0x1                           
  10acac:	0f b6 05 84 93 11 00 	movzbl 0x119384,%eax                  
  10acb3:	50                   	push   %eax                           
  10acb4:	6a 00                	push   $0x0                           
  10acb6:	a1 80 93 11 00       	mov    0x119380,%eax                  
  10acbb:	39 d0                	cmp    %edx,%eax                      
  10acbd:	73 02                	jae    10acc1 <_Thread_Create_idle+0x4d><== ALWAYS TAKEN
  10acbf:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  10acc1:	50                   	push   %eax                           
  10acc2:	6a 00                	push   $0x0                           
  10acc4:	ff 35 40 d9 11 00    	pushl  0x11d940                       
  10acca:	68 f4 d8 11 00       	push   $0x11d8f4                      
  10accf:	e8 50 02 00 00       	call   10af24 <_Thread_Initialize>    
  10acd4:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  10acd9:	48                   	dec    %eax                           
  10acda:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
                                                                      
  /*                                                                  
   *  WARNING!!! This is necessary to "kick" start the system and     
   *             MUST be done before _Thread_Start is invoked.        
   */                                                                 
  _Thread_Heir      =                                                 
  10acdf:	8b 15 40 d9 11 00    	mov    0x11d940,%edx                  
  10ace5:	89 15 58 d8 11 00    	mov    %edx,0x11d858                  
  10aceb:	89 15 24 d8 11 00    	mov    %edx,0x11d824                  
  _Thread_Executing = _Thread_Idle;                                   
                                                                      
  _Thread_Start(                                                      
  10acf1:	83 c4 24             	add    $0x24,%esp                     
  10acf4:	6a 00                	push   $0x0                           
  10acf6:	6a 00                	push   $0x0                           
  10acf8:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10acfd:	ff 70 14             	pushl  0x14(%eax)                     
  10ad00:	6a 00                	push   $0x0                           
  10ad02:	52                   	push   %edx                           
  10ad03:	e8 8c 0b 00 00       	call   10b894 <_Thread_Start>         
  10ad08:	83 c4 20             	add    $0x20,%esp                     
    _Configuration_Table->idle_task,                                  
    NULL,                                                             
    0                                                                 
  );                                                                  
                                                                      
}                                                                     
  10ad0b:	c9                   	leave                                 
  10ad0c:	c3                   	ret                                   
                                                                      

0010ad10 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) {
  10ad10:	55                   	push   %ebp                           
  10ad11:	89 e5                	mov    %esp,%ebp                      
  10ad13:	83 ec 20             	sub    $0x20,%esp                     
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  10ad16:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  10ad19:	50                   	push   %eax                           
  10ad1a:	ff 75 08             	pushl  0x8(%ebp)                      
  10ad1d:	e8 8a 01 00 00       	call   10aeac <_Thread_Get>           
  switch ( location ) {                                               
  10ad22:	83 c4 10             	add    $0x10,%esp                     
  10ad25:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  10ad29:	75 1b                	jne    10ad46 <_Thread_Delay_ended+0x36><== NEVER TAKEN
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  10ad2b:	52                   	push   %edx                           
  10ad2c:	52                   	push   %edx                           
  10ad2d:	68 f8 ff 03 10       	push   $0x1003fff8                    
  10ad32:	50                   	push   %eax                           
  10ad33:	e8 d4 fd ff ff       	call   10ab0c <_Thread_Clear_state>   
  10ad38:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  10ad3d:	48                   	dec    %eax                           
  10ad3e:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
  10ad43:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_LOCAL:                                               
      _Thread_Unblock( the_thread );                                  
      _Thread_Unnest_dispatch();                                      
      break;                                                          
  }                                                                   
}                                                                     
  10ad46:	c9                   	leave                                 
  10ad47:	c3                   	ret                                   
                                                                      

0010ad48 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) {
  10ad48:	55                   	push   %ebp                           
  10ad49:	89 e5                	mov    %esp,%ebp                      
  10ad4b:	57                   	push   %edi                           
  10ad4c:	56                   	push   %esi                           
  10ad4d:	53                   	push   %ebx                           
  10ad4e:	83 ec 1c             	sub    $0x1c,%esp                     
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  10ad51:	8b 1d 58 d8 11 00    	mov    0x11d858,%ebx                  
  _ISR_Disable( level );                                              
  10ad57:	9c                   	pushf                                 
  10ad58:	fa                   	cli                                   
  10ad59:	5a                   	pop    %edx                           
                                                                      
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS               
      {                                                               
        struct timespec uptime, ran;                                  
        _TOD_Get_uptime( &uptime );                                   
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
  10ad5a:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  10ad5d:	e9 f1 00 00 00       	jmp    10ae53 <_Thread_Dispatch+0x10b>
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Context_Switch_necessary == TRUE ) {                       
    heir = _Thread_Heir;                                              
  10ad62:	8b 35 24 d8 11 00    	mov    0x11d824,%esi                  
    _Thread_Dispatch_disable_level = 1;                               
  10ad68:	c7 05 98 d7 11 00 01 	movl   $0x1,0x11d798                  
  10ad6f:	00 00 00                                                    
    _Context_Switch_necessary = FALSE;                                
  10ad72:	c6 05 68 d8 11 00 00 	movb   $0x0,0x11d868                  
    _Thread_Executing = heir;                                         
  10ad79:	89 35 58 d8 11 00    	mov    %esi,0x11d858                  
#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 )
  10ad7f:	83 7e 7c 01          	cmpl   $0x1,0x7c(%esi)                
  10ad83:	75 08                	jne    10ad8d <_Thread_Dispatch+0x45> 
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
  10ad85:	a1 64 d7 11 00       	mov    0x11d764,%eax                  
  10ad8a:	89 46 78             	mov    %eax,0x78(%esi)                
    _ISR_Enable( level );                                             
  10ad8d:	52                   	push   %edx                           
  10ad8e:	9d                   	popf                                  
                                                                      
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS               
      {                                                               
        struct timespec uptime, ran;                                  
        _TOD_Get_uptime( &uptime );                                   
  10ad8f:	83 ec 0c             	sub    $0xc,%esp                      
  10ad92:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10ad95:	50                   	push   %eax                           
  10ad96:	e8 a1 31 00 00       	call   10df3c <_TOD_Get_uptime>       
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
  10ad9b:	83 c4 0c             	add    $0xc,%esp                      
  10ad9e:	57                   	push   %edi                           
  10ad9f:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10ada2:	50                   	push   %eax                           
  10ada3:	68 60 d8 11 00       	push   $0x11d860                      
  10ada8:	e8 37 0c 00 00       	call   10b9e4 <_Timespec_Subtract>    
        _Timespec_Add_to( &executing->cpu_time_used, &ran );          
  10adad:	58                   	pop    %eax                           
  10adae:	5a                   	pop    %edx                           
  10adaf:	57                   	push   %edi                           
  10adb0:	8d 83 84 00 00 00    	lea    0x84(%ebx),%eax                
  10adb6:	50                   	push   %eax                           
  10adb7:	e8 f8 0b 00 00       	call   10b9b4 <_Timespec_Add_to>      
        _Thread_Time_of_last_context_switch = uptime;                 
  10adbc:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10adbf:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  10adc2:	a3 60 d8 11 00       	mov    %eax,0x11d860                  
  10adc7:	89 15 64 d8 11 00    	mov    %edx,0x11d864                  
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
  10adcd:	8b 15 20 d8 11 00    	mov    0x11d820,%edx                  
  10add3:	83 c4 10             	add    $0x10,%esp                     
  10add6:	85 d2                	test   %edx,%edx                      
  10add8:	74 10                	je     10adea <_Thread_Dispatch+0xa2> <== NEVER TAKEN
      executing->libc_reent = *_Thread_libc_reent;                    
  10adda:	8b 02                	mov    (%edx),%eax                    
  10addc:	89 83 f0 00 00 00    	mov    %eax,0xf0(%ebx)                
      *_Thread_libc_reent = heir->libc_reent;                         
  10ade2:	8b 86 f0 00 00 00    	mov    0xf0(%esi),%eax                
  10ade8:	89 02                	mov    %eax,(%edx)                    
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
  10adea:	51                   	push   %ecx                           
  10adeb:	51                   	push   %ecx                           
  10adec:	56                   	push   %esi                           
  10aded:	53                   	push   %ebx                           
  10adee:	e8 01 0e 00 00       	call   10bbf4 <_User_extensions_Thread_switch>
    if ( executing->fp_context != NULL )                              
      _Context_Save_fp( &executing->fp_context );                     
#endif                                                                
#endif                                                                
                                                                      
    _Context_Switch( &executing->Registers, &heir->Registers );       
  10adf3:	58                   	pop    %eax                           
  10adf4:	5a                   	pop    %edx                           
  10adf5:	8d 86 d4 00 00 00    	lea    0xd4(%esi),%eax                
  10adfb:	50                   	push   %eax                           
  10adfc:	8d 83 d4 00 00 00    	lea    0xd4(%ebx),%eax                
  10ae02:	50                   	push   %eax                           
  10ae03:	e8 b8 10 00 00       	call   10bec0 <_CPU_Context_switch>   
                                                                      
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )                            
    if ( (executing->fp_context != NULL) &&                           
  10ae08:	83 c4 10             	add    $0x10,%esp                     
  10ae0b:	83 bb ec 00 00 00 00 	cmpl   $0x0,0xec(%ebx)                
  10ae12:	74 36                	je     10ae4a <_Thread_Dispatch+0x102>
  Heap_Control        *the_heap,                                      
  void                *starting_address,                              
  size_t              *size                                           
);                                                                    
                                                                      
/**                                                                   
  10ae14:	a1 1c d8 11 00       	mov    0x11d81c,%eax                  
  10ae19:	39 c3                	cmp    %eax,%ebx                      
  10ae1b:	74 2d                	je     10ae4a <_Thread_Dispatch+0x102>
         !_Thread_Is_allocated_fp( executing ) ) {                    
      if ( _Thread_Allocated_fp != NULL )                             
  10ae1d:	85 c0                	test   %eax,%eax                      
  10ae1f:	74 11                	je     10ae32 <_Thread_Dispatch+0xea> 
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );        
  10ae21:	83 ec 0c             	sub    $0xc,%esp                      
  10ae24:	05 ec 00 00 00       	add    $0xec,%eax                     
  10ae29:	50                   	push   %eax                           
  10ae2a:	e8 c5 10 00 00       	call   10bef4 <_CPU_Context_save_fp>  
  10ae2f:	83 c4 10             	add    $0x10,%esp                     
      _Context_Restore_fp( &executing->fp_context );                  
  10ae32:	83 ec 0c             	sub    $0xc,%esp                      
  10ae35:	8d 83 ec 00 00 00    	lea    0xec(%ebx),%eax                
  10ae3b:	50                   	push   %eax                           
  10ae3c:	e8 bd 10 00 00       	call   10befe <_CPU_Context_restore_fp>
      _Thread_Allocated_fp = executing;                               
  10ae41:	89 1d 1c d8 11 00    	mov    %ebx,0x11d81c                  
  10ae47:	83 c4 10             	add    $0x10,%esp                     
    if ( executing->fp_context != NULL )                              
      _Context_Restore_fp( &executing->fp_context );                  
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
  10ae4a:	8b 1d 58 d8 11 00    	mov    0x11d858,%ebx                  
                                                                      
    _ISR_Disable( level );                                            
  10ae50:	9c                   	pushf                                 
  10ae51:	fa                   	cli                                   
  10ae52:	5a                   	pop    %edx                           
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Context_Switch_necessary == TRUE ) {                       
  10ae53:	a0 68 d8 11 00       	mov    0x11d868,%al                   
  10ae58:	84 c0                	test   %al,%al                        
  10ae5a:	0f 85 02 ff ff ff    	jne    10ad62 <_Thread_Dispatch+0x1a> 
    executing = _Thread_Executing;                                    
                                                                      
    _ISR_Disable( level );                                            
  }                                                                   
                                                                      
  _Thread_Dispatch_disable_level = 0;                                 
  10ae60:	c7 05 98 d7 11 00 00 	movl   $0x0,0x11d798                  
  10ae67:	00 00 00                                                    
                                                                      
  _ISR_Enable( level );                                               
  10ae6a:	52                   	push   %edx                           
  10ae6b:	9d                   	popf                                  
                                                                      
  if ( _Thread_Do_post_task_switch_extension ||                       
  10ae6c:	83 3d 3c d8 11 00 00 	cmpl   $0x0,0x11d83c                  
  10ae73:	75 06                	jne    10ae7b <_Thread_Dispatch+0x133>
  10ae75:	80 7b 75 00          	cmpb   $0x0,0x75(%ebx)                
  10ae79:	74 09                	je     10ae84 <_Thread_Dispatch+0x13c>
       executing->do_post_task_switch_extension ) {                   
    executing->do_post_task_switch_extension = false;                 
  10ae7b:	c6 43 75 00          	movb   $0x0,0x75(%ebx)                
    _API_extensions_Run_postswitch();                                 
  10ae7f:	e8 4b eb ff ff       	call   1099cf <_API_extensions_Run_postswitch>
  }                                                                   
                                                                      
}                                                                     
  10ae84:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ae87:	5b                   	pop    %ebx                           
  10ae88:	5e                   	pop    %esi                           
  10ae89:	5f                   	pop    %edi                           
  10ae8a:	c9                   	leave                                 
  10ae8b:	c3                   	ret                                   
                                                                      

0010ef3c <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) {
  10ef3c:	55                   	push   %ebp                           
  10ef3d:	89 e5                	mov    %esp,%ebp                      
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
  10ef3f:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
                                                                      
  if ( !_States_Is_ready( executing->current_state ) ||               
  10ef44:	83 78 10 00          	cmpl   $0x0,0x10(%eax)                
  10ef48:	75 0e                	jne    10ef58 <_Thread_Evaluate_mode+0x1c><== NEVER TAKEN
  10ef4a:	3b 05 24 d8 11 00    	cmp    0x11d824,%eax                  
  10ef50:	74 11                	je     10ef63 <_Thread_Evaluate_mode+0x27>
  10ef52:	80 78 76 00          	cmpb   $0x0,0x76(%eax)                
  10ef56:	74 0b                	je     10ef63 <_Thread_Evaluate_mode+0x27><== NEVER TAKEN
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    _Context_Switch_necessary = TRUE;                                 
  10ef58:	c6 05 68 d8 11 00 01 	movb   $0x1,0x11d868                  
  10ef5f:	b0 01                	mov    $0x1,%al                       
  10ef61:	eb 02                	jmp    10ef65 <_Thread_Evaluate_mode+0x29>
    return TRUE;                                                      
  10ef63:	31 c0                	xor    %eax,%eax                      
  }                                                                   
                                                                      
  return FALSE;                                                       
}                                                                     
  10ef65:	c9                   	leave                                 
  10ef66:	c3                   	ret                                   
                                                                      

0010aeac <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) {
  10aeac:	55                   	push   %ebp                           
  10aead:	89 e5                	mov    %esp,%ebp                      
  10aeaf:	53                   	push   %ebx                           
  10aeb0:	83 ec 04             	sub    $0x4,%esp                      
  10aeb3:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10aeb6:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  uint32_t             the_class;                                     
  Objects_Information **api_information;                              
  Objects_Information *information;                                   
  Thread_Control      *tp = (Thread_Control *) 0;                     
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {           
  10aeb9:	85 db                	test   %ebx,%ebx                      
  10aebb:	75 18                	jne    10aed5 <_Thread_Get+0x29>      
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10aebd:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  10aec2:	40                   	inc    %eax                           
  10aec3:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
    _Thread_Disable_dispatch();                                       
    *location = OBJECTS_LOCAL;                                        
  10aec8:	c7 01 00 00 00 00    	movl   $0x0,(%ecx)                    
    tp = _Thread_Executing;                                           
  10aece:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  10aed3:	eb 40                	jmp    10af15 <_Thread_Get+0x69>      
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
  10aed5:	89 da                	mov    %ebx,%edx                      
  10aed7:	c1 ea 18             	shr    $0x18,%edx                     
  10aeda:	83 e2 07             	and    $0x7,%edx                      
/**                                                                   
 *  This function sets @a *size to the size of the block of user memory
 *  which begins at @a starting_address. The size returned in @a *size could
 *  be greater than the size requested for allocation.                
 *  Returns TRUE if the @a starting_address is in the heap, and FALSE 
 *  otherwise.                                                        
  10aedd:	8d 42 ff             	lea    -0x1(%edx),%eax                
  10aee0:	83 f8 03             	cmp    $0x3,%eax                      
  10aee3:	76 35                	jbe    10af1a <_Thread_Get+0x6e>      
    goto done;                                                        
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
    *location = OBJECTS_ERROR;                                        
  10aee5:	c7 01 01 00 00 00    	movl   $0x1,(%ecx)                    
  10aeeb:	31 c0                	xor    %eax,%eax                      
  10aeed:	eb 26                	jmp    10af15 <_Thread_Get+0x69>      
    goto done;                                                        
  }                                                                   
                                                                      
  api_information = _Objects_Information_table[ the_api ];            
  10aeef:	8b 04 95 6c d7 11 00 	mov    0x11d76c(,%edx,4),%eax         
  if ( !api_information ) {                                           
  10aef6:	85 c0                	test   %eax,%eax                      
  10aef8:	74 07                	je     10af01 <_Thread_Get+0x55>      
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  information = api_information[ the_class ];                         
  10aefa:	8b 40 04             	mov    0x4(%eax),%eax                 
  if ( !information ) {                                               
  10aefd:	85 c0                	test   %eax,%eax                      
  10aeff:	75 08                	jne    10af09 <_Thread_Get+0x5d>      <== ALWAYS TAKEN
    *location = OBJECTS_ERROR;                                        
  10af01:	c7 01 01 00 00 00    	movl   $0x1,(%ecx)                    
  10af07:	eb 0c                	jmp    10af15 <_Thread_Get+0x69>      
    goto done;                                                        
  }                                                                   
                                                                      
  tp = (Thread_Control *) _Objects_Get( information, id, location );  
  10af09:	52                   	push   %edx                           
  10af0a:	51                   	push   %ecx                           
  10af0b:	53                   	push   %ebx                           
  10af0c:	50                   	push   %eax                           
  10af0d:	e8 ba f7 ff ff       	call   10a6cc <_Objects_Get>          
  10af12:	83 c4 10             	add    $0x10,%esp                     
                                                                      
done:                                                                 
  return tp;                                                          
}                                                                     
  10af15:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10af18:	c9                   	leave                                 
  10af19:	c3                   	ret                                   
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
  10af1a:	89 d8                	mov    %ebx,%eax                      
  10af1c:	c1 e8 1b             	shr    $0x1b,%eax                     
  10af1f:	48                   	dec    %eax                           
  10af20:	74 cd                	je     10aeef <_Thread_Get+0x43>      
  10af22:	eb c1                	jmp    10aee5 <_Thread_Get+0x39>      
                                                                      

0010ef68 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) {
  10ef68:	55                   	push   %ebp                           
  10ef69:	89 e5                	mov    %esp,%ebp                      
  10ef6b:	53                   	push   %ebx                           
  10ef6c:	83 ec 04             	sub    $0x4,%esp                      
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)              
  static char doneConstructors;                                       
  char doneCons;                                                      
#endif                                                                
                                                                      
  executing = _Thread_Executing;                                      
  10ef6f:	8b 1d 58 d8 11 00    	mov    0x11d858,%ebx                  
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
                                                                      
  level = executing->Start.isr_level;                                 
  10ef75:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                
  _ISR_Set_level(level);                                              
  10ef7b:	85 c0                	test   %eax,%eax                      
  10ef7d:	74 03                	je     10ef82 <_Thread_Handler+0x1a>  
  10ef7f:	fa                   	cli                                   
  10ef80:	eb 01                	jmp    10ef83 <_Thread_Handler+0x1b>  
  10ef82:	fb                   	sti                                   
                                                                      
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)              
  doneCons = doneConstructors;                                        
  10ef83:	a0 90 d5 11 00       	mov    0x11d590,%al                   
  10ef88:	88 45 fb             	mov    %al,-0x5(%ebp)                 
  doneConstructors = 1;                                               
  10ef8b:	c6 05 90 d5 11 00 01 	movb   $0x1,0x11d590                  
#endif                                                                
                                                                      
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )                            
  if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) {
  10ef92:	83 bb ec 00 00 00 00 	cmpl   $0x0,0xec(%ebx)                
  10ef99:	74 24                	je     10efbf <_Thread_Handler+0x57>  
  Heap_Control        *the_heap,                                      
  void                *starting_address,                              
  size_t              *size                                           
);                                                                    
                                                                      
/**                                                                   
  10ef9b:	a1 1c d8 11 00       	mov    0x11d81c,%eax                  
  10efa0:	39 c3                	cmp    %eax,%ebx                      
  10efa2:	74 1b                	je     10efbf <_Thread_Handler+0x57>  
    if ( _Thread_Allocated_fp != NULL )                               
  10efa4:	85 c0                	test   %eax,%eax                      
  10efa6:	74 11                	je     10efb9 <_Thread_Handler+0x51>  
      _Context_Save_fp( &_Thread_Allocated_fp->fp_context );          
  10efa8:	83 ec 0c             	sub    $0xc,%esp                      
  10efab:	05 ec 00 00 00       	add    $0xec,%eax                     
  10efb0:	50                   	push   %eax                           
  10efb1:	e8 3e cf ff ff       	call   10bef4 <_CPU_Context_save_fp>  
  10efb6:	83 c4 10             	add    $0x10,%esp                     
    _Thread_Allocated_fp = executing;                                 
  10efb9:	89 1d 1c d8 11 00    	mov    %ebx,0x11d81c                  
   * Take care that 'begin' extensions get to complete before         
   * 'switch' extensions can run.  This means must keep dispatch      
   * disabled until all 'begin' extensions complete.                  
   */                                                                 
                                                                      
  _User_extensions_Thread_begin( executing );                         
  10efbf:	83 ec 0c             	sub    $0xc,%esp                      
  10efc2:	53                   	push   %ebx                           
  10efc3:	e8 e0 ca ff ff       	call   10baa8 <_User_extensions_Thread_begin>
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
                                                                      
  _Thread_Enable_dispatch();                                          
  10efc8:	e8 bf be ff ff       	call   10ae8c <_Thread_Enable_dispatch>
  /*                                                                  
   *  _init could be a weak symbol and we SHOULD test it but it isn't 
   *  in any configuration I know of and it generates a warning on every
   *  RTEMS target configuration.  --joel (12 May 2007)               
   */                                                                 
  if (!doneCons) /* && (volatile void *)_init) */                     
  10efcd:	83 c4 10             	add    $0x10,%esp                     
  10efd0:	80 7d fb 00          	cmpb   $0x0,-0x5(%ebp)                
  10efd4:	75 05                	jne    10efdb <_Thread_Handler+0x73>  
  {                                                                   
    _init ();                                                         
  10efd6:	e8 85 6e 00 00       	call   115e60 <__start_set_sysctl_set>
#if defined(__USE__MAIN__)                                            
  if (!doneCons && _main)                                             
    __main ();                                                        
#endif                                                                
                                                                      
  switch ( executing->Start.prototype ) {                             
  10efdb:	8b 83 a0 00 00 00    	mov    0xa0(%ebx),%eax                
  10efe1:	83 f8 01             	cmp    $0x1,%eax                      
  10efe4:	74 13                	je     10eff9 <_Thread_Handler+0x91>  
  10efe6:	72 0c                	jb     10eff4 <_Thread_Handler+0x8c>  <== ALWAYS TAKEN
  10efe8:	83 f8 02             	cmp    $0x2,%eax                      <== NOT EXECUTED
  10efeb:	74 11                	je     10effe <_Thread_Handler+0x96>  <== NOT EXECUTED
  10efed:	83 f8 03             	cmp    $0x3,%eax                      <== NOT EXECUTED
  10eff0:	75 36                	jne    10f028 <_Thread_Handler+0xc0>  <== NOT EXECUTED
  10eff2:	eb 1a                	jmp    10f00e <_Thread_Handler+0xa6>  <== NOT EXECUTED
    case THREAD_START_NUMERIC:                                        
      executing->Wait.return_argument =                               
  10eff4:	83 ec 0c             	sub    $0xc,%esp                      
  10eff7:	eb 1d                	jmp    10f016 <_Thread_Handler+0xae>  
        (*(Thread_Entry_numeric) executing->Start.entry_point)(       
          executing->Start.numeric_argument                           
      );                                                              
      break;                                                          
    case THREAD_START_POINTER:                                        
      executing->Wait.return_argument =                               
  10eff9:	83 ec 0c             	sub    $0xc,%esp                      
  10effc:	eb 08                	jmp    10f006 <_Thread_Handler+0x9e>  
        (*(Thread_Entry_pointer) executing->Start.entry_point)(       
          executing->Start.pointer_argument                           
        );                                                            
      break;                                                          
    case THREAD_START_BOTH_POINTER_FIRST:                             
      executing->Wait.return_argument =                               
  10effe:	52                   	push   %edx                           <== NOT EXECUTED
  10efff:	52                   	push   %edx                           <== NOT EXECUTED
  10f000:	ff b3 a8 00 00 00    	pushl  0xa8(%ebx)                     <== NOT EXECUTED
  10f006:	ff b3 a4 00 00 00    	pushl  0xa4(%ebx)                     
  10f00c:	eb 0e                	jmp    10f01c <_Thread_Handler+0xb4>  
           executing->Start.pointer_argument,                         
           executing->Start.numeric_argument                          
         );                                                           
      break;                                                          
    case THREAD_START_BOTH_NUMERIC_FIRST:                             
      executing->Wait.return_argument =                               
  10f00e:	50                   	push   %eax                           <== NOT EXECUTED
  10f00f:	50                   	push   %eax                           <== NOT EXECUTED
  10f010:	ff b3 a4 00 00 00    	pushl  0xa4(%ebx)                     <== NOT EXECUTED
  10f016:	ff b3 a8 00 00 00    	pushl  0xa8(%ebx)                     
  10f01c:	ff 93 9c 00 00 00    	call   *0x9c(%ebx)                    
  10f022:	89 43 28             	mov    %eax,0x28(%ebx)                
  10f025:	83 c4 10             	add    $0x10,%esp                     
   *  was placed in return_argument.  This assumed that if it returned
   *  anything (which is not supporting in all APIs), then it would be
   *  able to fit in a (void *).                                      
   */                                                                 
                                                                      
  _User_extensions_Thread_exitted( executing );                       
  10f028:	83 ec 0c             	sub    $0xc,%esp                      
  10f02b:	53                   	push   %ebx                           
  10f02c:	e8 a8 ca ff ff       	call   10bad9 <_User_extensions_Thread_exitted>
                                                                      
  _Internal_error_Occurred(                                           
  10f031:	83 c4 0c             	add    $0xc,%esp                      
  10f034:	6a 06                	push   $0x6                           
  10f036:	6a 01                	push   $0x1                           
  10f038:	6a 00                	push   $0x0                           
  10f03a:	e8 b5 b1 ff ff       	call   10a1f4 <_Internal_error_Occurred>
                                                                      

0010af24 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) {
  10af24:	55                   	push   %ebp                           
  10af25:	89 e5                	mov    %esp,%ebp                      
  10af27:	57                   	push   %edi                           
  10af28:	56                   	push   %esi                           
  10af29:	53                   	push   %ebx                           
  10af2a:	83 ec 0c             	sub    $0xc,%esp                      
  10af2d:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10af30:	8b 55 10             	mov    0x10(%ebp),%edx                
  10af33:	8b 75 14             	mov    0x14(%ebp),%esi                
  10af36:	8a 45 18             	mov    0x18(%ebp),%al                 
  10af39:	88 45 f3             	mov    %al,-0xd(%ebp)                 
  10af3c:	8a 45 20             	mov    0x20(%ebp),%al                 
  10af3f:	88 45 f2             	mov    %al,-0xe(%ebp)                 
  /*                                                                  
   *  Allocate and Initialize the stack for this thread.              
   */                                                                 
                                                                      
                                                                      
  if ( !stack_area ) {                                                
  10af42:	85 d2                	test   %edx,%edx                      
  10af44:	75 2a                	jne    10af70 <_Thread_Initialize+0x4c><== NEVER TAKEN
                                                                      
    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
  10af46:	51                   	push   %ecx                           
  10af47:	51                   	push   %ecx                           
  10af48:	56                   	push   %esi                           
  10af49:	53                   	push   %ebx                           
  10af4a:	e8 69 08 00 00       	call   10b7b8 <_Thread_Stack_Allocate>
                                                                      
    if ( !actual_stack_size || actual_stack_size < stack_size )       
  10af4f:	83 c4 10             	add    $0x10,%esp                     
  10af52:	85 c0                	test   %eax,%eax                      
  10af54:	74 04                	je     10af5a <_Thread_Initialize+0x36>
  10af56:	39 f0                	cmp    %esi,%eax                      
  10af58:	73 07                	jae    10af61 <_Thread_Initialize+0x3d><== ALWAYS TAKEN
  10af5a:	31 d2                	xor    %edx,%edx                      
  10af5c:	e9 8c 01 00 00       	jmp    10b0ed <_Thread_Initialize+0x1c9>
      return FALSE;                     /* stack allocation failed */ 
                                                                      
    stack = the_thread->Start.stack;                                  
  10af61:	8b 93 d0 00 00 00    	mov    0xd0(%ebx),%edx                
    the_thread->Start.core_allocated_stack = TRUE;                    
  10af67:	c6 83 c0 00 00 00 01 	movb   $0x1,0xc0(%ebx)                
  10af6e:	eb 09                	jmp    10af79 <_Thread_Initialize+0x55>
  } else {                                                            
    stack = stack_area;                                               
    actual_stack_size = stack_size;                                   
    the_thread->Start.core_allocated_stack = FALSE;                   
  10af70:	c6 83 c0 00 00 00 00 	movb   $0x0,0xc0(%ebx)                <== NOT EXECUTED
  10af77:	89 f0                	mov    %esi,%eax                      <== NOT EXECUTED
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
  10af79:	89 93 c8 00 00 00    	mov    %edx,0xc8(%ebx)                
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
  10af7f:	89 83 c4 00 00 00    	mov    %eax,0xc4(%ebx)                
  if ( is_fp ) {                                                      
                                                                      
    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );                 
    if ( !fp_area ) {                                                 
      _Thread_Stack_Free( the_thread );                               
      return FALSE;                                                   
  10af85:	31 f6                	xor    %esi,%esi                      
  /*                                                                  
   *  Allocate the floating point area for this thread                
   */                                                                 
                                                                      
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  if ( is_fp ) {                                                      
  10af87:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  10af8b:	74 17                	je     10afa4 <_Thread_Initialize+0x80>
                                                                      
    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );                 
  10af8d:	83 ec 0c             	sub    $0xc,%esp                      
  10af90:	6a 6c                	push   $0x6c                          
  10af92:	e8 92 0e 00 00       	call   10be29 <_Workspace_Allocate>   
  10af97:	89 c6                	mov    %eax,%esi                      
    if ( !fp_area ) {                                                 
  10af99:	83 c4 10             	add    $0x10,%esp                     
  10af9c:	85 c0                	test   %eax,%eax                      
  10af9e:	0f 84 3b 01 00 00    	je     10b0df <_Thread_Initialize+0x1bb><== NEVER TAKEN
    fp_area = _Context_Fp_start( fp_area, 0 );                        
                                                                      
  } else                                                              
    fp_area = NULL;                                                   
                                                                      
  the_thread->fp_context       = fp_area;                             
  10afa4:	89 b3 ec 00 00 00    	mov    %esi,0xec(%ebx)                
  the_thread->Start.fp_context = fp_area;                             
  10afaa:	89 b3 cc 00 00 00    	mov    %esi,0xcc(%ebx)                
 *                                                                    
  10afb0:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  10afb7:	c7 43 64 00 00 00 00 	movl   $0x0,0x64(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  10afbe:	c7 43 68 00 00 00 00 	movl   $0x0,0x68(%ebx)                
 *         the heap                                                   
  10afc5:	c7 43 6c 00 00 00 00 	movl   $0x0,0x6c(%ebx)                
                                                                      
  /*                                                                  
   * Clear the libc reent hook.                                       
   */                                                                 
                                                                      
  the_thread->libc_reent = NULL;                                      
  10afcc:	c7 83 f0 00 00 00 00 	movl   $0x0,0xf0(%ebx)                
  10afd3:	00 00 00                                                    
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
                                                                      
  if ( _Thread_Maximum_extensions ) {                                 
  10afd6:	a1 38 d8 11 00       	mov    0x11d838,%eax                  
        (void) _Workspace_Free( fp_area );                            
#endif                                                                
                                                                      
      _Thread_Stack_Free( the_thread );                               
                                                                      
      return FALSE;                                                   
  10afdb:	31 ff                	xor    %edi,%edi                      
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
                                                                      
  if ( _Thread_Maximum_extensions ) {                                 
  10afdd:	85 c0                	test   %eax,%eax                      
  10afdf:	74 1d                	je     10affe <_Thread_Initialize+0xda>
    extensions_area = _Workspace_Allocate(                            
  10afe1:	83 ec 0c             	sub    $0xc,%esp                      
  10afe4:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax              
  10afeb:	50                   	push   %eax                           
  10afec:	e8 38 0e 00 00       	call   10be29 <_Workspace_Allocate>   
  10aff1:	89 c7                	mov    %eax,%edi                      
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
                                                                      
    if ( !extensions_area ) {                                         
  10aff3:	83 c4 10             	add    $0x10,%esp                     
  10aff6:	85 c0                	test   %eax,%eax                      
  10aff8:	0f 84 d1 00 00 00    	je     10b0cf <_Thread_Initialize+0x1ab><== NEVER TAKEN
      return FALSE;                                                   
    }                                                                 
  } else                                                              
    extensions_area = NULL;                                           
                                                                      
  the_thread->extensions = (void **) extensions_area;                 
  10affe:	89 bb 00 01 00 00    	mov    %edi,0x100(%ebx)               
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
                                                                      
  if ( the_thread->extensions ) {                                     
  10b004:	31 d2                	xor    %edx,%edx                      
  10b006:	85 ff                	test   %edi,%edi                      
  10b008:	75 10                	jne    10b01a <_Thread_Initialize+0xf6>
  10b00a:	eb 18                	jmp    10b024 <_Thread_Initialize+0x100>
    uint32_t i;                                                       
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )          
      the_thread->extensions[i] = NULL;                               
  10b00c:	8b 83 00 01 00 00    	mov    0x100(%ebx),%eax               
  10b012:	c7 04 90 00 00 00 00 	movl   $0x0,(%eax,%edx,4)             
   * call.                                                            
   */                                                                 
                                                                      
  if ( the_thread->extensions ) {                                     
    uint32_t i;                                                       
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )          
  10b019:	42                   	inc    %edx                           
  10b01a:	a1 38 d8 11 00       	mov    0x11d838,%eax                  
  10b01f:	40                   	inc    %eax                           
  10b020:	39 c2                	cmp    %eax,%edx                      
  10b022:	72 e8                	jb     10b00c <_Thread_Initialize+0xe8>
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  10b024:	8a 45 f2             	mov    -0xe(%ebp),%al                 
  10b027:	88 83 ac 00 00 00    	mov    %al,0xac(%ebx)                 
  the_thread->Start.budget_algorithm = budget_algorithm;              
  10b02d:	8b 45 24             	mov    0x24(%ebp),%eax                
  10b030:	89 83 b0 00 00 00    	mov    %eax,0xb0(%ebx)                
  the_thread->Start.budget_callout   = budget_callout;                
  10b036:	8b 45 28             	mov    0x28(%ebp),%eax                
  10b039:	89 83 b4 00 00 00    	mov    %eax,0xb4(%ebx)                
                                                                      
  switch ( budget_algorithm ) {                                       
  10b03f:	83 7d 24 02          	cmpl   $0x2,0x24(%ebp)                
  10b043:	75 08                	jne    10b04d <_Thread_Initialize+0x129><== ALWAYS TAKEN
    case THREAD_CPU_BUDGET_ALGORITHM_NONE:                            
    case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:                 
      break;                                                          
    case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:               
      the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;      
  10b045:	a1 64 d7 11 00       	mov    0x11d764,%eax                  <== NOT EXECUTED
  10b04a:	89 43 78             	mov    %eax,0x78(%ebx)                <== NOT EXECUTED
      break;                                                          
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                         
      break;                                                          
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
  10b04d:	8b 45 2c             	mov    0x2c(%ebp),%eax                
  10b050:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
  10b056:	c7 43 10 01 00 00 00 	movl   $0x1,0x10(%ebx)                
  the_thread->Wait.queue              = NULL;                         
  10b05d:	c7 43 44 00 00 00 00 	movl   $0x0,0x44(%ebx)                
  the_thread->resource_count          = 0;                            
  10b064:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)                
  the_thread->suspend_count           = 0;                            
  10b06b:	c7 43 70 00 00 00 00 	movl   $0x0,0x70(%ebx)                
  the_thread->real_priority           = priority;                     
  10b072:	8b 45 1c             	mov    0x1c(%ebp),%eax                
  10b075:	89 43 18             	mov    %eax,0x18(%ebx)                
  the_thread->Start.initial_priority  = priority;                     
  10b078:	89 83 bc 00 00 00    	mov    %eax,0xbc(%ebx)                
  _Thread_Set_priority( the_thread, priority );                       
  10b07e:	52                   	push   %edx                           
  10b07f:	52                   	push   %edx                           
  10b080:	50                   	push   %eax                           
  10b081:	53                   	push   %ebx                           
  10b082:	e8 8d 05 00 00       	call   10b614 <_Thread_Set_priority>  
  /*                                                                  
   *  Initialize the CPU usage statistics                             
   */                                                                 
                                                                      
  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS                 
    the_thread->cpu_time_used.tv_sec  = 0;                            
  10b087:	c7 83 84 00 00 00 00 	movl   $0x0,0x84(%ebx)                
  10b08e:	00 00 00                                                    
    the_thread->cpu_time_used.tv_nsec = 0;                            
  10b091:	c7 83 88 00 00 00 00 	movl   $0x0,0x88(%ebx)                
  10b098:	00 00 00                                                    
  10b09b:	0f b7 53 08          	movzwl 0x8(%ebx),%edx                 
  10b09f:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10b0a2:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10b0a5:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  10b0a8:	8b 45 30             	mov    0x30(%ebp),%eax                
  10b0ab:	89 43 0c             	mov    %eax,0xc(%ebx)                 
   *  enabled when we get here.  We want to be able to run the        
   *  user extensions with dispatching enabled.  The Allocator        
   *  Mutex provides sufficient protection to let the user extensions 
   *  run safely.                                                     
   */                                                                 
  extension_status = _User_extensions_Thread_create( the_thread );    
  10b0ae:	89 1c 24             	mov    %ebx,(%esp)                    
  10b0b1:	e8 92 0a 00 00       	call   10bb48 <_User_extensions_Thread_create>
                                                                      
  if ( !extension_status ) {                                          
  10b0b6:	83 c4 10             	add    $0x10,%esp                     
  10b0b9:	b2 01                	mov    $0x1,%dl                       
  10b0bb:	84 c0                	test   %al,%al                        
  10b0bd:	75 2e                	jne    10b0ed <_Thread_Initialize+0x1c9>
                                                                      
    if ( extensions_area )                                            
  10b0bf:	85 ff                	test   %edi,%edi                      
  10b0c1:	74 0c                	je     10b0cf <_Thread_Initialize+0x1ab><== ALWAYS TAKEN
      (void) _Workspace_Free( extensions_area );                      
  10b0c3:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10b0c6:	57                   	push   %edi                           <== NOT EXECUTED
  10b0c7:	e8 48 0d 00 00       	call   10be14 <_Workspace_Free>       <== NOT EXECUTED
  10b0cc:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
    if ( fp_area )                                                    
  10b0cf:	85 f6                	test   %esi,%esi                      
  10b0d1:	74 0c                	je     10b0df <_Thread_Initialize+0x1bb><== ALWAYS TAKEN
      (void) _Workspace_Free( fp_area );                              
  10b0d3:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10b0d6:	56                   	push   %esi                           <== NOT EXECUTED
  10b0d7:	e8 38 0d 00 00       	call   10be14 <_Workspace_Free>       <== NOT EXECUTED
  10b0dc:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
#endif                                                                
                                                                      
    _Thread_Stack_Free( the_thread );                                 
  10b0df:	83 ec 0c             	sub    $0xc,%esp                      
  10b0e2:	53                   	push   %ebx                           
  10b0e3:	e8 20 07 00 00       	call   10b808 <_Thread_Stack_Free>    
  10b0e8:	31 d2                	xor    %edx,%edx                      
  10b0ea:	83 c4 10             	add    $0x10,%esp                     
    return FALSE;                                                     
  }                                                                   
                                                                      
  return TRUE;                                                        
                                                                      
}                                                                     
  10b0ed:	88 d0                	mov    %dl,%al                        
  10b0ef:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b0f2:	5b                   	pop    %ebx                           
  10b0f3:	5e                   	pop    %esi                           
  10b0f4:	5f                   	pop    %edi                           
  10b0f5:	c9                   	leave                                 
  10b0f6:	c3                   	ret                                   
                                                                      

0010ef70 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) {
  10ef70:	55                   	push   %ebp                           
  10ef71:	89 e5                	mov    %esp,%ebp                      
  10ef73:	53                   	push   %ebx                           
  10ef74:	83 ec 10             	sub    $0x10,%esp                     
  10ef77:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  the_thread->resource_count   = 0;                                   
  10ef7a:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)                
  the_thread->suspend_count    = 0;                                   
  10ef81:	c7 43 70 00 00 00 00 	movl   $0x0,0x70(%ebx)                
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
  10ef88:	8a 83 ac 00 00 00    	mov    0xac(%ebx),%al                 
  10ef8e:	88 43 76             	mov    %al,0x76(%ebx)                 
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
  10ef91:	8b 83 b0 00 00 00    	mov    0xb0(%ebx),%eax                
  10ef97:	89 43 7c             	mov    %eax,0x7c(%ebx)                
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
  10ef9a:	8b 83 b4 00 00 00    	mov    0xb4(%ebx),%eax                
  10efa0:	89 83 80 00 00 00    	mov    %eax,0x80(%ebx)                
                                                                      
  the_thread->Start.pointer_argument = pointer_argument;              
  10efa6:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10efa9:	89 83 a4 00 00 00    	mov    %eax,0xa4(%ebx)                
  the_thread->Start.numeric_argument = numeric_argument;              
  10efaf:	8b 45 10             	mov    0x10(%ebp),%eax                
  10efb2:	89 83 a8 00 00 00    	mov    %eax,0xa8(%ebx)                
                                                                      
  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {            
  10efb8:	53                   	push   %ebx                           
  10efb9:	e8 9e ce ff ff       	call   10be5c <_Thread_queue_Extract_with_proxy>
  10efbe:	83 c4 10             	add    $0x10,%esp                     
  10efc1:	84 c0                	test   %al,%al                        
  10efc3:	75 15                	jne    10efda <_Thread_Reset+0x6a>    <== NEVER TAKEN
                                                                      
    if ( _Watchdog_Is_active( &the_thread->Timer ) )                  
  10efc5:	83 7b 50 02          	cmpl   $0x2,0x50(%ebx)                
  10efc9:	75 0f                	jne    10efda <_Thread_Reset+0x6a>    <== ALWAYS TAKEN
      (void) _Watchdog_Remove( &the_thread->Timer );                  
  10efcb:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10efce:	8d 43 48             	lea    0x48(%ebx),%eax                <== NOT EXECUTED
  10efd1:	50                   	push   %eax                           <== NOT EXECUTED
  10efd2:	e8 c5 d7 ff ff       	call   10c79c <_Watchdog_Remove>      <== NOT EXECUTED
  10efd7:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
  10efda:	8b 83 bc 00 00 00    	mov    0xbc(%ebx),%eax                
  10efe0:	39 43 14             	cmp    %eax,0x14(%ebx)                
  10efe3:	74 12                	je     10eff7 <_Thread_Reset+0x87>    
    the_thread->real_priority = the_thread->Start.initial_priority;   
  10efe5:	89 43 18             	mov    %eax,0x18(%ebx)                
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
  10efe8:	89 45 0c             	mov    %eax,0xc(%ebp)                 
  10efeb:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
  }                                                                   
}                                                                     
  10efee:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10eff1:	c9                   	leave                                 
      (void) _Watchdog_Remove( &the_thread->Timer );                  
  }                                                                   
                                                                      
  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
    the_thread->real_priority = the_thread->Start.initial_priority;   
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
  10eff2:	e9 41 d0 ff ff       	jmp    10c038 <_Thread_Set_priority>  
  }                                                                   
}                                                                     
  10eff7:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10effa:	c9                   	leave                                 
  10effb:	c3                   	ret                                   
                                                                      

0010e498 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) {
  10e498:	55                   	push   %ebp                           
  10e499:	89 e5                	mov    %esp,%ebp                      
  10e49b:	56                   	push   %esi                           
  10e49c:	53                   	push   %ebx                           
  ISR_Level       level;                                              
  Thread_Control *executing;                                          
  Chain_Control  *ready;                                              
                                                                      
  executing = _Thread_Executing;                                      
  10e49d:	8b 0d 58 d8 11 00    	mov    0x11d858,%ecx                  
  ready     = executing->ready;                                       
  10e4a3:	8b 99 8c 00 00 00    	mov    0x8c(%ecx),%ebx                
  _ISR_Disable( level );                                              
  10e4a9:	9c                   	pushf                                 
  10e4aa:	fa                   	cli                                   
  10e4ab:	5e                   	pop    %esi                           
    if ( _Chain_Has_only_one_node( ready ) ) {                        
  10e4ac:	8b 03                	mov    (%ebx),%eax                    
  10e4ae:	3b 43 08             	cmp    0x8(%ebx),%eax                 
  10e4b1:	75 04                	jne    10e4b7 <_Thread_Reset_timeslice+0x1f>
      _ISR_Enable( level );                                           
  10e4b3:	56                   	push   %esi                           
  10e4b4:	9d                   	popf                                  
  10e4b5:	eb 35                	jmp    10e4ec <_Thread_Reset_timeslice+0x54>
  10e4b7:	8b 11                	mov    (%ecx),%edx                    
  10e4b9:	8b 41 04             	mov    0x4(%ecx),%eax                 
  10e4bc:	89 42 04             	mov    %eax,0x4(%edx)                 
  10e4bf:	89 10                	mov    %edx,(%eax)                    
  10e4c1:	8d 43 04             	lea    0x4(%ebx),%eax                 
  10e4c4:	89 01                	mov    %eax,(%ecx)                    
  10e4c6:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10e4c9:	89 4b 08             	mov    %ecx,0x8(%ebx)                 
  10e4cc:	89 08                	mov    %ecx,(%eax)                    
  10e4ce:	89 41 04             	mov    %eax,0x4(%ecx)                 
      return;                                                         
    }                                                                 
    _Chain_Extract_unprotected( &executing->Object.Node );            
    _Chain_Append_unprotected( ready, &executing->Object.Node );      
                                                                      
  _ISR_Flash( level );                                                
  10e4d1:	56                   	push   %esi                           
  10e4d2:	9d                   	popf                                  
  10e4d3:	fa                   	cli                                   
                                                                      
    if ( _Thread_Is_heir( executing ) )                               
  10e4d4:	3b 0d 24 d8 11 00    	cmp    0x11d824,%ecx                  
  10e4da:	75 07                	jne    10e4e3 <_Thread_Reset_timeslice+0x4b><== NEVER TAKEN
      _Thread_Heir = (Thread_Control *) ready->first;                 
  10e4dc:	8b 03                	mov    (%ebx),%eax                    
  10e4de:	a3 24 d8 11 00       	mov    %eax,0x11d824                  
                                                                      
    _Context_Switch_necessary = TRUE;                                 
  10e4e3:	c6 05 68 d8 11 00 01 	movb   $0x1,0x11d868                  
                                                                      
  _ISR_Enable( level );                                               
  10e4ea:	56                   	push   %esi                           
  10e4eb:	9d                   	popf                                  
}                                                                     
  10e4ec:	5b                   	pop    %ebx                           
  10e4ed:	5e                   	pop    %esi                           
  10e4ee:	c9                   	leave                                 
  10e4ef:	c3                   	ret                                   
                                                                      

0010bfb0 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) {
  10bfb0:	55                   	push   %ebp                           
  10bfb1:	89 e5                	mov    %esp,%ebp                      
  10bfb3:	53                   	push   %ebx                           
  10bfb4:	83 ec 04             	sub    $0x4,%esp                      
  10bfb7:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  if ( !_States_Is_dormant( the_thread->current_state ) ) {           
  10bfba:	31 c0                	xor    %eax,%eax                      
  10bfbc:	f6 43 10 01          	testb  $0x1,0x10(%ebx)                
  10bfc0:	75 70                	jne    10c032 <_Thread_Restart+0x82>  
                                                                      
    _Thread_Set_transient( the_thread );                              
  10bfc2:	83 ec 0c             	sub    $0xc,%esp                      
  10bfc5:	53                   	push   %ebx                           
  10bfc6:	e8 a1 01 00 00       	call   10c16c <_Thread_Set_transient> 
                                                                      
    _Thread_Reset( the_thread, pointer_argument, numeric_argument );  
  10bfcb:	83 c4 0c             	add    $0xc,%esp                      
  10bfce:	ff 75 10             	pushl  0x10(%ebp)                     
  10bfd1:	ff 75 0c             	pushl  0xc(%ebp)                      
  10bfd4:	53                   	push   %ebx                           
  10bfd5:	e8 96 2f 00 00       	call   10ef70 <_Thread_Reset>         
                                                                      
    _Thread_Load_environment( the_thread );                           
  10bfda:	89 1c 24             	mov    %ebx,(%esp)                    
  10bfdd:	e8 8a 2c 00 00       	call   10ec6c <_Thread_Load_environment>
                                                                      
    _Thread_Ready( the_thread );                                      
  10bfe2:	89 1c 24             	mov    %ebx,(%esp)                    
  10bfe5:	e8 e6 2e 00 00       	call   10eed0 <_Thread_Ready>         
                                                                      
    _User_extensions_Thread_restart( the_thread );                    
  10bfea:	89 1c 24             	mov    %ebx,(%esp)                    
  10bfed:	e8 ee 05 00 00       	call   10c5e0 <_User_extensions_Thread_restart>
                                                                      
    if ( _Thread_Is_executing ( the_thread ) )                        
  10bff2:	83 c4 10             	add    $0x10,%esp                     
  10bff5:	b0 01                	mov    $0x1,%al                       
  10bff7:	3b 1d c4 0c 12 00    	cmp    0x120cc4,%ebx                  
  10bffd:	75 33                	jne    10c032 <_Thread_Restart+0x82>  
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @param[in] alignment the required alignment                       
  10bfff:	83 bb ec 00 00 00 00 	cmpl   $0x0,0xec(%ebx)                
  10c006:	74 12                	je     10c01a <_Thread_Restart+0x6a>  
 *  @return NULL if unsuccessful and a pointer to the block if successful
  10c008:	83 ec 0c             	sub    $0xc,%esp                      
  10c00b:	8d 83 ec 00 00 00    	lea    0xec(%ebx),%eax                
  10c011:	50                   	push   %eax                           
  10c012:	e8 47 09 00 00       	call   10c95e <_CPU_Context_restore_fp>
  10c017:	83 c4 10             	add    $0x10,%esp                     
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  10c01a:	83 ec 0c             	sub    $0xc,%esp                      
  10c01d:	a1 c4 0c 12 00       	mov    0x120cc4,%eax                  
  10c022:	05 d4 00 00 00       	add    $0xd4,%eax                     
  10c027:	50                   	push   %eax                           
  10c028:	e8 20 09 00 00       	call   10c94d <_CPU_Context_restore>  
  10c02d:	b0 01                	mov    $0x1,%al                       <== NOT EXECUTED
  10c02f:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
    return TRUE;                                                      
  }                                                                   
                                                                      
  return FALSE;                                                       
}                                                                     
  10c032:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10c035:	c9                   	leave                                 
  10c036:	c3                   	ret                                   
                                                                      

0010c9c0 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) {
  10c9c0:	55                   	push   %ebp                           
  10c9c1:	89 e5                	mov    %esp,%ebp                      
  10c9c3:	53                   	push   %ebx                           
  10c9c4:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10c9c7:	8a 45 0c             	mov    0xc(%ebp),%al                  
                                                                      
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
  10c9ca:	9c                   	pushf                                 
  10c9cb:	fa                   	cli                                   
  10c9cc:	5b                   	pop    %ebx                           
                                                                      
  if ( force == TRUE )                                                
  10c9cd:	84 c0                	test   %al,%al                        
  10c9cf:	74 09                	je     10c9da <_Thread_Resume+0x1a>   <== NEVER TAKEN
    the_thread->suspend_count = 0;                                    
  10c9d1:	c7 41 70 00 00 00 00 	movl   $0x0,0x70(%ecx)                
  10c9d8:	eb 03                	jmp    10c9dd <_Thread_Resume+0x1d>   
  else                                                                
    the_thread->suspend_count--;                                      
  10c9da:	ff 49 70             	decl   0x70(%ecx)                     <== NOT EXECUTED
                                                                      
  if ( the_thread->suspend_count > 0 ) {                              
  10c9dd:	83 79 70 00          	cmpl   $0x0,0x70(%ecx)                
  10c9e1:	74 04                	je     10c9e7 <_Thread_Resume+0x27>   <== ALWAYS TAKEN
    _ISR_Enable( level );                                             
  10c9e3:	53                   	push   %ebx                           <== NOT EXECUTED
  10c9e4:	9d                   	popf                                  <== NOT EXECUTED
  10c9e5:	eb 77                	jmp    10ca5e <_Thread_Resume+0x9e>   <== NOT EXECUTED
    return;                                                           
  }                                                                   
                                                                      
  current_state = the_thread->current_state;                          
  10c9e7:	8b 41 10             	mov    0x10(%ecx),%eax                
  if ( current_state & STATES_SUSPENDED ) {                           
  10c9ea:	a8 02                	test   $0x2,%al                       
  10c9ec:	74 6e                	je     10ca5c <_Thread_Resume+0x9c>   <== NEVER TAKEN
 *  @param[in] page_size is the size in bytes of the allocation unit  
 *                                                                    
 *  @return This method returns the maximum memory available.  If     
 *          unsuccessful, 0 will be returned.                         
 */                                                                   
static inline uint32_t _Protected_heap_Initialize(                    
  10c9ee:	83 e0 fd             	and    $0xfffffffd,%eax               
    current_state =                                                   
  10c9f1:	89 41 10             	mov    %eax,0x10(%ecx)                
    the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
                                                                      
    if ( _States_Is_ready( current_state ) ) {                        
  10c9f4:	85 c0                	test   %eax,%eax                      
  10c9f6:	75 64                	jne    10ca5c <_Thread_Resume+0x9c>   <== NEVER TAKEN
 *  otherwise.                                                        
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the user block
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
  10c9f8:	8b 91 90 00 00 00    	mov    0x90(%ecx),%edx                
  10c9fe:	66 8b 81 96 00 00 00 	mov    0x96(%ecx),%ax                 
  10ca05:	66 09 02             	or     %ax,(%edx)                     
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
  10ca08:	66 a1 48 93 12 00    	mov    0x129348,%ax                   
  10ca0e:	0b 81 94 00 00 00    	or     0x94(%ecx),%eax                
  10ca14:	66 a3 48 93 12 00    	mov    %ax,0x129348                   
                                                                      
      _Priority_Add_to_bit_map( &the_thread->Priority_map );          
                                                                      
      _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
  10ca1a:	8b 81 8c 00 00 00    	mov    0x8c(%ecx),%eax                
  10ca20:	8d 50 04             	lea    0x4(%eax),%edx                 
  10ca23:	89 11                	mov    %edx,(%ecx)                    
  10ca25:	8b 50 08             	mov    0x8(%eax),%edx                 
  10ca28:	89 48 08             	mov    %ecx,0x8(%eax)                 
  10ca2b:	89 0a                	mov    %ecx,(%edx)                    
  10ca2d:	89 51 04             	mov    %edx,0x4(%ecx)                 
                                                                      
      _ISR_Flash( level );                                            
  10ca30:	53                   	push   %ebx                           
  10ca31:	9d                   	popf                                  
  10ca32:	fa                   	cli                                   
                                                                      
      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
  10ca33:	8b 51 14             	mov    0x14(%ecx),%edx                
  10ca36:	a1 20 93 12 00       	mov    0x129320,%eax                  
  10ca3b:	3b 50 14             	cmp    0x14(%eax),%edx                
  10ca3e:	73 1c                	jae    10ca5c <_Thread_Resume+0x9c>   
        _Thread_Heir = the_thread;                                    
  10ca40:	89 0d 20 93 12 00    	mov    %ecx,0x129320                  
        if ( _Thread_Executing->is_preemptible ||                     
  10ca46:	a1 54 93 12 00       	mov    0x129354,%eax                  
  10ca4b:	80 78 76 00          	cmpb   $0x0,0x76(%eax)                
  10ca4f:	75 04                	jne    10ca55 <_Thread_Resume+0x95>   
  10ca51:	85 d2                	test   %edx,%edx                      
  10ca53:	75 07                	jne    10ca5c <_Thread_Resume+0x9c>   <== ALWAYS TAKEN
             the_thread->current_priority == 0 )                      
          _Context_Switch_necessary = TRUE;                           
  10ca55:	c6 05 64 93 12 00 01 	movb   $0x1,0x129364                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
  10ca5c:	53                   	push   %ebx                           
  10ca5d:	9d                   	popf                                  
}                                                                     
  10ca5e:	5b                   	pop    %ebx                           
  10ca5f:	c9                   	leave                                 
  10ca60:	c3                   	ret                                   
                                                                      

0010b7b8 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) {
  10b7b8:	55                   	push   %ebp                           
  10b7b9:	89 e5                	mov    %esp,%ebp                      
  10b7bb:	53                   	push   %ebx                           
  10b7bc:	83 ec 04             	sub    $0x4,%esp                      
  10b7bf:	a1 80 93 11 00       	mov    0x119380,%eax                  
  10b7c4:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10b7c7:	39 c3                	cmp    %eax,%ebx                      
  10b7c9:	73 02                	jae    10b7cd <_Thread_Stack_Allocate+0x15>
  10b7cb:	89 c3                	mov    %eax,%ebx                      
   * Call ONLY the CPU table stack allocate hook, _or_ the            
   * the RTEMS workspace allocate.  This is so the stack free         
   * routine can call the correct deallocation routine.               
   */                                                                 
                                                                      
  if ( _Configuration_Table->stack_allocate_hook ) {                  
  10b7cd:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10b7d2:	8b 40 20             	mov    0x20(%eax),%eax                
  10b7d5:	85 c0                	test   %eax,%eax                      
  10b7d7:	74 08                	je     10b7e1 <_Thread_Stack_Allocate+0x29><== ALWAYS TAKEN
    stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
  10b7d9:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10b7dc:	53                   	push   %ebx                           <== NOT EXECUTED
  10b7dd:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10b7df:	eb 09                	jmp    10b7ea <_Thread_Stack_Allocate+0x32><== NOT EXECUTED
     *  get and keep the stack adjust factor, the stack alignment, and
     *  the context initialization sequence in sync.                  
     */                                                               
                                                                      
    the_stack_size = _Stack_Adjust_size( the_stack_size );            
    stack_addr = _Workspace_Allocate( the_stack_size );               
  10b7e1:	83 ec 0c             	sub    $0xc,%esp                      
  10b7e4:	53                   	push   %ebx                           
  10b7e5:	e8 3f 06 00 00       	call   10be29 <_Workspace_Allocate>   
  10b7ea:	89 c1                	mov    %eax,%ecx                      
  10b7ec:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  if ( !stack_addr )                                                  
  10b7ef:	31 c0                	xor    %eax,%eax                      
  10b7f1:	85 c9                	test   %ecx,%ecx                      
  10b7f3:	0f 95 c0             	setne  %al                            
  10b7f6:	f7 d8                	neg    %eax                           
  10b7f8:	21 d8                	and    %ebx,%eax                      
    the_stack_size = 0;                                               
                                                                      
  the_thread->Start.stack = stack_addr;                               
  10b7fa:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b7fd:	89 8a d0 00 00 00    	mov    %ecx,0xd0(%edx)                
                                                                      
  return the_stack_size;                                              
}                                                                     
  10b803:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b806:	c9                   	leave                                 
  10b807:	c3                   	ret                                   
                                                                      

0010b808 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) {
  10b808:	55                   	push   %ebp                           
  10b809:	89 e5                	mov    %esp,%ebp                      
  10b80b:	8b 55 08             	mov    0x8(%ebp),%edx                 
    /*                                                                
     *  If the API provided the stack space, then don't free it.      
     */                                                               
                                                                      
    if ( !the_thread->Start.core_allocated_stack )                    
  10b80e:	80 ba c0 00 00 00 00 	cmpb   $0x0,0xc0(%edx)                
  10b815:	74 21                	je     10b838 <_Thread_Stack_Free+0x30><== NEVER TAKEN
     * Call ONLY the CPU table stack free hook, or the                
     * the RTEMS workspace free.  This is so the free                 
     * routine properly matches the allocation of the stack.          
     */                                                               
                                                                      
    if ( _Configuration_Table->stack_free_hook )                      
  10b817:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10b81c:	8b 48 24             	mov    0x24(%eax),%ecx                
  10b81f:	85 c9                	test   %ecx,%ecx                      
  10b821:	8b 82 c8 00 00 00    	mov    0xc8(%edx),%eax                
  10b827:	74 06                	je     10b82f <_Thread_Stack_Free+0x27><== ALWAYS TAKEN
      (*_Configuration_Table->stack_free_hook)(                       
  10b829:	89 45 08             	mov    %eax,0x8(%ebp)                 <== NOT EXECUTED
        the_thread->Start.Initial_stack.area                          
      );                                                              
    else                                                              
        _Workspace_Free( the_thread->Start.Initial_stack.area );      
}                                                                     
  10b82c:	c9                   	leave                                 <== NOT EXECUTED
     * the RTEMS workspace free.  This is so the free                 
     * routine properly matches the allocation of the stack.          
     */                                                               
                                                                      
    if ( _Configuration_Table->stack_free_hook )                      
      (*_Configuration_Table->stack_free_hook)(                       
  10b82d:	ff e1                	jmp    *%ecx                          <== NOT EXECUTED
        the_thread->Start.Initial_stack.area                          
      );                                                              
    else                                                              
        _Workspace_Free( the_thread->Start.Initial_stack.area );      
  10b82f:	89 45 08             	mov    %eax,0x8(%ebp)                 
}                                                                     
  10b832:	c9                   	leave                                 
    if ( _Configuration_Table->stack_free_hook )                      
      (*_Configuration_Table->stack_free_hook)(                       
        the_thread->Start.Initial_stack.area                          
      );                                                              
    else                                                              
        _Workspace_Free( the_thread->Start.Initial_stack.area );      
  10b833:	e9 dc 05 00 00       	jmp    10be14 <_Workspace_Free>       
}                                                                     
  10b838:	c9                   	leave                                 <== NOT EXECUTED
  10b839:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010b8f0 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) {
  10b8f0:	55                   	push   %ebp                           
  10b8f1:	89 e5                	mov    %esp,%ebp                      
  10b8f3:	53                   	push   %ebx                           
  10b8f4:	83 ec 04             	sub    $0x4,%esp                      
  Thread_Control *executing;                                          
                                                                      
  executing = _Thread_Executing;                                      
  10b8f7:	8b 1d 58 d8 11 00    	mov    0x11d858,%ebx                  
  /*                                                                  
   *  If the thread is not preemptible or is not ready, then          
   *  just return.                                                    
   */                                                                 
                                                                      
  if ( !executing->is_preemptible )                                   
  10b8fd:	80 7b 76 00          	cmpb   $0x0,0x76(%ebx)                
  10b901:	74 4c                	je     10b94f <_Thread_Tickle_timeslice+0x5f>
    return;                                                           
                                                                      
  if ( !_States_Is_ready( executing->current_state ) )                
  10b903:	83 7b 10 00          	cmpl   $0x0,0x10(%ebx)                
  10b907:	75 46                	jne    10b94f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
                                                                      
  /*                                                                  
   *  The cpu budget algorithm determines what happens next.          
   */                                                                 
                                                                      
  switch ( executing->budget_algorithm ) {                            
  10b909:	8b 43 7c             	mov    0x7c(%ebx),%eax                
  10b90c:	83 f8 01             	cmp    $0x1,%eax                      
  10b90f:	72 3e                	jb     10b94f <_Thread_Tickle_timeslice+0x5f>
  10b911:	83 f8 02             	cmp    $0x2,%eax                      
  10b914:	76 07                	jbe    10b91d <_Thread_Tickle_timeslice+0x2d>
  10b916:	83 f8 03             	cmp    $0x3,%eax                      
  10b919:	75 34                	jne    10b94f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
  10b91b:	eb 1a                	jmp    10b937 <_Thread_Tickle_timeslice+0x47>
    case THREAD_CPU_BUDGET_ALGORITHM_NONE:                            
      break;                                                          
                                                                      
    case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:                 
    case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:               
      if ( (int)(--executing->cpu_time_budget) <= 0 ) {               
  10b91d:	8b 43 78             	mov    0x78(%ebx),%eax                
  10b920:	48                   	dec    %eax                           
  10b921:	89 43 78             	mov    %eax,0x78(%ebx)                
  10b924:	85 c0                	test   %eax,%eax                      
  10b926:	7f 27                	jg     10b94f <_Thread_Tickle_timeslice+0x5f>
        _Thread_Reset_timeslice();                                    
  10b928:	e8 6b 2b 00 00       	call   10e498 <_Thread_Reset_timeslice>
        executing->cpu_time_budget = _Thread_Ticks_per_timeslice;     
  10b92d:	a1 64 d7 11 00       	mov    0x11d764,%eax                  
  10b932:	89 43 78             	mov    %eax,0x78(%ebx)                
  10b935:	eb 18                	jmp    10b94f <_Thread_Tickle_timeslice+0x5f>
      }                                                               
      break;                                                          
                                                                      
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                         
      if ( --executing->cpu_time_budget == 0 )                        
  10b937:	8b 43 78             	mov    0x78(%ebx),%eax                
  10b93a:	48                   	dec    %eax                           
  10b93b:	89 43 78             	mov    %eax,0x78(%ebx)                
  10b93e:	85 c0                	test   %eax,%eax                      
  10b940:	75 0d                	jne    10b94f <_Thread_Tickle_timeslice+0x5f>
        (*executing->budget_callout)( executing );                    
  10b942:	83 ec 0c             	sub    $0xc,%esp                      
  10b945:	53                   	push   %ebx                           
  10b946:	ff 93 80 00 00 00    	call   *0x80(%ebx)                    
  10b94c:	83 c4 10             	add    $0x10,%esp                     
      break;                                                          
  }                                                                   
}                                                                     
  10b94f:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b952:	c9                   	leave                                 
  10b953:	c3                   	ret                                   
                                                                      

0010b954 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) {
  10b954:	55                   	push   %ebp                           
  10b955:	89 e5                	mov    %esp,%ebp                      
  10b957:	56                   	push   %esi                           
  10b958:	53                   	push   %ebx                           
  ISR_Level       level;                                              
  Thread_Control *executing;                                          
  Chain_Control  *ready;                                              
                                                                      
  executing = _Thread_Executing;                                      
  10b959:	8b 0d 58 d8 11 00    	mov    0x11d858,%ecx                  
  ready     = executing->ready;                                       
  10b95f:	8b 99 8c 00 00 00    	mov    0x8c(%ecx),%ebx                
  _ISR_Disable( level );                                              
  10b965:	9c                   	pushf                                 
  10b966:	fa                   	cli                                   
  10b967:	5e                   	pop    %esi                           
    if ( !_Chain_Has_only_one_node( ready ) ) {                       
  10b968:	8b 03                	mov    (%ebx),%eax                    
  10b96a:	3b 43 08             	cmp    0x8(%ebx),%eax                 
  10b96d:	74 2e                	je     10b99d <_Thread_Yield_processor+0x49>
  10b96f:	8b 11                	mov    (%ecx),%edx                    
  10b971:	8b 41 04             	mov    0x4(%ecx),%eax                 
  10b974:	89 42 04             	mov    %eax,0x4(%edx)                 
  10b977:	89 10                	mov    %edx,(%eax)                    
  10b979:	8d 43 04             	lea    0x4(%ebx),%eax                 
  10b97c:	89 01                	mov    %eax,(%ecx)                    
  10b97e:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10b981:	89 4b 08             	mov    %ecx,0x8(%ebx)                 
  10b984:	89 08                	mov    %ecx,(%eax)                    
  10b986:	89 41 04             	mov    %eax,0x4(%ecx)                 
      _Chain_Extract_unprotected( &executing->Object.Node );          
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
  10b989:	56                   	push   %esi                           
  10b98a:	9d                   	popf                                  
  10b98b:	fa                   	cli                                   
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
  10b98c:	3b 0d 24 d8 11 00    	cmp    0x11d824,%ecx                  
  10b992:	75 11                	jne    10b9a5 <_Thread_Yield_processor+0x51><== NEVER TAKEN
        _Thread_Heir = (Thread_Control *) ready->first;               
  10b994:	8b 03                	mov    (%ebx),%eax                    
  10b996:	a3 24 d8 11 00       	mov    %eax,0x11d824                  
  10b99b:	eb 08                	jmp    10b9a5 <_Thread_Yield_processor+0x51>
      _Context_Switch_necessary = TRUE;                               
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
  10b99d:	3b 0d 24 d8 11 00    	cmp    0x11d824,%ecx                  
  10b9a3:	74 07                	je     10b9ac <_Thread_Yield_processor+0x58><== ALWAYS TAKEN
      _Context_Switch_necessary = TRUE;                               
  10b9a5:	c6 05 68 d8 11 00 01 	movb   $0x1,0x11d868                  
                                                                      
  _ISR_Enable( level );                                               
  10b9ac:	56                   	push   %esi                           
  10b9ad:	9d                   	popf                                  
}                                                                     
  10b9ae:	5b                   	pop    %ebx                           
  10b9af:	5e                   	pop    %esi                           
  10b9b0:	c9                   	leave                                 
  10b9b1:	c3                   	ret                                   
                                                                      

0010b368 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) {
  10b368:	55                   	push   %ebp                           
  10b369:	89 e5                	mov    %esp,%ebp                      
  10b36b:	57                   	push   %edi                           
  10b36c:	56                   	push   %esi                           
  10b36d:	53                   	push   %ebx                           
  10b36e:	83 ec 18             	sub    $0x18,%esp                     
  10b371:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  10b374:	8d 41 3c             	lea    0x3c(%ecx),%eax                
  10b377:	89 41 38             	mov    %eax,0x38(%ecx)                
  10b37a:	c7 41 3c 00 00 00 00 	movl   $0x0,0x3c(%ecx)                
  10b381:	8d 41 38             	lea    0x38(%ecx),%eax                
  10b384:	89 41 40             	mov    %eax,0x40(%ecx)                
  Priority_Control     priority;                                      
  States_Control       block_state;                                   
                                                                      
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
  10b387:	8b 79 14             	mov    0x14(%ecx),%edi                
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
  10b38a:	89 f8                	mov    %edi,%eax                      
  10b38c:	c1 e8 06             	shr    $0x6,%eax                      
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
  10b38f:	6b c0 0c             	imul   $0xc,%eax,%eax                 
  10b392:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10b395:	01 c3                	add    %eax,%ebx                      
  block_state  = the_thread_queue->state;                             
  10b397:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b39a:	8b 52 38             	mov    0x38(%edx),%edx                
  10b39d:	89 55 e8             	mov    %edx,-0x18(%ebp)               
                                                                      
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
  10b3a0:	f7 c7 20 00 00 00    	test   $0x20,%edi                     
  10b3a6:	75 77                	jne    10b41f <_Thread_queue_Enqueue_priority+0xb7>
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  10b3a8:	83 c3 04             	add    $0x4,%ebx                      
  10b3ab:	89 5d ec             	mov    %ebx,-0x14(%ebp)               
    goto restart_reverse_search;                                      
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->first;                   
  10b3ae:	89 45 dc             	mov    %eax,-0x24(%ebp)               
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
    goto restart_reverse_search;                                      
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  10b3b1:	9c                   	pushf                                 
  10b3b2:	fa                   	cli                                   
  10b3b3:	5e                   	pop    %esi                           
  search_thread = (Thread_Control *) header->first;                   
  10b3b4:	8b 45 dc             	mov    -0x24(%ebp),%eax               
  10b3b7:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10b3ba:	8b 14 18             	mov    (%eax,%ebx,1),%edx             
  10b3bd:	c7 45 e0 ff ff ff ff 	movl   $0xffffffff,-0x20(%ebp)        
  10b3c4:	eb 1b                	jmp    10b3e1 <_Thread_queue_Enqueue_priority+0x79>
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
    search_priority = search_thread->current_priority;                
  10b3c6:	8b 5a 14             	mov    0x14(%edx),%ebx                
  10b3c9:	89 5d e0             	mov    %ebx,-0x20(%ebp)               
    if ( priority <= search_priority )                                
  10b3cc:	39 df                	cmp    %ebx,%edi                      
  10b3ce:	76 16                	jbe    10b3e6 <_Thread_queue_Enqueue_priority+0x7e>
      break;                                                          
    search_priority = search_thread->current_priority;                
    if ( priority <= search_priority )                                
      break;                                                          
#endif                                                                
    _ISR_Flash( level );                                              
  10b3d0:	56                   	push   %esi                           
  10b3d1:	9d                   	popf                                  
  10b3d2:	fa                   	cli                                   
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
  10b3d3:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10b3d6:	85 42 10             	test   %eax,0x10(%edx)                
  10b3d9:	75 04                	jne    10b3df <_Thread_queue_Enqueue_priority+0x77><== ALWAYS TAKEN
      _ISR_Enable( level );                                           
  10b3db:	56                   	push   %esi                           <== NOT EXECUTED
  10b3dc:	9d                   	popf                                  <== NOT EXECUTED
  10b3dd:	eb d2                	jmp    10b3b1 <_Thread_queue_Enqueue_priority+0x49><== NOT EXECUTED
      goto restart_forward_search;                                    
    }                                                                 
    search_thread =                                                   
  10b3df:	8b 12                	mov    (%edx),%edx                    
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->first;                   
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
  10b3e1:	3b 55 ec             	cmp    -0x14(%ebp),%edx               
  10b3e4:	75 e0                	jne    10b3c6 <_Thread_queue_Enqueue_priority+0x5e>
  10b3e6:	89 55 f0             	mov    %edx,-0x10(%ebp)               
  10b3e9:	89 f3                	mov    %esi,%ebx                      
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
  10b3eb:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10b3ee:	83 78 30 01          	cmpl   $0x1,0x30(%eax)                
  10b3f2:	0f 85 b4 00 00 00    	jne    10b4ac <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
  10b3f8:	c7 40 30 00 00 00 00 	movl   $0x0,0x30(%eax)                
                                                                      
  if ( priority == search_priority )                                  
  10b3ff:	3b 7d e0             	cmp    -0x20(%ebp),%edi               
  10b402:	0f 84 87 00 00 00    	je     10b48f <_Thread_queue_Enqueue_priority+0x127>
    goto equal_priority;                                              
                                                                      
  search_node   = (Chain_Node *) search_thread;                       
  previous_node = search_node->previous;                              
  10b408:	8b 42 04             	mov    0x4(%edx),%eax                 
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
  10b40b:	89 11                	mov    %edx,(%ecx)                    
  the_node->previous     = previous_node;                             
  10b40d:	89 41 04             	mov    %eax,0x4(%ecx)                 
  previous_node->next    = the_node;                                  
  10b410:	89 08                	mov    %ecx,(%eax)                    
  search_node->previous  = the_node;                                  
  10b412:	89 4a 04             	mov    %ecx,0x4(%edx)                 
  the_thread->Wait.queue = the_thread_queue;                          
  10b415:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b418:	89 51 44             	mov    %edx,0x44(%ecx)                
  _ISR_Enable( level );                                               
  10b41b:	56                   	push   %esi                           
  10b41c:	9d                   	popf                                  
  10b41d:	eb 69                	jmp    10b488 <_Thread_queue_Enqueue_priority+0x120>
                                                                      
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->last;                    
  10b41f:	8d 43 08             	lea    0x8(%ebx),%eax                 
  10b422:	89 45 e4             	mov    %eax,-0x1c(%ebp)               
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
  10b425:	0f b6 05 84 93 11 00 	movzbl 0x119384,%eax                  
  10b42c:	40                   	inc    %eax                           
  10b42d:	89 45 e0             	mov    %eax,-0x20(%ebp)               
                                                                      
  _ISR_Disable( level );                                              
  10b430:	9c                   	pushf                                 
  10b431:	fa                   	cli                                   
  10b432:	5e                   	pop    %esi                           
  search_thread = (Thread_Control *) header->last;                    
  10b433:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  10b436:	8b 10                	mov    (%eax),%edx                    
  10b438:	eb 1c                	jmp    10b456 <_Thread_queue_Enqueue_priority+0xee>
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
    search_priority = search_thread->current_priority;                
  10b43a:	8b 42 14             	mov    0x14(%edx),%eax                
  10b43d:	89 45 e0             	mov    %eax,-0x20(%ebp)               
    if ( priority >= search_priority )                                
  10b440:	39 c7                	cmp    %eax,%edi                      
  10b442:	73 16                	jae    10b45a <_Thread_queue_Enqueue_priority+0xf2>
      break;                                                          
    search_priority = search_thread->current_priority;                
    if ( priority >= search_priority )                                
      break;                                                          
#endif                                                                
    _ISR_Flash( level );                                              
  10b444:	56                   	push   %esi                           
  10b445:	9d                   	popf                                  
  10b446:	fa                   	cli                                   
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
  10b447:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10b44a:	85 42 10             	test   %eax,0x10(%edx)                
  10b44d:	75 04                	jne    10b453 <_Thread_queue_Enqueue_priority+0xeb><== ALWAYS TAKEN
      _ISR_Enable( level );                                           
  10b44f:	56                   	push   %esi                           <== NOT EXECUTED
  10b450:	9d                   	popf                                  <== NOT EXECUTED
  10b451:	eb d2                	jmp    10b425 <_Thread_queue_Enqueue_priority+0xbd><== NOT EXECUTED
      goto restart_reverse_search;                                    
    }                                                                 
    search_thread = (Thread_Control *)                                
  10b453:	8b 52 04             	mov    0x4(%edx),%edx                 
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->last;                    
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
  10b456:	39 da                	cmp    %ebx,%edx                      
  10b458:	75 e0                	jne    10b43a <_Thread_queue_Enqueue_priority+0xd2>
  10b45a:	89 55 f0             	mov    %edx,-0x10(%ebp)               
  10b45d:	89 f3                	mov    %esi,%ebx                      
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
  10b45f:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10b462:	83 78 30 01          	cmpl   $0x1,0x30(%eax)                
  10b466:	75 44                	jne    10b4ac <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
  10b468:	c7 40 30 00 00 00 00 	movl   $0x0,0x30(%eax)                
                                                                      
  if ( priority == search_priority )                                  
  10b46f:	3b 7d e0             	cmp    -0x20(%ebp),%edi               
  10b472:	74 1b                	je     10b48f <_Thread_queue_Enqueue_priority+0x127>
    goto equal_priority;                                              
                                                                      
  search_node = (Chain_Node *) search_thread;                         
  next_node   = search_node->next;                                    
  10b474:	8b 02                	mov    (%edx),%eax                    
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  10b476:	89 01                	mov    %eax,(%ecx)                    
  the_node->previous      = search_node;                              
  10b478:	89 51 04             	mov    %edx,0x4(%ecx)                 
  search_node->next       = the_node;                                 
  10b47b:	89 0a                	mov    %ecx,(%edx)                    
  next_node->previous    = the_node;                                  
  10b47d:	89 48 04             	mov    %ecx,0x4(%eax)                 
  the_thread->Wait.queue = the_thread_queue;                          
  10b480:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10b483:	89 51 44             	mov    %edx,0x44(%ecx)                
  _ISR_Enable( level );                                               
  10b486:	56                   	push   %esi                           
  10b487:	9d                   	popf                                  
  10b488:	b8 01 00 00 00       	mov    $0x1,%eax                      
  10b48d:	eb 28                	jmp    10b4b7 <_Thread_queue_Enqueue_priority+0x14f>
  10b48f:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10b492:	83 c0 3c             	add    $0x3c,%eax                     
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
equal_priority:               /* add at end of priority group */      
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );        
  previous_node = search_node->previous;                              
  10b495:	8b 50 04             	mov    0x4(%eax),%edx                 
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
  10b498:	89 01                	mov    %eax,(%ecx)                    
  the_node->previous     = previous_node;                             
  10b49a:	89 51 04             	mov    %edx,0x4(%ecx)                 
  previous_node->next    = the_node;                                  
  10b49d:	89 0a                	mov    %ecx,(%edx)                    
  search_node->previous  = the_node;                                  
  10b49f:	89 48 04             	mov    %ecx,0x4(%eax)                 
  the_thread->Wait.queue = the_thread_queue;                          
  10b4a2:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10b4a5:	89 41 44             	mov    %eax,0x44(%ecx)                
  _ISR_Enable( level );                                               
  10b4a8:	53                   	push   %ebx                           
  10b4a9:	9d                   	popf                                  
  10b4aa:	eb dc                	jmp    10b488 <_Thread_queue_Enqueue_priority+0x120>
   *  For example, the blocking thread could have been given          
   *  the mutex by an ISR or timed out.                               
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  *level_p = level;                                                   
  10b4ac:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  10b4af:	89 18                	mov    %ebx,(%eax)                    <== NOT EXECUTED
  return the_thread_queue->sync_state;                                
  10b4b1:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  10b4b4:	8b 42 30             	mov    0x30(%edx),%eax                <== NOT EXECUTED
}                                                                     
  10b4b7:	83 c4 18             	add    $0x18,%esp                     
  10b4ba:	5b                   	pop    %ebx                           
  10b4bb:	5e                   	pop    %esi                           
  10b4bc:	5f                   	pop    %edi                           
  10b4bd:	c9                   	leave                                 
  10b4be:	c3                   	ret                                   
                                                                      

0010f040 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
  10f040:	55                   	push   %ebp                           
  10f041:	89 e5                	mov    %esp,%ebp                      
  10f043:	53                   	push   %ebx                           
  10f044:	83 ec 04             	sub    $0x4,%esp                      
  10f047:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
  10f04a:	9c                   	pushf                                 
  10f04b:	fa                   	cli                                   
  10f04c:	59                   	pop    %ecx                           
                                                                      
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
  10f04d:	f7 43 10 e0 be 03 00 	testl  $0x3bee0,0x10(%ebx)            
  10f054:	75 07                	jne    10f05d <_Thread_queue_Extract_fifo+0x1d><== ALWAYS TAKEN
    _ISR_Enable( level );                                             
  10f056:	51                   	push   %ecx                           <== NOT EXECUTED
  10f057:	9d                   	popf                                  <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
                                                                      
}                                                                     
  10f058:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10f05b:	c9                   	leave                                 <== NOT EXECUTED
  10f05c:	c3                   	ret                                   <== NOT EXECUTED
  10f05d:	8b 13                	mov    (%ebx),%edx                    
  10f05f:	8b 43 04             	mov    0x4(%ebx),%eax                 
  10f062:	89 42 04             	mov    %eax,0x4(%edx)                 
  10f065:	89 10                	mov    %edx,(%eax)                    
    return;                                                           
  }                                                                   
                                                                      
  _Chain_Extract_unprotected( &the_thread->Object.Node );             
                                                                      
  the_thread->Wait.queue = NULL;                                      
  10f067:	c7 43 44 00 00 00 00 	movl   $0x0,0x44(%ebx)                
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
  10f06e:	83 7b 50 02          	cmpl   $0x2,0x50(%ebx)                
  10f072:	74 04                	je     10f078 <_Thread_queue_Extract_fifo+0x38>
    _ISR_Enable( level );                                             
  10f074:	51                   	push   %ecx                           
  10f075:	9d                   	popf                                  
  10f076:	eb 18                	jmp    10f090 <_Thread_queue_Extract_fifo+0x50>
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
  10f078:	c7 43 50 03 00 00 00 	movl   $0x3,0x50(%ebx)                
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
  10f07f:	51                   	push   %ecx                           
  10f080:	9d                   	popf                                  
    (void) _Watchdog_Remove( &the_thread->Timer );                    
  10f081:	83 ec 0c             	sub    $0xc,%esp                      
  10f084:	8d 43 48             	lea    0x48(%ebx),%eax                
  10f087:	50                   	push   %eax                           
  10f088:	e8 b3 cc ff ff       	call   10bd40 <_Watchdog_Remove>      
  10f08d:	83 c4 10             	add    $0x10,%esp                     
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  10f090:	c7 45 0c f8 ff 03 10 	movl   $0x1003fff8,0xc(%ebp)          
  10f097:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
                                                                      
}                                                                     
  10f09a:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10f09d:	c9                   	leave                                 
  10f09e:	e9 69 ba ff ff       	jmp    10ab0c <_Thread_Clear_state>   
                                                                      

0010e2f0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) {
  10e2f0:	55                   	push   %ebp                           
  10e2f1:	89 e5                	mov    %esp,%ebp                      
  10e2f3:	57                   	push   %edi                           
  10e2f4:	56                   	push   %esi                           
  10e2f5:	53                   	push   %ebx                           
  10e2f6:	83 ec 0c             	sub    $0xc,%esp                      
  10e2f9:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10e2fc:	8a 45 10             	mov    0x10(%ebp),%al                 
  10e2ff:	88 45 eb             	mov    %al,-0x15(%ebp)                
  Chain_Node     *new_first_node;                                     
  Chain_Node     *new_second_node;                                    
  Chain_Node     *last_node;                                          
                                                                      
  the_node = (Chain_Node *) the_thread;                               
  _ISR_Disable( level );                                              
  10e302:	9c                   	pushf                                 
  10e303:	fa                   	cli                                   
  10e304:	8f 45 ec             	popl   -0x14(%ebp)                    
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
  10e307:	f7 43 10 e0 be 03 00 	testl  $0x3bee0,0x10(%ebx)            
  10e30e:	75 09                	jne    10e319 <_Thread_queue_Extract_priority_helper+0x29><== ALWAYS TAKEN
    _ISR_Enable( level );                                             
  10e310:	ff 75 ec             	pushl  -0x14(%ebp)                    <== NOT EXECUTED
  10e313:	9d                   	popf                                  <== NOT EXECUTED
  10e314:	e9 8f 00 00 00       	jmp    10e3a8 <_Thread_queue_Extract_priority_helper+0xb8><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  The thread was actually waiting on a thread queue so let's remove it.
   */                                                                 
                                                                      
  next_node     = the_node->next;                                     
  10e319:	8b 33                	mov    (%ebx),%esi                    
  previous_node = the_node->previous;                                 
  10e31b:	8b 4b 04             	mov    0x4(%ebx),%ecx                 
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  10e31e:	8b 53 38             	mov    0x38(%ebx),%edx                
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
  10e321:	8d 43 3c             	lea    0x3c(%ebx),%eax                
  10e324:	39 c2                	cmp    %eax,%edx                      
  10e326:	74 33                	je     10e35b <_Thread_queue_Extract_priority_helper+0x6b>
    new_first_node   = the_thread->Wait.Block2n.first;                
    new_first_thread = (Thread_Control *) new_first_node;             
    last_node        = the_thread->Wait.Block2n.last;                 
  10e328:	8b 43 40             	mov    0x40(%ebx),%eax                
  10e32b:	89 45 f0             	mov    %eax,-0x10(%ebp)               
    new_second_node  = new_first_node->next;                          
  10e32e:	8b 3a                	mov    (%edx),%edi                    
                                                                      
    previous_node->next      = new_first_node;                        
  10e330:	89 11                	mov    %edx,(%ecx)                    
    next_node->previous      = new_first_node;                        
  10e332:	89 56 04             	mov    %edx,0x4(%esi)                 
    new_first_node->next     = next_node;                             
  10e335:	89 32                	mov    %esi,(%edx)                    
    new_first_node->previous = previous_node;                         
  10e337:	89 4a 04             	mov    %ecx,0x4(%edx)                 
                                                                      
    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {   
  10e33a:	8b 43 38             	mov    0x38(%ebx),%eax                
  10e33d:	3b 43 40             	cmp    0x40(%ebx),%eax                
  10e340:	74 1e                	je     10e360 <_Thread_queue_Extract_priority_helper+0x70>
                                        /* > two threads on 2-n */    
      new_second_node->previous =                                     
  10e342:	8d 42 38             	lea    0x38(%edx),%eax                
  10e345:	89 47 04             	mov    %eax,0x4(%edi)                 
                _Chain_Head( &new_first_thread->Wait.Block2n );       
      new_first_thread->Wait.Block2n.first = new_second_node;         
  10e348:	89 7a 38             	mov    %edi,0x38(%edx)                
                                                                      
      new_first_thread->Wait.Block2n.last = last_node;                
  10e34b:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10e34e:	89 42 40             	mov    %eax,0x40(%edx)                
      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
  10e351:	8d 42 3c             	lea    0x3c(%edx),%eax                
  10e354:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  10e357:	89 02                	mov    %eax,(%edx)                    
  10e359:	eb 05                	jmp    10e360 <_Thread_queue_Extract_priority_helper+0x70>
    }                                                                 
  } else {                                                            
    previous_node->next = next_node;                                  
  10e35b:	89 31                	mov    %esi,(%ecx)                    
    next_node->previous = previous_node;                              
  10e35d:	89 4e 04             	mov    %ecx,0x4(%esi)                 
                                                                      
  /*                                                                  
   *  If we are not supposed to touch timers or the thread's state, return.
   */                                                                 
                                                                      
  if ( requeuing ) {                                                  
  10e360:	80 7d eb 00          	cmpb   $0x0,-0x15(%ebp)               
  10e364:	74 06                	je     10e36c <_Thread_queue_Extract_priority_helper+0x7c>
    _ISR_Enable( level );                                             
  10e366:	ff 75 ec             	pushl  -0x14(%ebp)                    
  10e369:	9d                   	popf                                  
  10e36a:	eb 3c                	jmp    10e3a8 <_Thread_queue_Extract_priority_helper+0xb8>
    return;                                                           
  }                                                                   
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
  10e36c:	83 7b 50 02          	cmpl   $0x2,0x50(%ebx)                
  10e370:	74 06                	je     10e378 <_Thread_queue_Extract_priority_helper+0x88>
    _ISR_Enable( level );                                             
  10e372:	ff 75 ec             	pushl  -0x14(%ebp)                    
  10e375:	9d                   	popf                                  
  10e376:	eb 1a                	jmp    10e392 <_Thread_queue_Extract_priority_helper+0xa2>
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
  10e378:	c7 43 50 03 00 00 00 	movl   $0x3,0x50(%ebx)                
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
  10e37f:	ff 75 ec             	pushl  -0x14(%ebp)                    
  10e382:	9d                   	popf                                  
    (void) _Watchdog_Remove( &the_thread->Timer );                    
  10e383:	83 ec 0c             	sub    $0xc,%esp                      
  10e386:	8d 43 48             	lea    0x48(%ebx),%eax                
  10e389:	50                   	push   %eax                           
  10e38a:	e8 b1 d9 ff ff       	call   10bd40 <_Watchdog_Remove>      
  10e38f:	83 c4 10             	add    $0x10,%esp                     
void *_Protected_heap_Allocate(                                       
  Heap_Control *the_heap,                                             
  size_t        size                                                  
);                                                                    
                                                                      
/**                                                                   
  10e392:	c7 45 0c f8 ff 03 10 	movl   $0x1003fff8,0xc(%ebp)          
  10e399:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
                                                                      
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
}                                                                     
  10e39c:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e39f:	5b                   	pop    %ebx                           
  10e3a0:	5e                   	pop    %esi                           
  10e3a1:	5f                   	pop    %edi                           
  10e3a2:	c9                   	leave                                 
  10e3a3:	e9 64 c7 ff ff       	jmp    10ab0c <_Thread_Clear_state>   
  10e3a8:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10e3ab:	5b                   	pop    %ebx                           
  10e3ac:	5e                   	pop    %esi                           
  10e3ad:	5f                   	pop    %edi                           
  10e3ae:	c9                   	leave                                 
  10e3af:	c3                   	ret                                   
                                                                      

0010e3b0 <_Thread_queue_Process_timeout>: #include <rtems/score/tqdata.h> void _Thread_queue_Process_timeout( Thread_Control *the_thread ) {
  10e3b0:	55                   	push   %ebp                           
  10e3b1:	89 e5                	mov    %esp,%ebp                      
  10e3b3:	83 ec 08             	sub    $0x8,%esp                      
  10e3b6:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;    
  10e3b9:	8b 51 44             	mov    0x44(%ecx),%edx                
   *  If it is not satisfied, then it is "nothing happened" and       
   *  this is the "timeout" transition.  After a request is satisfied,
   *  a timeout is not allowed to occur.                              
   */                                                                 
                                                                      
  if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
  10e3bc:	8b 42 30             	mov    0x30(%edx),%eax                
  10e3bf:	85 c0                	test   %eax,%eax                      
  10e3c1:	74 1c                	je     10e3df <_Thread_queue_Process_timeout+0x2f>
  10e3c3:	3b 0d 58 d8 11 00    	cmp    0x11d858,%ecx                  
  10e3c9:	75 14                	jne    10e3df <_Thread_queue_Process_timeout+0x2f><== NEVER TAKEN
       _Thread_Is_executing( the_thread ) ) {                         
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
  10e3cb:	83 f8 03             	cmp    $0x3,%eax                      
  10e3ce:	74 23                	je     10e3f3 <_Thread_queue_Process_timeout+0x43><== NEVER TAKEN
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
  10e3d0:	8b 42 3c             	mov    0x3c(%edx),%eax                
  10e3d3:	89 41 34             	mov    %eax,0x34(%ecx)                
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
  10e3d6:	c7 42 30 02 00 00 00 	movl   $0x2,0x30(%edx)                
  10e3dd:	eb 14                	jmp    10e3f3 <_Thread_queue_Process_timeout+0x43>
    }                                                                 
  } else {                                                            
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
  10e3df:	8b 42 3c             	mov    0x3c(%edx),%eax                
  10e3e2:	89 41 34             	mov    %eax,0x34(%ecx)                
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );      
  10e3e5:	50                   	push   %eax                           
  10e3e6:	50                   	push   %eax                           
  10e3e7:	51                   	push   %ecx                           
  10e3e8:	ff 71 44             	pushl  0x44(%ecx)                     
  10e3eb:	e8 d0 fe ff ff       	call   10e2c0 <_Thread_queue_Extract> 
  10e3f0:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
}                                                                     
  10e3f3:	c9                   	leave                                 
  10e3f4:	c3                   	ret                                   
                                                                      

0010b58c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
  10b58c:	55                   	push   %ebp                           
  10b58d:	89 e5                	mov    %esp,%ebp                      
  10b58f:	57                   	push   %edi                           
  10b590:	56                   	push   %esi                           
  10b591:	53                   	push   %ebx                           
  10b592:	83 ec 1c             	sub    $0x1c,%esp                     
  10b595:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10b598:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  /*                                                                  
   * Just in case the thread really wasn't blocked on a thread queue  
   * when we get here.                                                
   */                                                                 
  if ( !the_thread_queue )                                            
  10b59b:	85 db                	test   %ebx,%ebx                      
  10b59d:	74 36                	je     10b5d5 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
                                                                      
  /*                                                                  
   * 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 ) {
  10b59f:	83 7b 34 01          	cmpl   $0x1,0x34(%ebx)                
  10b5a3:	75 30                	jne    10b5d5 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
  10b5a5:	9c                   	pushf                                 
  10b5a6:	fa                   	cli                                   
  10b5a7:	5f                   	pop    %edi                           
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
  10b5a8:	f7 46 10 e0 be 03 00 	testl  $0x3bee0,0x10(%esi)            
  10b5af:	74 22                	je     10b5d3 <_Thread_queue_Requeue+0x47><== NEVER TAKEN
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  10b5b1:	c7 43 30 01 00 00 00 	movl   $0x1,0x30(%ebx)                
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );  
  10b5b8:	50                   	push   %eax                           
  10b5b9:	6a 01                	push   $0x1                           
  10b5bb:	56                   	push   %esi                           
  10b5bc:	53                   	push   %ebx                           
  10b5bd:	e8 2e 2d 00 00       	call   10e2f0 <_Thread_queue_Extract_priority_helper>
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
  10b5c2:	83 c4 0c             	add    $0xc,%esp                      
  10b5c5:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10b5c8:	50                   	push   %eax                           
  10b5c9:	56                   	push   %esi                           
  10b5ca:	53                   	push   %ebx                           
  10b5cb:	e8 98 fd ff ff       	call   10b368 <_Thread_queue_Enqueue_priority>
  10b5d0:	83 c4 10             	add    $0x10,%esp                     
    }                                                                 
    _ISR_Enable( level );                                             
  10b5d3:	57                   	push   %edi                           
  10b5d4:	9d                   	popf                                  
  }                                                                   
}                                                                     
  10b5d5:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b5d8:	5b                   	pop    %ebx                           
  10b5d9:	5e                   	pop    %esi                           
  10b5da:	5f                   	pop    %edi                           
  10b5db:	c9                   	leave                                 
  10b5dc:	c3                   	ret                                   
                                                                      

0010b5e0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) {
  10b5e0:	55                   	push   %ebp                           
  10b5e1:	89 e5                	mov    %esp,%ebp                      
  10b5e3:	83 ec 20             	sub    $0x20,%esp                     
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  10b5e6:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  10b5e9:	50                   	push   %eax                           
  10b5ea:	ff 75 08             	pushl  0x8(%ebp)                      
  10b5ed:	e8 ba f8 ff ff       	call   10aeac <_Thread_Get>           
  switch ( location ) {                                               
  10b5f2:	83 c4 10             	add    $0x10,%esp                     
  10b5f5:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  10b5f9:	75 17                	jne    10b612 <_Thread_queue_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
  10b5fb:	83 ec 0c             	sub    $0xc,%esp                      
  10b5fe:	50                   	push   %eax                           
  10b5ff:	e8 ac 2d 00 00       	call   10e3b0 <_Thread_queue_Process_timeout>
  10b604:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  10b609:	48                   	dec    %eax                           
  10b60a:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
  10b60f:	83 c4 10             	add    $0x10,%esp                     
      _Thread_Unnest_dispatch();                                      
      break;                                                          
  }                                                                   
}                                                                     
  10b612:	c9                   	leave                                 
  10b613:	c3                   	ret                                   
                                                                      

00113240 <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) {
  113240:	55                   	push   %ebp                           
  113241:	89 e5                	mov    %esp,%ebp                      
  113243:	57                   	push   %edi                           
  113244:	56                   	push   %esi                           
  113245:	53                   	push   %ebx                           
  113246:	83 ec 1c             	sub    $0x1c,%esp                     
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  113249:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  11324c:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  11324f:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  113252:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  113255:	c7 45 ec 00 00 00 00 	movl   $0x0,-0x14(%ebp)               
  11325c:	89 75 f0             	mov    %esi,-0x10(%ebp)               
                                                                      
  /*                                                                  
   *  Initialize the "last time" markers to indicate the timer that   
   *  the server was initiated.                                       
   */                                                                 
  _Timer_Server_ticks_last_time   = _Watchdog_Ticks_since_boot;       
  11325f:	a1 88 42 13 00       	mov    0x134288,%eax                  
  113264:	a3 bc 40 13 00       	mov    %eax,0x1340bc                  
  _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;         
  113269:	a1 c8 41 13 00       	mov    0x1341c8,%eax                  
  11326e:	a3 b8 40 13 00       	mov    %eax,0x1340b8                  
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  113273:	a1 38 41 13 00       	mov    0x134138,%eax                  
  113278:	40                   	inc    %eax                           
  113279:	a3 38 41 13 00       	mov    %eax,0x134138                  
  /*                                                                  
   *  Insert the timers that were inserted before we got to run.      
   *  This should be done with dispatching disabled.                  
   */                                                                 
  _Thread_Disable_dispatch();                                         
    _Timer_Server_process_insertions();                               
  11327e:	e8 6d ff ff ff       	call   1131f0 <_Timer_Server_process_insertions>
  _Thread_Enable_dispatch();                                          
  113283:	e8 30 25 00 00       	call   1157b8 <_Thread_Enable_dispatch>
     ticks = snapshot - _Timer_Server_ticks_last_time;                
  else                                                                
     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 
                                                                      
  _Timer_Server_ticks_last_time = snapshot;                           
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );   
  113288:	89 f7                	mov    %esi,%edi                      
  11328a:	a1 38 41 13 00       	mov    0x134138,%eax                  
  11328f:	40                   	inc    %eax                           
  113290:	a3 38 41 13 00       	mov    %eax,0x134138                  
                                                                      
    /*                                                                
     *  Block until there is something to do.                         
     */                                                               
    _Thread_Disable_dispatch();                                       
      _Thread_Set_state( _Timer_Server, STATES_DELAYING );            
  113295:	51                   	push   %ecx                           
  113296:	51                   	push   %ecx                           
  113297:	6a 08                	push   $0x8                           
  113299:	ff 35 bc 4a 13 00    	pushl  0x134abc                       
  11329f:	e8 30 2e 00 00       	call   1160d4 <_Thread_Set_state>     
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  1132a4:	8b 15 ac 40 13 00    	mov    0x1340ac,%edx                  
      _Timer_Server_reset_ticks_timer();                              
  1132aa:	83 c4 10             	add    $0x10,%esp                     
  1132ad:	81 fa b0 40 13 00    	cmp    $0x1340b0,%edx                 
  1132b3:	74 1e                	je     1132d3 <_Timer_Server_body+0x93>
  1132b5:	a1 bc 4a 13 00       	mov    0x134abc,%eax                  
  Heap_Control        *the_heap,                                      
  1132ba:	8b 52 10             	mov    0x10(%edx),%edx                
  1132bd:	89 50 54             	mov    %edx,0x54(%eax)                
  void                *starting_address,                              
  size_t              *size                                           
  1132c0:	52                   	push   %edx                           
  1132c1:	52                   	push   %edx                           
  1132c2:	83 c0 48             	add    $0x48,%eax                     
  1132c5:	50                   	push   %eax                           
  1132c6:	68 18 42 13 00       	push   $0x134218                      
  1132cb:	e8 04 36 00 00       	call   1168d4 <_Watchdog_Insert>      
  1132d0:	83 c4 10             	add    $0x10,%esp                     
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  1132d3:	a1 c0 40 13 00       	mov    0x1340c0,%eax                  
      _Timer_Server_reset_seconds_timer();                            
  1132d8:	3d c4 40 13 00       	cmp    $0x1340c4,%eax                 
  1132dd:	74 1c                	je     1132fb <_Timer_Server_body+0xbb>
 *  @return TRUE if successfully able to resize the block.            
 *          FALSE if the block can't be resized in place.             
 */                                                                   
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  1132df:	8b 40 10             	mov    0x10(%eax),%eax                
  1132e2:	a3 e4 40 13 00       	mov    %eax,0x1340e4                  
  size_t        size                                                  
);                                                                    
  1132e7:	50                   	push   %eax                           
  1132e8:	50                   	push   %eax                           
  1132e9:	68 d8 40 13 00       	push   $0x1340d8                      
  1132ee:	68 0c 42 13 00       	push   $0x13420c                      
  1132f3:	e8 dc 35 00 00       	call   1168d4 <_Watchdog_Insert>      
  1132f8:	83 c4 10             	add    $0x10,%esp                     
    _Thread_Enable_dispatch();                                        
  1132fb:	e8 b8 24 00 00       	call   1157b8 <_Thread_Enable_dispatch>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  113300:	a1 38 41 13 00       	mov    0x134138,%eax                  
  113305:	40                   	inc    %eax                           
  113306:	a3 38 41 13 00       	mov    %eax,0x134138                  
    /*                                                                
     *  At this point, at least one of the timers this task relies    
     *  upon has fired.  Stop them both while we process any outstanding
     *  timers.  Before we block, we will restart them.               
     */                                                               
    _Timer_Server_stop_ticks_timer();                                 
  11330b:	83 ec 0c             	sub    $0xc,%esp                      
  11330e:	a1 bc 4a 13 00       	mov    0x134abc,%eax                  
  113313:	83 c0 48             	add    $0x48,%eax                     
  113316:	50                   	push   %eax                           
  113317:	e8 d0 36 00 00       	call   1169ec <_Watchdog_Remove>      
    _Timer_Server_stop_seconds_timer();                               
  11331c:	c7 04 24 d8 40 13 00 	movl   $0x1340d8,(%esp)               
  113323:	e8 c4 36 00 00       	call   1169ec <_Watchdog_Remove>      
)                                                                     
{                                                                     
  Watchdog_Interval snapshot;                                         
  Watchdog_Interval ticks;                                            
                                                                      
  snapshot = _Watchdog_Ticks_since_boot;                              
  113328:	8b 15 88 42 13 00    	mov    0x134288,%edx                  
  if ( snapshot >= _Timer_Server_ticks_last_time )                    
  11332e:	a1 bc 40 13 00       	mov    0x1340bc,%eax                  
  113333:	83 c4 10             	add    $0x10,%esp                     
  113336:	39 c2                	cmp    %eax,%edx                      
  113338:	72 08                	jb     113342 <_Timer_Server_body+0x102><== NEVER TAKEN
     ticks = snapshot - _Timer_Server_ticks_last_time;                
  11333a:	89 d1                	mov    %edx,%ecx                      
  11333c:	29 c1                	sub    %eax,%ecx                      
  11333e:	89 c8                	mov    %ecx,%eax                      
  113340:	eb 04                	jmp    113346 <_Timer_Server_body+0x106>
  else                                                                
     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 
  113342:	f7 d0                	not    %eax                           <== NOT EXECUTED
  113344:	01 d0                	add    %edx,%eax                      <== NOT EXECUTED
                                                                      
  _Timer_Server_ticks_last_time = snapshot;                           
  113346:	89 15 bc 40 13 00    	mov    %edx,0x1340bc                  
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );   
  11334c:	53                   	push   %ebx                           
  11334d:	57                   	push   %edi                           
  11334e:	50                   	push   %eax                           
  11334f:	68 ac 40 13 00       	push   $0x1340ac                      
  113354:	e8 eb 34 00 00       	call   116844 <_Watchdog_Adjust_to_chain>
  /*                                                                  
   *  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 _Timer_Seconds_chain to indicate this.    
   */                                                                 
  snapshot =  _TOD_Seconds_since_epoch;                               
  113359:	8b 1d c8 41 13 00    	mov    0x1341c8,%ebx                  
  if ( snapshot > _Timer_Server_seconds_last_time ) {                 
  11335f:	a1 b8 40 13 00       	mov    0x1340b8,%eax                  
  113364:	83 c4 10             	add    $0x10,%esp                     
  113367:	39 c3                	cmp    %eax,%ebx                      
  113369:	76 13                	jbe    11337e <_Timer_Server_body+0x13e>
    /*                                                                
     *  This path is for normal forward movement and cases where the  
     *  TOD has been set forward.                                     
     */                                                               
    ticks = snapshot - _Timer_Server_seconds_last_time;               
    _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
  11336b:	51                   	push   %ecx                           
  11336c:	57                   	push   %edi                           
  11336d:	89 da                	mov    %ebx,%edx                      
  11336f:	29 c2                	sub    %eax,%edx                      
  113371:	52                   	push   %edx                           
  113372:	68 c0 40 13 00       	push   $0x1340c0                      
  113377:	e8 c8 34 00 00       	call   116844 <_Watchdog_Adjust_to_chain>
  11337c:	eb 12                	jmp    113390 <_Timer_Server_body+0x150>
                                                                      
  } else if ( snapshot < _Timer_Server_seconds_last_time ) {          
  11337e:	73 13                	jae    113393 <_Timer_Server_body+0x153>
     /*                                                               
      *  The current TOD is before the last TOD which indicates that  
      *  TOD has been set backwards.                                  
      */                                                              
     ticks = _Timer_Server_seconds_last_time - snapshot;              
     _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
  113380:	52                   	push   %edx                           
  113381:	29 d8                	sub    %ebx,%eax                      
  113383:	50                   	push   %eax                           
  113384:	6a 01                	push   $0x1                           
  113386:	68 c0 40 13 00       	push   $0x1340c0                      
  11338b:	e8 48 34 00 00       	call   1167d8 <_Watchdog_Adjust>      
  113390:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
  _Timer_Server_seconds_last_time = snapshot;                         
  113393:	89 1d b8 40 13 00    	mov    %ebx,0x1340b8                  
    _Timer_Server_process_seconds_chain( &to_fire );                  
                                                                      
    /*                                                                
     *  Insert the timers that have been requested to be inserted.    
     */                                                               
    _Timer_Server_process_insertions();                               
  113399:	e8 52 fe ff ff       	call   1131f0 <_Timer_Server_process_insertions>
                                                                      
    /*                                                                
     * Enable dispatching to process the set that are ready "to fire."
     */                                                               
    _Thread_Enable_dispatch();                                        
  11339e:	e8 15 24 00 00       	call   1157b8 <_Thread_Enable_dispatch>
     */                                                               
    while (1) {                                                       
      Watchdog_Control *watch;                                        
      ISR_Level         level;                                        
                                                                      
      _ISR_Disable( level );                                          
  1133a3:	9c                   	pushf                                 
  1133a4:	fa                   	cli                                   
  1133a5:	59                   	pop    %ecx                           
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  1133a6:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  1133a9:	3b 55 e0             	cmp    -0x20(%ebp),%edx               
  1133ac:	74 0c                	je     1133ba <_Timer_Server_body+0x17a>
  1133ae:	8b 02                	mov    (%edx),%eax                    
  1133b0:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  1133b3:	89 70 04             	mov    %esi,0x4(%eax)                 
      watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
      if ( watch == NULL ) {                                          
  1133b6:	85 d2                	test   %edx,%edx                      
  1133b8:	75 07                	jne    1133c1 <_Timer_Server_body+0x181><== ALWAYS TAKEN
        _ISR_Enable( level );                                         
  1133ba:	51                   	push   %ecx                           
  1133bb:	9d                   	popf                                  
  1133bc:	e9 c9 fe ff ff       	jmp    11328a <_Timer_Server_body+0x4a>
        break;                                                        
      }                                                               
                                                                      
      watch->state = WATCHDOG_INACTIVE;                               
  1133c1:	c7 42 08 00 00 00 00 	movl   $0x0,0x8(%edx)                 
      _ISR_Enable( level );                                           
  1133c8:	51                   	push   %ecx                           
  1133c9:	9d                   	popf                                  
                                                                      
      (*watch->routine)( watch->id, watch->user_data );               
  1133ca:	53                   	push   %ebx                           
  1133cb:	53                   	push   %ebx                           
  1133cc:	ff 72 24             	pushl  0x24(%edx)                     
  1133cf:	ff 72 20             	pushl  0x20(%edx)                     
  1133d2:	ff 52 1c             	call   *0x1c(%edx)                    
  1133d5:	83 c4 10             	add    $0x10,%esp                     
  1133d8:	eb c9                	jmp    1133a3 <_Timer_Server_body+0x163>
                                                                      

001131f0 <_Timer_Server_process_insertions>: * onto one of the Timer Server chains. * * @note It is only to be called from the Timer Server task. */ static void _Timer_Server_process_insertions(void) {
  1131f0:	55                   	push   %ebp                           
  1131f1:	89 e5                	mov    %esp,%ebp                      
  1131f3:	83 ec 08             	sub    $0x8,%esp                      
  Timer_Control *the_timer;                                           
                                                                      
  while ( 1 ) {                                                       
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
  1131f6:	83 ec 0c             	sub    $0xc,%esp                      
  1131f9:	68 cc 40 13 00       	push   $0x1340cc                      
  1131fe:	e8 a5 08 00 00       	call   113aa8 <_Chain_Get>            
    if ( the_timer == NULL )                                          
  113203:	83 c4 10             	add    $0x10,%esp                     
  113206:	85 c0                	test   %eax,%eax                      
  113208:	74 34                	je     11323e <_Timer_Server_process_insertions+0x4e>
      break;                                                          
                                                                      
    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {           
  11320a:	8b 50 38             	mov    0x38(%eax),%edx                
  11320d:	83 fa 01             	cmp    $0x1,%edx                      
  113210:	75 0d                	jne    11321f <_Timer_Server_process_insertions+0x2f>
      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );    
  113212:	51                   	push   %ecx                           
  113213:	51                   	push   %ecx                           
  113214:	83 c0 10             	add    $0x10,%eax                     
  113217:	50                   	push   %eax                           
  113218:	68 ac 40 13 00       	push   $0x1340ac                      
  11321d:	eb 10                	jmp    11322f <_Timer_Server_process_insertions+0x3f>
    } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 
  11321f:	83 fa 03             	cmp    $0x3,%edx                      
  113222:	75 13                	jne    113237 <_Timer_Server_process_insertions+0x47><== NEVER TAKEN
      _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );  
  113224:	52                   	push   %edx                           
  113225:	52                   	push   %edx                           
  113226:	83 c0 10             	add    $0x10,%eax                     
  113229:	50                   	push   %eax                           
  11322a:	68 c0 40 13 00       	push   $0x1340c0                      
  11322f:	e8 a0 36 00 00       	call   1168d4 <_Watchdog_Insert>      
  113234:	83 c4 10             	add    $0x10,%esp                     
    }                                                                 
                                                                      
    /*                                                                
     *  Insert the timers that have been requested to be inserted.    
     */                                                               
    _Timer_Server_process_insertions();                               
  113237:	e8 b4 ff ff ff       	call   1131f0 <_Timer_Server_process_insertions>
  11323c:	eb b8                	jmp    1131f6 <_Timer_Server_process_insertions+0x6>
  }                                                                   
                                                                      
}                                                                     
  11323e:	c9                   	leave                                 
  11323f:	c3                   	ret                                   
                                                                      

0010cf04 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) {
  10cf04:	55                   	push   %ebp                           
  10cf05:	89 e5                	mov    %esp,%ebp                      
  10cf07:	57                   	push   %edi                           
  10cf08:	56                   	push   %esi                           
  10cf09:	53                   	push   %ebx                           
  10cf0a:	83 ec 1c             	sub    $0x1c,%esp                     
  10cf0d:	8b 45 08             	mov    0x8(%ebp),%eax                 
                                                                      
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  10cf10:	8b 18                	mov    (%eax),%ebx                    
  left  += lhs->tv_nsec;                                              
  10cf12:	8b 40 04             	mov    0x4(%eax),%eax                 
  10cf15:	89 45 e4             	mov    %eax,-0x1c(%ebp)               
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  10cf18:	b8 00 ca 9a 3b       	mov    $0x3b9aca00,%eax               
  10cf1d:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  10cf20:	f7 29                	imull  (%ecx)                         
  10cf22:	89 c6                	mov    %eax,%esi                      
  10cf24:	89 d7                	mov    %edx,%edi                      
  right += rhs->tv_nsec;                                              
  10cf26:	8b 41 04             	mov    0x4(%ecx),%eax                 
  10cf29:	99                   	cltd                                  
  10cf2a:	01 c6                	add    %eax,%esi                      
  10cf2c:	11 d7                	adc    %edx,%edi                      
                                                                      
  if ( right == 0 ) {                                                 
  10cf2e:	89 f8                	mov    %edi,%eax                      
  10cf30:	09 f0                	or     %esi,%eax                      
  10cf32:	75 14                	jne    10cf48 <_Timespec_Divide+0x44> <== ALWAYS TAKEN
    *ival_percentage = 0;                                             
  10cf34:	8b 55 10             	mov    0x10(%ebp),%edx                <== NOT EXECUTED
  10cf37:	c7 02 00 00 00 00    	movl   $0x0,(%edx)                    <== NOT EXECUTED
    *fval_percentage = 0;                                             
  10cf3d:	8b 4d 14             	mov    0x14(%ebp),%ecx                <== NOT EXECUTED
  10cf40:	c7 01 00 00 00 00    	movl   $0x0,(%ecx)                    <== NOT EXECUTED
  10cf46:	eb 70                	jmp    10cfb8 <_Timespec_Divide+0xb4> <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  10cf48:	b8 00 ca 9a 3b       	mov    $0x3b9aca00,%eax               
  10cf4d:	f7 eb                	imul   %ebx                           
  10cf4f:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  10cf52:	89 55 ec             	mov    %edx,-0x14(%ebp)               
   *  Put it back in the timespec result.                             
   *                                                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (left * 100000) / right;                                   
  10cf55:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  10cf58:	99                   	cltd                                  
  10cf59:	01 45 e8             	add    %eax,-0x18(%ebp)               
  10cf5c:	11 55 ec             	adc    %edx,-0x14(%ebp)               
  10cf5f:	69 5d ec a0 86 01 00 	imul   $0x186a0,-0x14(%ebp),%ebx      
  10cf66:	b9 a0 86 01 00       	mov    $0x186a0,%ecx                  
  10cf6b:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10cf6e:	f7 e1                	mul    %ecx                           
  10cf70:	89 45 d8             	mov    %eax,-0x28(%ebp)               
  10cf73:	01 da                	add    %ebx,%edx                      
  10cf75:	89 55 dc             	mov    %edx,-0x24(%ebp)               
  10cf78:	57                   	push   %edi                           
  10cf79:	56                   	push   %esi                           
  10cf7a:	ff 75 dc             	pushl  -0x24(%ebp)                    
  10cf7d:	ff 75 d8             	pushl  -0x28(%ebp)                    
  10cf80:	e8 33 ae 00 00       	call   117db8 <__udivdi3>             
  10cf85:	83 c4 10             	add    $0x10,%esp                     
  10cf88:	89 c3                	mov    %eax,%ebx                      
  10cf8a:	89 d6                	mov    %edx,%esi                      
                                                                      
  *ival_percentage = answer / 1000;                                   
  10cf8c:	6a 00                	push   $0x0                           
  10cf8e:	68 e8 03 00 00       	push   $0x3e8                         
  10cf93:	52                   	push   %edx                           
  10cf94:	50                   	push   %eax                           
  10cf95:	e8 1e ae 00 00       	call   117db8 <__udivdi3>             
  10cf9a:	83 c4 10             	add    $0x10,%esp                     
  10cf9d:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  10cfa0:	89 01                	mov    %eax,(%ecx)                    
  *fval_percentage = answer % 1000;                                   
  10cfa2:	6a 00                	push   $0x0                           
  10cfa4:	68 e8 03 00 00       	push   $0x3e8                         
  10cfa9:	56                   	push   %esi                           
  10cfaa:	53                   	push   %ebx                           
  10cfab:	e8 14 af 00 00       	call   117ec4 <__umoddi3>             
  10cfb0:	83 c4 10             	add    $0x10,%esp                     
  10cfb3:	8b 4d 14             	mov    0x14(%ebp),%ecx                
  10cfb6:	89 01                	mov    %eax,(%ecx)                    
}                                                                     
  10cfb8:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10cfbb:	5b                   	pop    %ebx                           
  10cfbc:	5e                   	pop    %esi                           
  10cfbd:	5f                   	pop    %edi                           
  10cfbe:	c9                   	leave                                 
  10cfbf:	c3                   	ret                                   
                                                                      

0010d510 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) {
  10d510:	55                   	push   %ebp                           
  10d511:	89 e5                	mov    %esp,%ebp                      
  10d513:	53                   	push   %ebx                           
  10d514:	83 ec 10             	sub    $0x10,%esp                     
  10d517:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  _Chain_Extract( &the_extension->Node );                             
  10d51a:	53                   	push   %ebx                           
  10d51b:	e8 6c 23 00 00       	call   10f88c <_Chain_Extract>        
                                                                      
  /*                                                                  
   * If a switch handler is present, remove it.                       
   */                                                                 
                                                                      
  if ( the_extension->Callouts.thread_switch != NULL )                
  10d520:	83 c4 10             	add    $0x10,%esp                     
  10d523:	83 7b 24 00          	cmpl   $0x0,0x24(%ebx)                
  10d527:	74 0f                	je     10d538 <_User_extensions_Remove_set+0x28><== ALWAYS TAKEN
    _Chain_Extract( &the_extension->Switch.Node );                    
  10d529:	8d 43 08             	lea    0x8(%ebx),%eax                 <== NOT EXECUTED
  10d52c:	89 45 08             	mov    %eax,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  10d52f:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10d532:	c9                   	leave                                 <== NOT EXECUTED
  /*                                                                  
   * If a switch handler is present, remove it.                       
   */                                                                 
                                                                      
  if ( the_extension->Callouts.thread_switch != NULL )                
    _Chain_Extract( &the_extension->Switch.Node );                    
  10d533:	e9 54 23 00 00       	jmp    10f88c <_Chain_Extract>        <== NOT EXECUTED
}                                                                     
  10d538:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10d53b:	c9                   	leave                                 
  10d53c:	c3                   	ret                                   
                                                                      

0010d260 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) {
  10d260:	55                   	push   %ebp                           
  10d261:	89 e5                	mov    %esp,%ebp                      
  10d263:	57                   	push   %edi                           
  10d264:	56                   	push   %esi                           
  10d265:	53                   	push   %ebx                           
  10d266:	83 ec 0c             	sub    $0xc,%esp                      
  10d269:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10d26c:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  10d26f:	8b 75 10             	mov    0x10(%ebp),%esi                
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
  10d272:	9c                   	pushf                                 
  10d273:	fa                   	cli                                   
  10d274:	5a                   	pop    %edx                           
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  10d275:	8b 07                	mov    (%edi),%eax                    
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  10d277:	8d 5f 04             	lea    0x4(%edi),%ebx                 
  10d27a:	89 5d f0             	mov    %ebx,-0x10(%ebp)               
   *       hence the compiler must not assume *header to remain       
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
  10d27d:	39 d8                	cmp    %ebx,%eax                      
  10d27f:	74 41                	je     10d2c2 <_Watchdog_Adjust+0x62> 
    switch ( direction ) {                                            
  10d281:	85 c9                	test   %ecx,%ecx                      
  10d283:	74 39                	je     10d2be <_Watchdog_Adjust+0x5e> 
  10d285:	49                   	dec    %ecx                           
  10d286:	75 3a                	jne    10d2c2 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
  10d288:	01 70 10             	add    %esi,0x10(%eax)                
  10d28b:	eb 35                	jmp    10d2c2 <_Watchdog_Adjust+0x62> 
  10d28d:	8b 07                	mov    (%edi),%eax                    
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
  10d28f:	8b 58 10             	mov    0x10(%eax),%ebx                
  10d292:	39 de                	cmp    %ebx,%esi                      
  10d294:	73 07                	jae    10d29d <_Watchdog_Adjust+0x3d> 
            _Watchdog_First( header )->delta_interval -= units;       
  10d296:	29 f3                	sub    %esi,%ebx                      
  10d298:	89 58 10             	mov    %ebx,0x10(%eax)                
  10d29b:	eb 25                	jmp    10d2c2 <_Watchdog_Adjust+0x62> 
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
  10d29d:	c7 40 10 01 00 00 00 	movl   $0x1,0x10(%eax)                
                                                                      
			_ISR_Enable( level );                                              
  10d2a4:	52                   	push   %edx                           
  10d2a5:	9d                   	popf                                  
                                                                      
            _Watchdog_Tickle( header );                               
  10d2a6:	83 ec 0c             	sub    $0xc,%esp                      
  10d2a9:	57                   	push   %edi                           
  10d2aa:	e8 9d 01 00 00       	call   10d44c <_Watchdog_Tickle>      
                                                                      
			_ISR_Disable( level );                                             
  10d2af:	9c                   	pushf                                 
  10d2b0:	fa                   	cli                                   
  10d2b1:	5a                   	pop    %edx                           
                                                                      
            if ( _Chain_Is_empty( header ) )                          
  10d2b2:	83 c4 10             	add    $0x10,%esp                     
  10d2b5:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10d2b8:	39 07                	cmp    %eax,(%edi)                    
  10d2ba:	74 06                	je     10d2c2 <_Watchdog_Adjust+0x62> 
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
  10d2bc:	29 de                	sub    %ebx,%esi                      
    switch ( direction ) {                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
  10d2be:	85 f6                	test   %esi,%esi                      
  10d2c0:	75 cb                	jne    10d28d <_Watchdog_Adjust+0x2d> <== ALWAYS TAKEN
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
  10d2c2:	52                   	push   %edx                           
  10d2c3:	9d                   	popf                                  
                                                                      
}                                                                     
  10d2c4:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10d2c7:	5b                   	pop    %ebx                           
  10d2c8:	5e                   	pop    %esi                           
  10d2c9:	5f                   	pop    %edi                           
  10d2ca:	c9                   	leave                                 
  10d2cb:	c3                   	ret                                   
                                                                      

00116844 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) {
  116844:	55                   	push   %ebp                           
  116845:	89 e5                	mov    %esp,%ebp                      
  116847:	57                   	push   %edi                           
  116848:	56                   	push   %esi                           
  116849:	53                   	push   %ebx                           
  11684a:	83 ec 0c             	sub    $0xc,%esp                      
  11684d:	8b 75 08             	mov    0x8(%ebp),%esi                 
  116850:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  Watchdog_Interval  units = units_arg;                               
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  if ( !units ) {                                                     
  116853:	85 c0                	test   %eax,%eax                      
  116855:	74 74                	je     1168cb <_Watchdog_Adjust_to_chain+0x87>
    return;                                                           
  }                                                                   
  _ISR_Disable( level );                                              
  116857:	9c                   	pushf                                 
  116858:	fa                   	cli                                   
  116859:	8f 45 ec             	popl   -0x14(%ebp)                    
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  11685c:	8d 7e 04             	lea    0x4(%esi),%edi                 
                                                                      
  if ( !_Chain_Is_empty( header ) ) {                                 
  11685f:	39 3e                	cmp    %edi,(%esi)                    
  116861:	74 64                	je     1168c7 <_Watchdog_Adjust_to_chain+0x83>
  116863:	8b 55 10             	mov    0x10(%ebp),%edx                
  116866:	83 c2 04             	add    $0x4,%edx                      
  116869:	89 55 f0             	mov    %edx,-0x10(%ebp)               
  11686c:	89 c3                	mov    %eax,%ebx                      
  11686e:	8b 06                	mov    (%esi),%eax                    
    while ( units ) {                                                 
      if ( units < _Watchdog_First( header )->delta_interval ) {      
  116870:	8b 48 10             	mov    0x10(%eax),%ecx                
  116873:	39 cb                	cmp    %ecx,%ebx                      
  116875:	73 07                	jae    11687e <_Watchdog_Adjust_to_chain+0x3a>
	_Watchdog_First( header )->delta_interval -= units;                  
  116877:	29 d9                	sub    %ebx,%ecx                      
  116879:	89 48 10             	mov    %ecx,0x10(%eax)                
  11687c:	eb 49                	jmp    1168c7 <_Watchdog_Adjust_to_chain+0x83>
	break;                                                               
      } else {                                                        
	units -= _Watchdog_First( header )->delta_interval;                  
	_Watchdog_First( header )->delta_interval = 0;                       
  11687e:	c7 40 10 00 00 00 00 	movl   $0x0,0x10(%eax)                
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  116885:	8b 16                	mov    (%esi),%edx                    
  116887:	39 fa                	cmp    %edi,%edx                      
  116889:	75 04                	jne    11688f <_Watchdog_Adjust_to_chain+0x4b><== ALWAYS TAKEN
  11688b:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  11688d:	eb 07                	jmp    116896 <_Watchdog_Adjust_to_chain+0x52><== NOT EXECUTED
  11688f:	8b 02                	mov    (%edx),%eax                    
  116891:	89 06                	mov    %eax,(%esi)                    
  116893:	89 70 04             	mov    %esi,0x4(%eax)                 
  116896:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  116899:	89 02                	mov    %eax,(%edx)                    
  11689b:	8b 45 10             	mov    0x10(%ebp),%eax                
  11689e:	8b 40 08             	mov    0x8(%eax),%eax                 
  1168a1:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  1168a4:	8b 45 10             	mov    0x10(%ebp),%eax                
  1168a7:	89 50 08             	mov    %edx,0x8(%eax)                 
  1168aa:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  1168ad:	89 10                	mov    %edx,(%eax)                    
  1168af:	89 42 04             	mov    %eax,0x4(%edx)                 
                                                                      
        do {                                                          
          node = _Chain_Get_unprotected( header );                    
          _Chain_Append_unprotected( to_fire, node );                 
                                                                      
	  _ISR_Flash( level );                                               
  1168b2:	ff 75 ec             	pushl  -0x14(%ebp)                    
  1168b5:	9d                   	popf                                  
  1168b6:	fa                   	cli                                   
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  1168b7:	8b 06                	mov    (%esi),%eax                    
                                                                      
        } while ( !_Chain_Is_empty( header ) &&                       
                  _Watchdog_First( header )->delta_interval == 0 );   
  1168b9:	39 f8                	cmp    %edi,%eax                      
  1168bb:	74 0a                	je     1168c7 <_Watchdog_Adjust_to_chain+0x83>
  1168bd:	83 78 10 00          	cmpl   $0x0,0x10(%eax)                
  1168c1:	74 c2                	je     116885 <_Watchdog_Adjust_to_chain+0x41>
    return;                                                           
  }                                                                   
  _ISR_Disable( level );                                              
                                                                      
  if ( !_Chain_Is_empty( header ) ) {                                 
    while ( units ) {                                                 
  1168c3:	29 cb                	sub    %ecx,%ebx                      
  1168c5:	75 a7                	jne    11686e <_Watchdog_Adjust_to_chain+0x2a><== NEVER TAKEN
	  break;                                                             
      }                                                               
    }                                                                 
                                                                      
  }                                                                   
  _ISR_Enable( level );                                               
  1168c7:	ff 75 ec             	pushl  -0x14(%ebp)                    
  1168ca:	9d                   	popf                                  
}                                                                     
  1168cb:	83 c4 0c             	add    $0xc,%esp                      
  1168ce:	5b                   	pop    %ebx                           
  1168cf:	5e                   	pop    %esi                           
  1168d0:	5f                   	pop    %edi                           
  1168d1:	c9                   	leave                                 
  1168d2:	c3                   	ret                                   
                                                                      

0010bc28 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) {
  10bc28:	55                   	push   %ebp                           
  10bc29:	89 e5                	mov    %esp,%ebp                      
  10bc2b:	57                   	push   %edi                           
  10bc2c:	56                   	push   %esi                           
  10bc2d:	53                   	push   %ebx                           
  10bc2e:	83 ec 04             	sub    $0x4,%esp                      
  10bc31:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Watchdog_Control  *after;                                           
  uint32_t           insert_isr_nest_level;                           
  Watchdog_Interval  delta_interval;                                  
                                                                      
                                                                      
  insert_isr_nest_level   = _ISR_Nest_level;                          
  10bc34:	8b 3d 34 d8 11 00    	mov    0x11d834,%edi                  
                                                                      
  _ISR_Disable( level );                                              
  10bc3a:	9c                   	pushf                                 
  10bc3b:	fa                   	cli                                   
  10bc3c:	8f 45 f0             	popl   -0x10(%ebp)                    
  /*                                                                  
   *  Check to see if the watchdog has just been inserted by a        
   *  higher priority interrupt.  If so, abandon this insert.         
   */                                                                 
                                                                      
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {                   
  10bc3f:	83 7e 08 00          	cmpl   $0x0,0x8(%esi)                 
  10bc43:	74 09                	je     10bc4e <_Watchdog_Insert+0x26> <== ALWAYS TAKEN
    _ISR_Enable( level );                                             
  10bc45:	ff 75 f0             	pushl  -0x10(%ebp)                    <== NOT EXECUTED
  10bc48:	9d                   	popf                                  <== NOT EXECUTED
  10bc49:	e9 89 00 00 00       	jmp    10bcd7 <_Watchdog_Insert+0xaf> <== NOT EXECUTED
    return;                                                           
  }                                                                   
                                                                      
  the_watchdog->state = WATCHDOG_BEING_INSERTED;                      
  10bc4e:	c7 46 08 01 00 00 00 	movl   $0x1,0x8(%esi)                 
  _Watchdog_Sync_count++;                                             
  10bc55:	a1 e4 d8 11 00       	mov    0x11d8e4,%eax                  
  10bc5a:	40                   	inc    %eax                           
  10bc5b:	a3 e4 d8 11 00       	mov    %eax,0x11d8e4                  
                                                                      
restart:                                                              
  delta_interval = the_watchdog->initial;                             
  10bc60:	8b 4e 0c             	mov    0xc(%esi),%ecx                 
   * cache *header!!                                                  
   *                                                                  
   *  Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)               
   *                                                                  
   */                                                                 
  for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
  10bc63:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10bc66:	8b 18                	mov    (%eax),%ebx                    
        ;                                                             
        after = _Watchdog_Next( after ) ) {                           
                                                                      
     if ( delta_interval == 0 || !_Watchdog_Next( after ) )           
  10bc68:	85 c9                	test   %ecx,%ecx                      
  10bc6a:	74 35                	je     10bca1 <_Watchdog_Insert+0x79> 
  10bc6c:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10bc6f:	74 30                	je     10bca1 <_Watchdog_Insert+0x79> 
       break;                                                         
                                                                      
     if ( delta_interval < after->delta_interval ) {                  
  10bc71:	8b 53 10             	mov    0x10(%ebx),%edx                
  10bc74:	39 d1                	cmp    %edx,%ecx                      
  10bc76:	73 07                	jae    10bc7f <_Watchdog_Insert+0x57> 
       after->delta_interval -= delta_interval;                       
  10bc78:	29 ca                	sub    %ecx,%edx                      
  10bc7a:	89 53 10             	mov    %edx,0x10(%ebx)                
  10bc7d:	eb 22                	jmp    10bca1 <_Watchdog_Insert+0x79> 
      *  used around this flash point allowed interrupts to execute   
      *  which violated the design assumptions.  The critical section 
      *  mechanism used here WAS redesigned to address this.          
      */                                                              
                                                                      
     _ISR_Flash( level );                                             
  10bc7f:	ff 75 f0             	pushl  -0x10(%ebp)                    
  10bc82:	9d                   	popf                                  
  10bc83:	fa                   	cli                                   
                                                                      
     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {          
  10bc84:	83 7e 08 01          	cmpl   $0x1,0x8(%esi)                 
  10bc88:	75 38                	jne    10bcc2 <_Watchdog_Insert+0x9a> <== NEVER TAKEN
       goto exit_insert;                                              
     }                                                                
                                                                      
     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {            
  10bc8a:	a1 54 d8 11 00       	mov    0x11d854,%eax                  
  10bc8f:	39 f8                	cmp    %edi,%eax                      
  10bc91:	76 08                	jbe    10bc9b <_Watchdog_Insert+0x73> 
       _Watchdog_Sync_level = insert_isr_nest_level;                  
  10bc93:	89 3d 54 d8 11 00    	mov    %edi,0x11d854                  
  10bc99:	eb c5                	jmp    10bc60 <_Watchdog_Insert+0x38> 
     if ( delta_interval < after->delta_interval ) {                  
       after->delta_interval -= delta_interval;                       
       break;                                                         
     }                                                                
                                                                      
     delta_interval -= after->delta_interval;                         
  10bc9b:	29 d1                	sub    %edx,%ecx                      
);                                                                    
                                                                      
#ifdef __cplusplus                                                    
}                                                                     
#endif                                                                
                                                                      
  10bc9d:	8b 1b                	mov    (%ebx),%ebx                    
  10bc9f:	eb c7                	jmp    10bc68 <_Watchdog_Insert+0x40> 
 *  @param[in] starting_address is the starting address of the memory 
 *         to add to the heap                                         
 *  @param[in] size is the size in bytes of the memory area to add    
 *  @return a status indicating success or the reason for failure     
 */                                                                   
bool _Protected_heap_Extend(                                          
  10bca1:	c7 46 08 02 00 00 00 	movl   $0x2,0x8(%esi)                 
     }                                                                
  }                                                                   
                                                                      
  _Watchdog_Activate( the_watchdog );                                 
                                                                      
  the_watchdog->delta_interval = delta_interval;                      
  10bca8:	89 4e 10             	mov    %ecx,0x10(%esi)                
                                                                      
  _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
  10bcab:	8b 43 04             	mov    0x4(%ebx),%eax                 
  10bcae:	89 46 04             	mov    %eax,0x4(%esi)                 
  10bcb1:	8b 10                	mov    (%eax),%edx                    
  10bcb3:	89 30                	mov    %esi,(%eax)                    
  10bcb5:	89 16                	mov    %edx,(%esi)                    
  10bcb7:	89 72 04             	mov    %esi,0x4(%edx)                 
                                                                      
  the_watchdog->start_time = _Watchdog_Ticks_since_boot;              
  10bcba:	a1 e8 d8 11 00       	mov    0x11d8e8,%eax                  
  10bcbf:	89 46 14             	mov    %eax,0x14(%esi)                
                                                                      
exit_insert:                                                          
  _Watchdog_Sync_level = insert_isr_nest_level;                       
  10bcc2:	89 3d 54 d8 11 00    	mov    %edi,0x11d854                  
  _Watchdog_Sync_count--;                                             
  10bcc8:	a1 e4 d8 11 00       	mov    0x11d8e4,%eax                  
  10bccd:	48                   	dec    %eax                           
  10bcce:	a3 e4 d8 11 00       	mov    %eax,0x11d8e4                  
  _ISR_Enable( level );                                               
  10bcd3:	ff 75 f0             	pushl  -0x10(%ebp)                    
  10bcd6:	9d                   	popf                                  
}                                                                     
  10bcd7:	58                   	pop    %eax                           
  10bcd8:	5b                   	pop    %ebx                           
  10bcd9:	5e                   	pop    %esi                           
  10bcda:	5f                   	pop    %edi                           
  10bcdb:	c9                   	leave                                 
  10bcdc:	c3                   	ret                                   
                                                                      

0010bd40 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) {
  10bd40:	55                   	push   %ebp                           
  10bd41:	89 e5                	mov    %esp,%ebp                      
  10bd43:	56                   	push   %esi                           
  10bd44:	53                   	push   %ebx                           
  10bd45:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  10bd48:	9c                   	pushf                                 
  10bd49:	fa                   	cli                                   
  10bd4a:	5e                   	pop    %esi                           
  previous_state = the_watchdog->state;                               
  10bd4b:	8b 59 08             	mov    0x8(%ecx),%ebx                 
  switch ( previous_state ) {                                         
  10bd4e:	83 fb 01             	cmp    $0x1,%ebx                      
  10bd51:	74 09                	je     10bd5c <_Watchdog_Remove+0x1c> <== NEVER TAKEN
  10bd53:	72 41                	jb     10bd96 <_Watchdog_Remove+0x56> 
  10bd55:	83 fb 03             	cmp    $0x3,%ebx                      
  10bd58:	77 3c                	ja     10bd96 <_Watchdog_Remove+0x56> <== NEVER TAKEN
  10bd5a:	eb 09                	jmp    10bd65 <_Watchdog_Remove+0x25> 
                                                                      
      /*                                                              
       *  It is not actually on the chain so just change the state and
       *  the Insert operation we interrupted will be aborted.        
       */                                                             
      the_watchdog->state = WATCHDOG_INACTIVE;                        
  10bd5c:	c7 41 08 00 00 00 00 	movl   $0x0,0x8(%ecx)                 <== NOT EXECUTED
  10bd63:	eb 31                	jmp    10bd96 <_Watchdog_Remove+0x56> <== NOT EXECUTED
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
  10bd65:	c7 41 08 00 00 00 00 	movl   $0x0,0x8(%ecx)                 
);                                                                    
                                                                      
#ifdef __cplusplus                                                    
}                                                                     
#endif                                                                
                                                                      
  10bd6c:	8b 11                	mov    (%ecx),%edx                    
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
  10bd6e:	83 3a 00             	cmpl   $0x0,(%edx)                    
  10bd71:	74 06                	je     10bd79 <_Watchdog_Remove+0x39> 
        next_watchdog->delta_interval += the_watchdog->delta_interval;
  10bd73:	8b 41 10             	mov    0x10(%ecx),%eax                
  10bd76:	01 42 10             	add    %eax,0x10(%edx)                
                                                                      
      if ( _Watchdog_Sync_count )                                     
  10bd79:	a1 e4 d8 11 00       	mov    0x11d8e4,%eax                  
  10bd7e:	85 c0                	test   %eax,%eax                      
  10bd80:	74 0a                	je     10bd8c <_Watchdog_Remove+0x4c> <== ALWAYS TAKEN
        _Watchdog_Sync_level = _ISR_Nest_level;                       
  10bd82:	a1 34 d8 11 00       	mov    0x11d834,%eax                  <== NOT EXECUTED
  10bd87:	a3 54 d8 11 00       	mov    %eax,0x11d854                  <== NOT EXECUTED
  10bd8c:	8b 11                	mov    (%ecx),%edx                    
  10bd8e:	8b 41 04             	mov    0x4(%ecx),%eax                 
  10bd91:	89 42 04             	mov    %eax,0x4(%edx)                 
  10bd94:	89 10                	mov    %edx,(%eax)                    
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
  10bd96:	a1 e8 d8 11 00       	mov    0x11d8e8,%eax                  
  10bd9b:	89 41 18             	mov    %eax,0x18(%ecx)                
                                                                      
  _ISR_Enable( level );                                               
  10bd9e:	56                   	push   %esi                           
  10bd9f:	9d                   	popf                                  
  return( previous_state );                                           
}                                                                     
  10bda0:	89 d8                	mov    %ebx,%eax                      
  10bda2:	5b                   	pop    %ebx                           
  10bda3:	5e                   	pop    %esi                           
  10bda4:	c9                   	leave                                 
  10bda5:	c3                   	ret                                   
                                                                      

0010bda8 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) {
  10bda8:	55                   	push   %ebp                           
  10bda9:	89 e5                	mov    %esp,%ebp                      
  10bdab:	57                   	push   %edi                           
  10bdac:	56                   	push   %esi                           
  10bdad:	53                   	push   %ebx                           
  10bdae:	83 ec 0c             	sub    $0xc,%esp                      
  10bdb1:	8b 7d 08             	mov    0x8(%ebp),%edi                 
   * 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 );                                              
  10bdb4:	9c                   	pushf                                 
  10bdb5:	fa                   	cli                                   
  10bdb6:	5e                   	pop    %esi                           
 *         to obtain the size of                                      
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  10bdb7:	8b 17                	mov    (%edi),%edx                    
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  10bdb9:	8d 47 04             	lea    0x4(%edi),%eax                 
  10bdbc:	89 45 f0             	mov    %eax,-0x10(%ebp)               
                                                                      
  if ( _Chain_Is_empty( header ) )                                    
  10bdbf:	39 c2                	cmp    %eax,%edx                      
  10bdc1:	74 44                	je     10be07 <_Watchdog_Tickle+0x5f> 
  10bdc3:	89 d3                	mov    %edx,%ebx                      
   * 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) {                            
  10bdc5:	8b 42 10             	mov    0x10(%edx),%eax                
  10bdc8:	85 c0                	test   %eax,%eax                      
  10bdca:	74 08                	je     10bdd4 <_Watchdog_Tickle+0x2c> <== NEVER TAKEN
    the_watchdog->delta_interval--;                                   
  10bdcc:	48                   	dec    %eax                           
  10bdcd:	89 42 10             	mov    %eax,0x10(%edx)                
    if ( the_watchdog->delta_interval != 0 )                          
  10bdd0:	85 c0                	test   %eax,%eax                      
  10bdd2:	75 33                	jne    10be07 <_Watchdog_Tickle+0x5f> 
      goto leave;                                                     
  }                                                                   
                                                                      
  do {                                                                
     watchdog_state = _Watchdog_Remove( the_watchdog );               
  10bdd4:	83 ec 0c             	sub    $0xc,%esp                      
  10bdd7:	53                   	push   %ebx                           
  10bdd8:	e8 63 ff ff ff       	call   10bd40 <_Watchdog_Remove>      
                                                                      
     _ISR_Enable( level );                                            
  10bddd:	56                   	push   %esi                           
  10bdde:	9d                   	popf                                  
                                                                      
     switch( watchdog_state ) {                                       
  10bddf:	83 c4 10             	add    $0x10,%esp                     
  10bde2:	83 f8 02             	cmp    $0x2,%eax                      
  10bde5:	75 0e                	jne    10bdf5 <_Watchdog_Tickle+0x4d> <== NEVER TAKEN
       case WATCHDOG_ACTIVE:                                          
         (*the_watchdog->routine)(                                    
  10bde7:	50                   	push   %eax                           
  10bde8:	50                   	push   %eax                           
  10bde9:	ff 73 24             	pushl  0x24(%ebx)                     
  10bdec:	ff 73 20             	pushl  0x20(%ebx)                     
  10bdef:	ff 53 1c             	call   *0x1c(%ebx)                    
  10bdf2:	83 c4 10             	add    $0x10,%esp                     
                                                                      
       case WATCHDOG_REMOVE_IT:                                       
         break;                                                       
     }                                                                
                                                                      
	 _ISR_Disable( level );                                              
  10bdf5:	9c                   	pushf                                 
  10bdf6:	fa                   	cli                                   
  10bdf7:	5e                   	pop    %esi                           
  10bdf8:	8b 07                	mov    (%edi),%eax                    
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
  10bdfa:	3b 45 f0             	cmp    -0x10(%ebp),%eax               
  10bdfd:	74 08                	je     10be07 <_Watchdog_Tickle+0x5f> 
  10bdff:	89 c3                	mov    %eax,%ebx                      
  10be01:	83 78 10 00          	cmpl   $0x0,0x10(%eax)                
  10be05:	eb cb                	jmp    10bdd2 <_Watchdog_Tickle+0x2a> 
                                                                      
leave:                                                                
   _ISR_Enable(level);                                                
  10be07:	56                   	push   %esi                           
  10be08:	9d                   	popf                                  
}                                                                     
  10be09:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10be0c:	5b                   	pop    %ebx                           
  10be0d:	5e                   	pop    %esi                           
  10be0e:	5f                   	pop    %edi                           
  10be0f:	c9                   	leave                                 
  10be10:	c3                   	ret                                   
                                                                      

0010be66 <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) {
  10be66:	55                   	push   %ebp                           
  10be67:	89 e5                	mov    %esp,%ebp                      
  10be69:	57                   	push   %edi                           
  10be6a:	83 ec 14             	sub    $0x14,%esp                     
  10be6d:	8b 55 08             	mov    0x8(%ebp),%edx                 
  uint32_t    memory_available;                                       
                                                                      
  if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
  10be70:	85 d2                	test   %edx,%edx                      
  10be72:	74 05                	je     10be79 <_Workspace_Handler_initialization+0x13>
  10be74:	f6 c2 03             	test   $0x3,%dl                       
  10be77:	74 05                	je     10be7e <_Workspace_Handler_initialization+0x18><== ALWAYS TAKEN
    _Internal_error_Occurred(                                         
  10be79:	51                   	push   %ecx                           
  10be7a:	6a 02                	push   $0x2                           
  10be7c:	eb 2e                	jmp    10beac <_Workspace_Handler_initialization+0x46>
      INTERNAL_ERROR_CORE,                                            
      TRUE,                                                           
      INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS                        
    );                                                                
                                                                      
  if ( _Configuration_Table->do_zero_of_workspace )                   
  10be7e:	a1 30 d8 11 00       	mov    0x11d830,%eax                  
  10be83:	80 78 28 00          	cmpb   $0x0,0x28(%eax)                
  10be87:	74 09                	je     10be92 <_Workspace_Handler_initialization+0x2c><== ALWAYS TAKEN
   memset( starting_address, 0, size );                               
  10be89:	31 c0                	xor    %eax,%eax                      
  10be8b:	89 d7                	mov    %edx,%edi                      <== NOT EXECUTED
  10be8d:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 <== NOT EXECUTED
  10be90:	f3 aa                	rep stos %al,%es:(%edi)               <== NOT EXECUTED
                                                                      
  memory_available = _Heap_Initialize(                                
  10be92:	6a 04                	push   $0x4                           
  10be94:	ff 75 0c             	pushl  0xc(%ebp)                      
  10be97:	52                   	push   %edx                           
  10be98:	68 bc d7 11 00       	push   $0x11d7bc                      
  10be9d:	e8 8a e1 ff ff       	call   10a02c <_Heap_Initialize>      
    starting_address,                                                 
    size,                                                             
    CPU_HEAP_ALIGNMENT                                                
  );                                                                  
                                                                      
  if ( memory_available == 0 )                                        
  10bea2:	83 c4 10             	add    $0x10,%esp                     
  10bea5:	85 c0                	test   %eax,%eax                      
  10bea7:	75 0c                	jne    10beb5 <_Workspace_Handler_initialization+0x4f><== ALWAYS TAKEN
    _Internal_error_Occurred(                                         
  10bea9:	52                   	push   %edx                           <== NOT EXECUTED
  10beaa:	6a 03                	push   $0x3                           <== NOT EXECUTED
  10beac:	6a 01                	push   $0x1                           
  10beae:	6a 00                	push   $0x0                           
  10beb0:	e8 3f e3 ff ff       	call   10a1f4 <_Internal_error_Occurred>
      INTERNAL_ERROR_CORE,                                            
      TRUE,                                                           
      INTERNAL_ERROR_TOO_LITTLE_WORKSPACE                             
    );                                                                
}                                                                     
  10beb5:	8b 7d fc             	mov    -0x4(%ebp),%edi                
  10beb8:	c9                   	leave                                 
  10beb9:	c3                   	ret                                   
                                                                      

001062c2 <__assert>: void __assert( const char *file, int line, const char *failedexpr ) {
  1062c2:	55                   	push   %ebp                           <== NOT EXECUTED
  1062c3:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1062c5:	83 ec 08             	sub    $0x8,%esp                      <== NOT EXECUTED
  __assert_func (file, line, NULL, failedexpr);                       
  1062c8:	ff 75 10             	pushl  0x10(%ebp)                     <== NOT EXECUTED
  1062cb:	6a 00                	push   $0x0                           <== NOT EXECUTED
  1062cd:	ff 75 0c             	pushl  0xc(%ebp)                      <== NOT EXECUTED
  1062d0:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  1062d3:	e8 b0 ff ff ff       	call   106288 <__assert_func>         <== NOT EXECUTED
  1062d8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
}                                                                     
  1062db:	c9                   	leave                                 <== NOT EXECUTED
  1062dc:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00106288 <__assert_func>: const char *file, int line, const char *func, const char *failedexpr ) {
  106288:	55                   	push   %ebp                           
  106289:	89 e5                	mov    %esp,%ebp                      
  10628b:	83 ec 08             	sub    $0x8,%esp                      
  10628e:	8b 45 10             	mov    0x10(%ebp),%eax                
  printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",       
  106291:	ba bd 71 11 00       	mov    $0x1171bd,%edx                 
  106296:	85 c0                	test   %eax,%eax                      
  106298:	75 07                	jne    1062a1 <__assert_func+0x19>    <== ALWAYS TAKEN
  10629a:	ba 55 72 11 00       	mov    $0x117255,%edx                 <== NOT EXECUTED
  10629f:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  1062a1:	51                   	push   %ecx                           
  1062a2:	51                   	push   %ecx                           
  1062a3:	50                   	push   %eax                           
  1062a4:	52                   	push   %edx                           
  1062a5:	ff 75 0c             	pushl  0xc(%ebp)                      
  1062a8:	ff 75 08             	pushl  0x8(%ebp)                      
  1062ab:	ff 75 14             	pushl  0x14(%ebp)                     
  1062ae:	68 ca 71 11 00       	push   $0x1171ca                      
  1062b3:	e8 a6 0d 00 00       	call   10705e <printk>                
    file,                                                             
    line,                                                             
    (func) ? ", function: " : "",                                     
    (func) ? func : ""                                                
  );                                                                  
  rtems_fatal_error_occurred(0);                                      
  1062b8:	83 c4 14             	add    $0x14,%esp                     
  1062bb:	6a 00                	push   $0x0                           
  1062bd:	e8 d2 34 00 00       	call   109794 <rtems_fatal_error_occurred>
                                                                      

0011573a <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini();
  11573a:	55                   	push   %ebp                           
  11573b:	89 e5                	mov    %esp,%ebp                      
  11573d:	83 ec 08             	sub    $0x8,%esp                      
  115740:	e8 28 07 00 00       	call   115e6d <_fini>                 
   *  We need to do the exit processing on the global reentrancy structure.
   *  This has already been done on the per task reentrancy structure 
   *  associated with this task.                                      
   */                                                                 
                                                                      
  libc_wrapup();                                                      
  115745:	e8 8a ff ff ff       	call   1156d4 <libc_wrapup>           
  rtems_shutdown_executive(status);                                   
  11574a:	83 ec 0c             	sub    $0xc,%esp                      
  11574d:	ff 75 08             	pushl  0x8(%ebp)                      
  115750:	e8 d7 00 00 00       	call   11582c <rtems_shutdown_executive>
  115755:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  115758:	eb fe                	jmp    115758 <_exit+0x1e>            <== NOT EXECUTED
                                                                      

001071f6 <_fcntl_r>: struct _reent *ptr, int fd, int cmd, int arg ) {
  1071f6:	55                   	push   %ebp                           <== NOT EXECUTED
  1071f7:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1071f9:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 <== NOT EXECUTED
  1071fc:	8b 55 10             	mov    0x10(%ebp),%edx                <== NOT EXECUTED
  return fcntl( fd, cmd, arg );                                       
  1071ff:	8b 45 14             	mov    0x14(%ebp),%eax                <== NOT EXECUTED
  107202:	89 45 10             	mov    %eax,0x10(%ebp)                <== NOT EXECUTED
  107205:	89 55 0c             	mov    %edx,0xc(%ebp)                 <== NOT EXECUTED
  107208:	89 4d 08             	mov    %ecx,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  10720b:	c9                   	leave                                 <== NOT EXECUTED
  int fd,                                                             
  int cmd,                                                            
  int arg                                                             
)                                                                     
{                                                                     
  return fcntl( fd, cmd, arg );                                       
  10720c:	e9 9f fe ff ff       	jmp    1070b0 <fcntl>                 <== NOT EXECUTED
                                                                      

001180b6 <_getpid_r>: #include <reent.h> pid_t _getpid_r( struct _reent *ptr ) {
  1180b6:	55                   	push   %ebp                           <== NOT EXECUTED
  1180b7:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  return getpid();                                                    
}                                                                     
  1180b9:	b8 01 00 00 00       	mov    $0x1,%eax                      <== NOT EXECUTED
  1180be:	c9                   	leave                                 <== NOT EXECUTED
  1180bf:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010cea4 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) {
  10cea4:	55                   	push   %ebp                           <== NOT EXECUTED
  10cea5:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  return gettimeofday( tp, tzp );                                     
}                                                                     
  10cea7:	c9                   	leave                                 <== NOT EXECUTED
int _gettimeofday(                                                    
  struct timeval  *tp,                                                
  struct timezone *tzp                                                
)                                                                     
{                                                                     
  return gettimeofday( tp, tzp );                                     
  10cea8:	e9 a7 ff ff ff       	jmp    10ce54 <gettimeofday>          <== NOT EXECUTED
                                                                      

00107b86 <_link_r>: int _link_r( struct _reent *ptr, const char *existing, const char *new ) {
  107b86:	55                   	push   %ebp                           <== NOT EXECUTED
  107b87:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107b89:	8b 55 0c             	mov    0xc(%ebp),%edx                 <== NOT EXECUTED
  return link( existing, new );                                       
  107b8c:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  107b8f:	89 45 0c             	mov    %eax,0xc(%ebp)                 <== NOT EXECUTED
  107b92:	89 55 08             	mov    %edx,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  107b95:	c9                   	leave                                 <== NOT EXECUTED
  struct _reent *ptr,                                                 
  const char    *existing,                                            
  const char    *new                                                  
)                                                                     
{                                                                     
  return link( existing, new );                                       
  107b96:	e9 3d fe ff ff       	jmp    1079d8 <link>                  <== NOT EXECUTED
                                                                      

001157f8 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) {
  1157f8:	55                   	push   %ebp                           <== NOT EXECUTED
  1157f9:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1157fb:	8b 55 0c             	mov    0xc(%ebp),%edx                 <== NOT EXECUTED
  return realloc( ptr, size );                                        
  1157fe:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  115801:	89 45 0c             	mov    %eax,0xc(%ebp)                 <== NOT EXECUTED
  115804:	89 55 08             	mov    %edx,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  115807:	c9                   	leave                                 <== NOT EXECUTED
  struct _reent *ignored,                                             
  void          *ptr,                                                 
  size_t         size                                                 
)                                                                     
{                                                                     
  return realloc( ptr, size );                                        
  115808:	e9 4f 00 00 00       	jmp    11585c <realloc>               <== NOT EXECUTED
                                                                      

0010841f <_stat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) {
  10841f:	55                   	push   %ebp                           <== NOT EXECUTED
  108420:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  108422:	8b 55 0c             	mov    0xc(%ebp),%edx                 <== NOT EXECUTED
  return _STAT_NAME( path, buf );                                     
  108425:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  108428:	89 45 0c             	mov    %eax,0xc(%ebp)                 <== NOT EXECUTED
  10842b:	89 55 08             	mov    %edx,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  10842e:	c9                   	leave                                 <== NOT EXECUTED
  struct _reent *ptr,                                                 
  const char    *path,                                                
  struct stat   *buf                                                  
)                                                                     
{                                                                     
  return _STAT_NAME( path, buf );                                     
  10842f:	e9 4c ff ff ff       	jmp    108380 <stat>                  <== NOT EXECUTED
                                                                      

0010b218 <_unlink_r>: int _unlink_r( struct _reent *ptr, const char *path ) {
  10b218:	55                   	push   %ebp                           <== NOT EXECUTED
  10b219:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  return unlink( path );                                              
  10b21b:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  10b21e:	89 45 08             	mov    %eax,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  10b221:	c9                   	leave                                 <== NOT EXECUTED
int _unlink_r(                                                        
  struct _reent *ptr,                                                 
  const char    *path                                                 
)                                                                     
{                                                                     
  return unlink( path );                                              
  10b222:	e9 e9 fe ff ff       	jmp    10b110 <unlink>                <== NOT EXECUTED
                                                                      

00108dc4 <adjtime>: int adjtime( struct timeval *delta, struct timeval *olddelta ) {
  108dc4:	55                   	push   %ebp                           
  108dc5:	89 e5                	mov    %esp,%ebp                      
  108dc7:	57                   	push   %edi                           
  108dc8:	56                   	push   %esi                           
  108dc9:	53                   	push   %ebx                           
  108dca:	83 ec 1c             	sub    $0x1c,%esp                     
  108dcd:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  108dd0:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  long   adjustment;                                                  
                                                                      
  /*                                                                  
   * Simple validations                                               
   */                                                                 
  if ( !delta )                                                       
  108dd3:	85 db                	test   %ebx,%ebx                      
  108dd5:	74 09                	je     108de0 <adjtime+0x1c>          
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )                
  108dd7:	81 7b 04 3f 42 0f 00 	cmpl   $0xf423f,0x4(%ebx)             
  108dde:	76 13                	jbe    108df3 <adjtime+0x2f>          
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  108de0:	e8 47 6a 00 00       	call   10f82c <__errno>               
  108de5:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  108deb:	83 c8 ff             	or     $0xffffffff,%eax               
  108dee:	e9 9e 00 00 00       	jmp    108e91 <adjtime+0xcd>          
                                                                      
  if ( olddelta ) {                                                   
  108df3:	85 f6                	test   %esi,%esi                      
  108df5:	74 0d                	je     108e04 <adjtime+0x40>          
    olddelta->tv_sec  = 0;                                            
  108df7:	c7 06 00 00 00 00    	movl   $0x0,(%esi)                    
    olddelta->tv_usec = 0;                                            
  108dfd:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)                 
  }                                                                   
                                                                      
  /* convert delta to microseconds */                                 
  adjustment  = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);        
  108e04:	69 03 40 42 0f 00    	imul   $0xf4240,(%ebx),%eax           
  adjustment += delta->tv_usec;                                       
                                                                      
  /* too small to account for */                                      
  if ( adjustment < _TOD_Microseconds_per_tick )                      
  108e0a:	03 43 04             	add    0x4(%ebx),%eax                 
  108e0d:	3b 05 74 e7 11 00    	cmp    0x11e774,%eax                  
  108e13:	72 7a                	jb     108e8f <adjtime+0xcb>          
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  108e15:	a1 d8 e5 11 00       	mov    0x11e5d8,%eax                  
  108e1a:	40                   	inc    %eax                           
  108e1b:	a3 d8 e5 11 00       	mov    %eax,0x11e5d8                  
   * This prevents context switches while we are adjusting the TOD    
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
  108e20:	83 ec 0c             	sub    $0xc,%esp                      
  108e23:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  108e26:	50                   	push   %eax                           
  108e27:	e8 30 17 00 00       	call   10a55c <_TOD_Get>              
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
  108e2c:	69 7b 04 e8 03 00 00 	imul   $0x3e8,0x4(%ebx),%edi          
  108e33:	03 7d f0             	add    -0x10(%ebp),%edi               
                                                                      
int  adjtime(                                                         
  struct timeval *delta,                                              
  struct timeval *olddelta                                            
)                                                                     
{                                                                     
  108e36:	b9 00 ca 9a 3b       	mov    $0x3b9aca00,%ecx               
  108e3b:	89 f8                	mov    %edi,%eax                      
  108e3d:	31 d2                	xor    %edx,%edx                      
  108e3f:	f7 f1                	div    %ecx                           
  108e41:	89 45 dc             	mov    %eax,-0x24(%ebp)               
  108e44:	89 c1                	mov    %eax,%ecx                      
  108e46:	03 0b                	add    (%ebx),%ecx                    
  108e48:	03 4d ec             	add    -0x14(%ebp),%ecx               
  108e4b:	69 c0 00 36 65 c4    	imul   $0xc4653600,%eax,%eax          
  108e51:	01 f8                	add    %edi,%eax                      
  108e53:	83 c4 10             	add    $0x10,%esp                     
  108e56:	eb 05                	jmp    108e5d <adjtime+0x99>          
  108e58:	05 00 ca 9a 3b       	add    $0x3b9aca00,%eax               
  108e5d:	89 ca                	mov    %ecx,%edx                      
  108e5f:	49                   	dec    %ecx                           
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
      ts.tv_sec++;                                                    
    }                                                                 
                                                                      
    /* if adjustment is too much negative */                          
    while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {       
  108e60:	3d 00 36 65 c4       	cmp    $0xc4653600,%eax               
  108e65:	76 f1                	jbe    108e58 <adjtime+0x94>          
  108e67:	89 55 ec             	mov    %edx,-0x14(%ebp)               
  108e6a:	89 45 f0             	mov    %eax,-0x10(%ebp)               
      ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;                       
      ts.tv_sec--;                                                    
    }                                                                 
                                                                      
    _TOD_Set( &ts );                                                  
  108e6d:	83 ec 0c             	sub    $0xc,%esp                      
  108e70:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  108e73:	50                   	push   %eax                           
  108e74:	e8 73 17 00 00       	call   10a5ec <_TOD_Set>              
                                                                      
  _Thread_Enable_dispatch();                                          
  108e79:	e8 8a 26 00 00       	call   10b508 <_Thread_Enable_dispatch>
                                                                      
  /* set the user's output */                                         
  if ( olddelta )                                                     
  108e7e:	83 c4 10             	add    $0x10,%esp                     
  108e81:	85 f6                	test   %esi,%esi                      
  108e83:	74 0a                	je     108e8f <adjtime+0xcb>          <== NEVER TAKEN
    *olddelta = *delta;                                               
  108e85:	8b 13                	mov    (%ebx),%edx                    
  108e87:	8b 43 04             	mov    0x4(%ebx),%eax                 
  108e8a:	89 46 04             	mov    %eax,0x4(%esi)                 
  108e8d:	89 16                	mov    %edx,(%esi)                    
  108e8f:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  108e91:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108e94:	5b                   	pop    %ebx                           
  108e95:	5e                   	pop    %esi                           
  108e96:	5f                   	pop    %edi                           
  108e97:	c9                   	leave                                 
  108e98:	c3                   	ret                                   
                                                                      

0010a708 <alarm>: } unsigned int alarm( unsigned int seconds ) {
  10a708:	55                   	push   %ebp                           
  10a709:	89 e5                	mov    %esp,%ebp                      
  10a70b:	53                   	push   %ebx                           
  10a70c:	83 ec 14             	sub    $0x14,%esp                     
                                                                      
  /*                                                                  
   *  Initialize the timer used to implement alarm().                 
   */                                                                 
                                                                      
  if ( !the_timer->routine ) {                                        
  10a70f:	83 3d 04 29 12 00 00 	cmpl   $0x0,0x122904                  
  10a716:	75 2c                	jne    10a744 <alarm+0x3c>            
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10a718:	c7 05 f0 28 12 00 00 	movl   $0x0,0x1228f0                  
  10a71f:	00 00 00                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  10a722:	c7 05 04 29 12 00 a7 	movl   $0x10a7a7,0x122904             
  10a729:	a7 10 00                                                    
 *  @param[in] starting_address is the starting address of the memory for
  10a72c:	c7 05 08 29 12 00 00 	movl   $0x0,0x122908                  
  10a733:	00 00 00                                                    
 *         the heap                                                   
  10a736:	c7 05 0c 29 12 00 00 	movl   $0x0,0x12290c                  
  10a73d:	00 00 00                                                    
  10a740:	31 db                	xor    %ebx,%ebx                      
  10a742:	eb 43                	jmp    10a787 <alarm+0x7f>            
    _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
  } else {                                                            
    switch ( _Watchdog_Remove( the_timer ) ) {                        
  10a744:	83 ec 0c             	sub    $0xc,%esp                      
  10a747:	68 e8 28 12 00       	push   $0x1228e8                      
  10a74c:	e8 e3 41 00 00       	call   10e934 <_Watchdog_Remove>      
  10a751:	83 c4 10             	add    $0x10,%esp                     
  10a754:	83 e8 02             	sub    $0x2,%eax                      
  10a757:	31 db                	xor    %ebx,%ebx                      
  10a759:	83 f8 01             	cmp    $0x1,%eax                      
  10a75c:	77 29                	ja     10a787 <alarm+0x7f>            <== NEVER TAKEN
         *  The stop_time and start_time fields are snapshots of ticks since
         *  boot.  Since alarm() is dealing in seconds, we must account for
         *  this.                                                     
         */                                                           
                                                                      
        remaining = the_timer->initial -                              
  10a75e:	8b 0d 00 29 12 00    	mov    0x122900,%ecx                  
  10a764:	2b 0d fc 28 12 00    	sub    0x1228fc,%ecx                  
  10a76a:	b8 40 42 0f 00       	mov    $0xf4240,%eax                  
  10a76f:	31 d2                	xor    %edx,%edx                      
  10a771:	f7 35 64 2b 12 00    	divl   0x122b64                       
  10a777:	89 c3                	mov    %eax,%ebx                      
  10a779:	89 c8                	mov    %ecx,%eax                      
  10a77b:	31 d2                	xor    %edx,%edx                      
  10a77d:	f7 f3                	div    %ebx                           
  10a77f:	8b 1d f4 28 12 00    	mov    0x1228f4,%ebx                  
  10a785:	29 c3                	sub    %eax,%ebx                      
 *  @return TRUE if successfully able to resize the block.            
 *          FALSE if the block can't be resized in place.             
 */                                                                   
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  10a787:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10a78a:	a3 f4 28 12 00       	mov    %eax,0x1228f4                  
  size_t        size                                                  
);                                                                    
  10a78f:	50                   	push   %eax                           
  10a790:	50                   	push   %eax                           
  10a791:	68 e8 28 12 00       	push   $0x1228e8                      
  10a796:	68 9c 2a 12 00       	push   $0x122a9c                      
  10a79b:	e8 7c 40 00 00       	call   10e81c <_Watchdog_Insert>      
  }                                                                   
                                                                      
  _Watchdog_Insert_seconds( the_timer, seconds );                     
                                                                      
  return remaining;                                                   
}                                                                     
  10a7a0:	89 d8                	mov    %ebx,%eax                      
  10a7a2:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10a7a5:	c9                   	leave                                 
  10a7a6:	c3                   	ret                                   
                                                                      

00108e24 <alphasort>: */ int alphasort( const void *d1, const void *d2 ) {
  108e24:	55                   	push   %ebp                           <== NOT EXECUTED
  108e25:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
	return(strcmp((*(struct dirent **)d1)->d_name,                       
  108e27:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  108e2a:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
  108e2c:	83 c0 0c             	add    $0xc,%eax                      <== NOT EXECUTED
  108e2f:	89 45 0c             	mov    %eax,0xc(%ebp)                 <== NOT EXECUTED
  108e32:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  108e35:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
  108e37:	83 c0 0c             	add    $0xc,%eax                      <== NOT EXECUTED
  108e3a:	89 45 08             	mov    %eax,0x8(%ebp)                 <== NOT EXECUTED
	    (*(struct dirent **)d2)->d_name));                               
}                                                                     
  108e3d:	c9                   	leave                                 <== NOT EXECUTED
int                                                                   
alphasort(                                                            
	const void *d1,                                                      
	const void *d2 )                                                     
{                                                                     
	return(strcmp((*(struct dirent **)d1)->d_name,                       
  108e3e:	e9 55 a8 00 00       	jmp    113698 <strcmp>                <== NOT EXECUTED
                                                                      

0010ccd0 <calloc>: ) { register char *cptr; int length; MSBUMP(calloc_calls, 1);
  10ccd0:	55                   	push   %ebp                           
  10ccd1:	89 e5                	mov    %esp,%ebp                      
  10ccd3:	57                   	push   %edi                           
  10ccd4:	53                   	push   %ebx                           
  10ccd5:	83 ec 1c             	sub    $0x1c,%esp                     
  10ccd8:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10ccdb:	ff 05 bc d6 11 00    	incl   0x11d6bc                       
                                                                      
  length = nelem * elsize;                                            
  10cce1:	0f af 5d 08          	imul   0x8(%ebp),%ebx                 
  cptr = malloc( length );                                            
  10cce5:	53                   	push   %ebx                           
  10cce6:	e8 89 99 ff ff       	call   106674 <malloc>                
  10cceb:	89 c2                	mov    %eax,%edx                      
  if ( cptr )                                                         
  10cced:	83 c4 10             	add    $0x10,%esp                     
  10ccf0:	85 c0                	test   %eax,%eax                      
  10ccf2:	74 08                	je     10ccfc <calloc+0x2c>           <== NEVER TAKEN
    memset( cptr, '\0', length );                                     
  10ccf4:	31 c0                	xor    %eax,%eax                      
  10ccf6:	89 d7                	mov    %edx,%edi                      
  10ccf8:	89 d9                	mov    %ebx,%ecx                      
  10ccfa:	f3 aa                	rep stos %al,%es:(%edi)               
                                                                      
  MSBUMP(malloc_calls, -1);   /* subtract off the malloc */           
  10ccfc:	ff 0d ac d6 11 00    	decl   0x11d6ac                       
                                                                      
  return cptr;                                                        
}                                                                     
  10cd02:	89 d0                	mov    %edx,%eax                      
  10cd04:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10cd07:	5b                   	pop    %ebx                           
  10cd08:	5f                   	pop    %edi                           
  10cd09:	c9                   	leave                                 
  10cd0a:	c3                   	ret                                   
                                                                      

0010dc74 <chdir>: #include <rtems/seterr.h> int chdir( const char *pathname ) {
  10dc74:	55                   	push   %ebp                           
  10dc75:	89 e5                	mov    %esp,%ebp                      
  10dc77:	57                   	push   %edi                           
  10dc78:	56                   	push   %esi                           
  10dc79:	83 ec 10             	sub    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Get the node where we wish to go.                               
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path(                            
  10dc7c:	6a 01                	push   $0x1                           
  10dc7e:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  10dc81:	56                   	push   %esi                           
  10dc82:	6a 01                	push   $0x1                           
  10dc84:	ff 75 08             	pushl  0x8(%ebp)                      
  10dc87:	e8 26 8e ff ff       	call   106ab2 <rtems_filesystem_evaluate_path>
    pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true );                 
  if ( result != 0 )                                                  
  10dc8c:	83 c4 10             	add    $0x10,%esp                     
  10dc8f:	83 ca ff             	or     $0xffffffff,%edx               
  10dc92:	85 c0                	test   %eax,%eax                      
  10dc94:	0f 85 8d 00 00 00    	jne    10dd27 <chdir+0xb3>            
                                                                      
  /*                                                                  
   * Verify you can change directory into this node.                  
   */                                                                 
                                                                      
  if ( !loc.ops->node_type_h ) {                                      
  10dc9a:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10dc9d:	8b 50 10             	mov    0x10(%eax),%edx                
  10dca0:	85 d2                	test   %edx,%edx                      
  10dca2:	75 1d                	jne    10dcc1 <chdir+0x4d>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  10dca4:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  10dca7:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10dca9:	74 09                	je     10dcb4 <chdir+0x40>            <== NOT EXECUTED
  10dcab:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10dcae:	56                   	push   %esi                           <== NOT EXECUTED
  10dcaf:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10dcb1:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10dcb4:	e8 f7 2c 00 00       	call   1109b0 <__errno>               <== NOT EXECUTED
  10dcb9:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10dcbf:	eb 2e                	jmp    10dcef <chdir+0x7b>            <== NOT EXECUTED
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
  10dcc1:	83 ec 0c             	sub    $0xc,%esp                      
  10dcc4:	56                   	push   %esi                           
  10dcc5:	ff d2                	call   *%edx                          
  10dcc7:	83 c4 10             	add    $0x10,%esp                     
  10dcca:	48                   	dec    %eax                           
  10dccb:	74 27                	je     10dcf4 <chdir+0x80>            
    rtems_filesystem_freenode( &loc );                                
  10dccd:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10dcd0:	85 c0                	test   %eax,%eax                      
  10dcd2:	74 10                	je     10dce4 <chdir+0x70>            <== NEVER TAKEN
  10dcd4:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10dcd7:	85 c0                	test   %eax,%eax                      
  10dcd9:	74 09                	je     10dce4 <chdir+0x70>            <== NEVER TAKEN
  10dcdb:	83 ec 0c             	sub    $0xc,%esp                      
  10dcde:	56                   	push   %esi                           
  10dcdf:	ff d0                	call   *%eax                          
  10dce1:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  10dce4:	e8 c7 2c 00 00       	call   1109b0 <__errno>               
  10dce9:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   
  10dcef:	83 ca ff             	or     $0xffffffff,%edx               
  10dcf2:	eb 33                	jmp    10dd27 <chdir+0xb3>            
  }                                                                   
                                                                      
  rtems_filesystem_freenode( &rtems_filesystem_current );             
  10dcf4:	a1 ac e3 11 00       	mov    0x11e3ac,%eax                  
  10dcf9:	8b 50 0c             	mov    0xc(%eax),%edx                 
  10dcfc:	85 d2                	test   %edx,%edx                      
  10dcfe:	74 13                	je     10dd13 <chdir+0x9f>            <== NEVER TAKEN
  10dd00:	8b 52 1c             	mov    0x1c(%edx),%edx                
  10dd03:	85 d2                	test   %edx,%edx                      
  10dd05:	74 0c                	je     10dd13 <chdir+0x9f>            <== NEVER TAKEN
  10dd07:	83 ec 0c             	sub    $0xc,%esp                      
  10dd0a:	83 c0 04             	add    $0x4,%eax                      
  10dd0d:	50                   	push   %eax                           
  10dd0e:	ff d2                	call   *%edx                          
  10dd10:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  rtems_filesystem_current = loc;                                     
  10dd13:	a1 ac e3 11 00       	mov    0x11e3ac,%eax                  
  10dd18:	8d 78 04             	lea    0x4(%eax),%edi                 
  10dd1b:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  10dd1e:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10dd23:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  10dd25:	31 d2                	xor    %edx,%edx                      
                                                                      
  return 0;                                                           
}                                                                     
  10dd27:	89 d0                	mov    %edx,%eax                      
  10dd29:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10dd2c:	5e                   	pop    %esi                           
  10dd2d:	5f                   	pop    %edi                           
  10dd2e:	c9                   	leave                                 
  10dd2f:	c3                   	ret                                   
                                                                      

00108000 <chmod>: int chmod( const char *path, mode_t mode ) {
  108000:	55                   	push   %ebp                           
  108001:	89 e5                	mov    %esp,%ebp                      
  108003:	56                   	push   %esi                           
  108004:	53                   	push   %ebx                           
  108005:	83 ec 10             	sub    $0x10,%esp                     
  int                              status;                            
  rtems_filesystem_location_info_t loc;                               
  int                              result;                            
                                                                      
  status = rtems_filesystem_evaluate_path( path, 0, &loc, true );     
  108008:	6a 01                	push   $0x1                           
  10800a:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  10800d:	56                   	push   %esi                           
  10800e:	6a 00                	push   $0x0                           
  108010:	ff 75 08             	pushl  0x8(%ebp)                      
  108013:	e8 92 01 00 00       	call   1081aa <rtems_filesystem_evaluate_path>
  if ( status != 0 )                                                  
  108018:	83 c4 10             	add    $0x10,%esp                     
  10801b:	83 cb ff             	or     $0xffffffff,%ebx               
  10801e:	85 c0                	test   %eax,%eax                      
  108020:	75 7d                	jne    10809f <chmod+0x9f>            
    return -1;                                                        
                                                                      
  if ( !loc.handlers ){                                               
  108022:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  108025:	85 c0                	test   %eax,%eax                      
  108027:	75 24                	jne    10804d <chmod+0x4d>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  108029:	8b 45 f0             	mov    -0x10(%ebp),%eax               <== NOT EXECUTED
  10802c:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10802e:	74 10                	je     108040 <chmod+0x40>            <== NOT EXECUTED
  108030:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  108033:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108035:	74 09                	je     108040 <chmod+0x40>            <== NOT EXECUTED
  108037:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10803a:	56                   	push   %esi                           <== NOT EXECUTED
  10803b:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10803d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBADF );                    
  108040:	e8 2b a6 00 00       	call   112670 <__errno>               <== NOT EXECUTED
  108045:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  10804b:	eb 29                	jmp    108076 <chmod+0x76>            <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( !loc.handlers->fchmod_h ){                                     
  10804d:	8b 40 1c             	mov    0x1c(%eax),%eax                
  108050:	85 c0                	test   %eax,%eax                      
  108052:	75 27                	jne    10807b <chmod+0x7b>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  108054:	8b 45 f0             	mov    -0x10(%ebp),%eax               <== NOT EXECUTED
  108057:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108059:	74 10                	je     10806b <chmod+0x6b>            <== NOT EXECUTED
  10805b:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  10805e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108060:	74 09                	je     10806b <chmod+0x6b>            <== NOT EXECUTED
  108062:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108065:	56                   	push   %esi                           <== NOT EXECUTED
  108066:	ff d0                	call   *%eax                          <== NOT EXECUTED
  108068:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10806b:	e8 00 a6 00 00       	call   112670 <__errno>               <== NOT EXECUTED
  108070:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  108076:	83 cb ff             	or     $0xffffffff,%ebx               <== NOT EXECUTED
  108079:	eb 24                	jmp    10809f <chmod+0x9f>            <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*loc.handlers->fchmod_h)( &loc, mode );                   
  10807b:	52                   	push   %edx                           
  10807c:	52                   	push   %edx                           
  10807d:	ff 75 0c             	pushl  0xc(%ebp)                      
  108080:	56                   	push   %esi                           
  108081:	ff d0                	call   *%eax                          
  108083:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  108085:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  108088:	83 c4 10             	add    $0x10,%esp                     
  10808b:	85 c0                	test   %eax,%eax                      
  10808d:	74 10                	je     10809f <chmod+0x9f>            <== NEVER TAKEN
  10808f:	8b 40 1c             	mov    0x1c(%eax),%eax                
  108092:	85 c0                	test   %eax,%eax                      
  108094:	74 09                	je     10809f <chmod+0x9f>            <== NEVER TAKEN
  108096:	83 ec 0c             	sub    $0xc,%esp                      
  108099:	56                   	push   %esi                           
  10809a:	ff d0                	call   *%eax                          
  10809c:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  10809f:	89 d8                	mov    %ebx,%eax                      
  1080a1:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1080a4:	5b                   	pop    %ebx                           
  1080a5:	5e                   	pop    %esi                           
  1080a6:	c9                   	leave                                 
  1080a7:	c3                   	ret                                   
                                                                      

001080a8 <chown>: int chown( const char *path, uid_t owner, gid_t group ) {
  1080a8:	55                   	push   %ebp                           
  1080a9:	89 e5                	mov    %esp,%ebp                      
  1080ab:	57                   	push   %edi                           
  1080ac:	56                   	push   %esi                           
  1080ad:	53                   	push   %ebx                           
  1080ae:	83 ec 1c             	sub    $0x1c,%esp                     
  1080b1:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1080b4:	66 89 45 e2          	mov    %ax,-0x1e(%ebp)                
  1080b8:	8b 7d 10             	mov    0x10(%ebp),%edi                
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
                                                                      
  if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) )     
  1080bb:	6a 01                	push   $0x1                           
  1080bd:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  1080c0:	56                   	push   %esi                           
  1080c1:	6a 00                	push   $0x0                           
  1080c3:	ff 75 08             	pushl  0x8(%ebp)                      
  1080c6:	e8 df 00 00 00       	call   1081aa <rtems_filesystem_evaluate_path>
  1080cb:	83 c4 10             	add    $0x10,%esp                     
  1080ce:	83 cb ff             	or     $0xffffffff,%ebx               
  1080d1:	85 c0                	test   %eax,%eax                      
  1080d3:	75 53                	jne    108128 <chown+0x80>            
    return -1;                                                        
                                                                      
  if ( !loc.ops->chown_h ) {                                          
  1080d5:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  1080d8:	8b 50 18             	mov    0x18(%eax),%edx                
  1080db:	85 d2                	test   %edx,%edx                      
  1080dd:	75 20                	jne    1080ff <chown+0x57>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  1080df:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  1080e2:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1080e4:	74 09                	je     1080ef <chown+0x47>            <== NOT EXECUTED
  1080e6:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1080e9:	56                   	push   %esi                           <== NOT EXECUTED
  1080ea:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1080ec:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  1080ef:	e8 7c a5 00 00       	call   112670 <__errno>               <== NOT EXECUTED
  1080f4:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1080fa:	83 cb ff             	or     $0xffffffff,%ebx               <== NOT EXECUTED
  1080fd:	eb 29                	jmp    108128 <chown+0x80>            <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*loc.ops->chown_h)( &loc, owner, group );                 
  1080ff:	50                   	push   %eax                           
  108100:	0f b7 c7             	movzwl %di,%eax                       
  108103:	50                   	push   %eax                           
  108104:	0f b7 45 e2          	movzwl -0x1e(%ebp),%eax               
  108108:	50                   	push   %eax                           
  108109:	56                   	push   %esi                           
  10810a:	ff d2                	call   *%edx                          
  10810c:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  10810e:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  108111:	83 c4 10             	add    $0x10,%esp                     
  108114:	85 c0                	test   %eax,%eax                      
  108116:	74 10                	je     108128 <chown+0x80>            <== NEVER TAKEN
  108118:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10811b:	85 c0                	test   %eax,%eax                      
  10811d:	74 09                	je     108128 <chown+0x80>            <== NEVER TAKEN
  10811f:	83 ec 0c             	sub    $0xc,%esp                      
  108122:	56                   	push   %esi                           
  108123:	ff d0                	call   *%eax                          
  108125:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  108128:	89 d8                	mov    %ebx,%eax                      
  10812a:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10812d:	5b                   	pop    %ebx                           
  10812e:	5e                   	pop    %esi                           
  10812f:	5f                   	pop    %edi                           
  108130:	c9                   	leave                                 
  108131:	c3                   	ret                                   
                                                                      

00106908 <chroot>: #include <rtems/seterr.h> int chroot( const char *pathname ) {
  106908:	55                   	push   %ebp                           
  106909:	89 e5                	mov    %esp,%ebp                      
  10690b:	57                   	push   %edi                           
  10690c:	56                   	push   %esi                           
  10690d:	53                   	push   %ebx                           
  10690e:	83 ec 1c             	sub    $0x1c,%esp                     
  int                               result;                           
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /* an automatic call to new private env the first time */           
  if (rtems_current_user_env == &rtems_global_user_env) {             
  106911:	81 3d ac e3 11 00 00 	cmpl   $0x120a00,0x11e3ac             
  106918:	0a 12 00                                                    
  10691b:	75 1e                	jne    10693b <chroot+0x33>           <== NEVER TAKEN
   rtems_libio_set_private_env(); /* try to set a new private env*/   
  10691d:	e8 47 12 00 00       	call   107b69 <rtems_libio_set_private_env>
   if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 
  106922:	81 3d ac e3 11 00 00 	cmpl   $0x120a00,0x11e3ac             
  106929:	0a 12 00                                                    
  10692c:	75 0d                	jne    10693b <chroot+0x33>           <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10692e:	e8 7d a0 00 00       	call   1109b0 <__errno>               <== NOT EXECUTED
  106933:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  106939:	eb 22                	jmp    10695d <chroot+0x55>           <== NOT EXECUTED
  }                                                                   
                                                                      
  result = chdir(pathname);                                           
  10693b:	83 ec 0c             	sub    $0xc,%esp                      
  10693e:	ff 75 08             	pushl  0x8(%ebp)                      
  106941:	e8 2e 73 00 00       	call   10dc74 <chdir>                 
  if (result) {                                                       
  106946:	83 c4 10             	add    $0x10,%esp                     
  106949:	85 c0                	test   %eax,%eax                      
  10694b:	74 15                	je     106962 <chroot+0x5a>           <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( errno );                    
  10694d:	e8 5e a0 00 00       	call   1109b0 <__errno>               <== NOT EXECUTED
  106952:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
  106954:	e8 57 a0 00 00       	call   1109b0 <__errno>               <== NOT EXECUTED
  106959:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
  10695b:	89 03                	mov    %eax,(%ebx)                    <== NOT EXECUTED
  10695d:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  106960:	eb 4c                	jmp    1069ae <chroot+0xa6>           <== NOT EXECUTED
  }                                                                   
                                                                      
  /* clone the new root location */                                   
  if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) {              
  106962:	6a 00                	push   $0x0                           
  106964:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  106967:	50                   	push   %eax                           
  106968:	6a 00                	push   $0x0                           
  10696a:	68 f9 9c 11 00       	push   $0x119cf9                      
  10696f:	e8 3e 01 00 00       	call   106ab2 <rtems_filesystem_evaluate_path>
  106974:	83 c4 10             	add    $0x10,%esp                     
  106977:	85 c0                	test   %eax,%eax                      
  106979:	75 d2                	jne    10694d <chroot+0x45>           <== NEVER TAKEN
    /* our cwd has changed, though - but there is no easy way of return :-( */
    rtems_set_errno_and_return_minus_one( errno );                    
  }                                                                   
  rtems_filesystem_freenode(&rtems_filesystem_root);                  
  10697b:	a1 ac e3 11 00       	mov    0x11e3ac,%eax                  
  106980:	8b 50 1c             	mov    0x1c(%eax),%edx                
  106983:	85 d2                	test   %edx,%edx                      
  106985:	74 13                	je     10699a <chroot+0x92>           <== NEVER TAKEN
  106987:	8b 52 1c             	mov    0x1c(%edx),%edx                
  10698a:	85 d2                	test   %edx,%edx                      
  10698c:	74 0c                	je     10699a <chroot+0x92>           <== NEVER TAKEN
  10698e:	83 ec 0c             	sub    $0xc,%esp                      
  106991:	83 c0 14             	add    $0x14,%eax                     
  106994:	50                   	push   %eax                           
  106995:	ff d2                	call   *%edx                          
  106997:	83 c4 10             	add    $0x10,%esp                     
  rtems_filesystem_root = loc;                                        
  10699a:	a1 ac e3 11 00       	mov    0x11e3ac,%eax                  
  10699f:	8d 78 14             	lea    0x14(%eax),%edi                
  1069a2:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  1069a5:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  1069aa:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  1069ac:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  1069ae:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1069b1:	5b                   	pop    %ebx                           
  1069b2:	5e                   	pop    %esi                           
  1069b3:	5f                   	pop    %edi                           
  1069b4:	c9                   	leave                                 
  1069b5:	c3                   	ret                                   
                                                                      

0010985c <clock_gettime>: int clock_gettime( clockid_t clock_id, struct timespec *tp ) {
  10985c:	55                   	push   %ebp                           
  10985d:	89 e5                	mov    %esp,%ebp                      
  10985f:	83 ec 08             	sub    $0x8,%esp                      
  109862:	8b 45 08             	mov    0x8(%ebp),%eax                 
  109865:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  if ( !tp )                                                          
  109868:	85 d2                	test   %edx,%edx                      
  10986a:	74 3c                	je     1098a8 <clock_gettime+0x4c>    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME )                                   
  10986c:	83 f8 01             	cmp    $0x1,%eax                      
  10986f:	75 0b                	jne    10987c <clock_gettime+0x20>    
    _TOD_Get(tp);                                                     
  109871:	83 ec 0c             	sub    $0xc,%esp                      
  109874:	52                   	push   %edx                           
  109875:	e8 06 20 00 00       	call   10b880 <_TOD_Get>              
  10987a:	eb 13                	jmp    10988f <clock_gettime+0x33>    
#ifdef CLOCK_MONOTONIC                                                
  else if ( clock_id == CLOCK_MONOTONIC )                             
  10987c:	83 f8 04             	cmp    $0x4,%eax                      
  10987f:	74 05                	je     109886 <clock_gettime+0x2a>    <== NEVER TAKEN
    _TOD_Get_uptime(tp);                                              
#endif                                                                
#ifdef _POSIX_CPUTIME                                                 
  else if ( clock_id == CLOCK_PROCESS_CPUTIME )                       
  109881:	83 f8 02             	cmp    $0x2,%eax                      
  109884:	75 10                	jne    109896 <clock_gettime+0x3a>    
    _TOD_Get_uptime(tp);                                              
  109886:	83 ec 0c             	sub    $0xc,%esp                      
  109889:	52                   	push   %edx                           
  10988a:	e8 45 20 00 00       	call   10b8d4 <_TOD_Get_uptime>       
  10988f:	31 c0                	xor    %eax,%eax                      
  109891:	83 c4 10             	add    $0x10,%esp                     
  109894:	eb 20                	jmp    1098b6 <clock_gettime+0x5a>    
#endif                                                                
#ifdef _POSIX_THREAD_CPUTIME                                          
  else if ( clock_id == CLOCK_THREAD_CPUTIME )                        
  109896:	83 f8 03             	cmp    $0x3,%eax                      
  109899:	75 0d                	jne    1098a8 <clock_gettime+0x4c>    
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
  10989b:	e8 60 6f 00 00       	call   110800 <__errno>               
  1098a0:	c7 00 58 00 00 00    	movl   $0x58,(%eax)                   
  1098a6:	eb 0b                	jmp    1098b3 <clock_gettime+0x57>    
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  1098a8:	e8 53 6f 00 00       	call   110800 <__errno>               
  1098ad:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  1098b3:	83 c8 ff             	or     $0xffffffff,%eax               
                                                                      
  return 0;                                                           
}                                                                     
  1098b6:	c9                   	leave                                 
  1098b7:	c3                   	ret                                   
                                                                      

001098b8 <clock_settime>: int clock_settime( clockid_t clock_id, const struct timespec *tp ) {
  1098b8:	55                   	push   %ebp                           
  1098b9:	89 e5                	mov    %esp,%ebp                      
  1098bb:	83 ec 08             	sub    $0x8,%esp                      
  1098be:	8b 45 08             	mov    0x8(%ebp),%eax                 
  1098c1:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  if ( !tp )                                                          
  1098c4:	85 d2                	test   %edx,%edx                      
  1098c6:	74 44                	je     10990c <clock_settime+0x54>    <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
  1098c8:	83 f8 01             	cmp    $0x1,%eax                      
  1098cb:	75 28                	jne    1098f5 <clock_settime+0x3d>    
    if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )                 
  1098cd:	81 3a ff e4 da 21    	cmpl   $0x21dae4ff,(%edx)             
  1098d3:	76 37                	jbe    10990c <clock_settime+0x54>    
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  1098d5:	a1 f0 10 12 00       	mov    0x1210f0,%eax                  
  1098da:	40                   	inc    %eax                           
  1098db:	a3 f0 10 12 00       	mov    %eax,0x1210f0                  
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    _Thread_Disable_dispatch();                                       
      _TOD_Set( tp );                                                 
  1098e0:	83 ec 0c             	sub    $0xc,%esp                      
  1098e3:	52                   	push   %edx                           
  1098e4:	e8 7b 20 00 00       	call   10b964 <_TOD_Set>              
    _Thread_Enable_dispatch();                                        
  1098e9:	e8 92 2f 00 00       	call   10c880 <_Thread_Enable_dispatch>
  1098ee:	31 c0                	xor    %eax,%eax                      
  1098f0:	83 c4 10             	add    $0x10,%esp                     
  1098f3:	eb 25                	jmp    10991a <clock_settime+0x62>    
  }                                                                   
#ifdef _POSIX_CPUTIME                                                 
  else if ( clock_id == CLOCK_PROCESS_CPUTIME )                       
  1098f5:	83 f8 02             	cmp    $0x2,%eax                      
  1098f8:	74 05                	je     1098ff <clock_settime+0x47>    
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
#ifdef _POSIX_THREAD_CPUTIME                                          
  else if ( clock_id == CLOCK_THREAD_CPUTIME )                        
  1098fa:	83 f8 03             	cmp    $0x3,%eax                      
  1098fd:	75 0d                	jne    10990c <clock_settime+0x54>    
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
  1098ff:	e8 fc 6e 00 00       	call   110800 <__errno>               
  109904:	c7 00 58 00 00 00    	movl   $0x58,(%eax)                   
  10990a:	eb 0b                	jmp    109917 <clock_settime+0x5f>    
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10990c:	e8 ef 6e 00 00       	call   110800 <__errno>               
  109911:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  109917:	83 c8 ff             	or     $0xffffffff,%eax               
                                                                      
  return 0;                                                           
}                                                                     
  10991a:	c9                   	leave                                 
  10991b:	c3                   	ret                                   
                                                                      

0010cd0c <close>: #include <rtems/libio_.h> int close( int fd ) {
  10cd0c:	55                   	push   %ebp                           
  10cd0d:	89 e5                	mov    %esp,%ebp                      
  10cd0f:	56                   	push   %esi                           
  10cd10:	53                   	push   %ebx                           
  10cd11:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_t      *iop;                                            
  rtems_status_code   rc;                                             
                                                                      
  rtems_libio_check_fd(fd);                                           
  10cd14:	3b 05 d8 92 11 00    	cmp    0x1192d8,%eax                  
  10cd1a:	73 0f                	jae    10cd2b <close+0x1f>            
  iop = rtems_libio_iop(fd);                                          
  10cd1c:	6b d8 34             	imul   $0x34,%eax,%ebx                
  10cd1f:	03 1d 38 d6 11 00    	add    0x11d638,%ebx                  
  rtems_libio_check_is_open(iop);                                     
  10cd25:	f6 43 0d 01          	testb  $0x1,0xd(%ebx)                 
  10cd29:	75 10                	jne    10cd3b <close+0x2f>            
  10cd2b:	e8 f8 23 00 00       	call   10f128 <__errno>               
  10cd30:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    
  10cd36:	83 c8 ff             	or     $0xffffffff,%eax               
  10cd39:	eb 3f                	jmp    10cd7a <close+0x6e>            
                                                                      
  rc = RTEMS_SUCCESSFUL;                                              
  if ( iop->handlers->close_h )                                       
  10cd3b:	8b 43 30             	mov    0x30(%ebx),%eax                
  10cd3e:	8b 40 04             	mov    0x4(%eax),%eax                 
  10cd41:	31 f6                	xor    %esi,%esi                      
  10cd43:	85 c0                	test   %eax,%eax                      
  10cd45:	74 0b                	je     10cd52 <close+0x46>            <== NEVER TAKEN
    rc = (*iop->handlers->close_h)( iop );                            
  10cd47:	83 ec 0c             	sub    $0xc,%esp                      
  10cd4a:	53                   	push   %ebx                           
  10cd4b:	ff d0                	call   *%eax                          
  10cd4d:	89 c6                	mov    %eax,%esi                      
  10cd4f:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  rtems_filesystem_freenode( &iop->pathinfo );                        
  10cd52:	8b 43 18             	mov    0x18(%ebx),%eax                
  10cd55:	85 c0                	test   %eax,%eax                      
  10cd57:	74 13                	je     10cd6c <close+0x60>            <== NEVER TAKEN
  10cd59:	8b 50 1c             	mov    0x1c(%eax),%edx                
  10cd5c:	85 d2                	test   %edx,%edx                      
  10cd5e:	74 0c                	je     10cd6c <close+0x60>            
  10cd60:	83 ec 0c             	sub    $0xc,%esp                      
  10cd63:	8d 43 10             	lea    0x10(%ebx),%eax                
  10cd66:	50                   	push   %eax                           
  10cd67:	ff d2                	call   *%edx                          
  10cd69:	83 c4 10             	add    $0x10,%esp                     
  rtems_libio_free( iop );                                            
  10cd6c:	83 ec 0c             	sub    $0xc,%esp                      
  10cd6f:	53                   	push   %ebx                           
  10cd70:	e8 47 02 00 00       	call   10cfbc <rtems_libio_free>      
                                                                      
  return rc;                                                          
  10cd75:	89 f0                	mov    %esi,%eax                      
  10cd77:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  10cd7a:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10cd7d:	5b                   	pop    %ebx                           
  10cd7e:	5e                   	pop    %esi                           
  10cd7f:	c9                   	leave                                 
  10cd80:	c3                   	ret                                   
                                                                      

001073e4 <closedir>: * close a directory. */ int closedir( DIR *dirp ) {
  1073e4:	55                   	push   %ebp                           
  1073e5:	89 e5                	mov    %esp,%ebp                      
  1073e7:	56                   	push   %esi                           
  1073e8:	53                   	push   %ebx                           
  1073e9:	8b 75 08             	mov    0x8(%ebp),%esi                 
	int fd;                                                              
                                                                      
        if ( !dirp )                                                  
  1073ec:	85 f6                	test   %esi,%esi                      
  1073ee:	75 15                	jne    107405 <closedir+0x21>         <== ALWAYS TAKEN
          rtems_set_errno_and_return_minus_one( EBADF );              
  1073f0:	e8 bb a1 00 00       	call   1115b0 <__errno>               <== NOT EXECUTED
  1073f5:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
	dirp->dd_fd = -1;                                                    
	dirp->dd_loc = 0;                                                    
	(void)free((void *)dirp->dd_buf);                                    
	(void)free((void *)dirp);                                            
	return(close(fd));                                                   
}                                                                     
  1073fb:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  1073fe:	8d 65 f8             	lea    -0x8(%ebp),%esp                <== NOT EXECUTED
  107401:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107402:	5e                   	pop    %esi                           <== NOT EXECUTED
  107403:	c9                   	leave                                 <== NOT EXECUTED
  107404:	c3                   	ret                                   <== NOT EXECUTED
	int fd;                                                              
                                                                      
        if ( !dirp )                                                  
          rtems_set_errno_and_return_minus_one( EBADF );              
                                                                      
	fd = dirp->dd_fd;                                                    
  107405:	8b 1e                	mov    (%esi),%ebx                    
	dirp->dd_fd = -1;                                                    
  107407:	c7 06 ff ff ff ff    	movl   $0xffffffff,(%esi)             
	dirp->dd_loc = 0;                                                    
  10740d:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)                 
	(void)free((void *)dirp->dd_buf);                                    
  107414:	83 ec 0c             	sub    $0xc,%esp                      
  107417:	ff 76 0c             	pushl  0xc(%esi)                      
  10741a:	e8 35 02 00 00       	call   107654 <free>                  
	(void)free((void *)dirp);                                            
  10741f:	89 34 24             	mov    %esi,(%esp)                    
  107422:	e8 2d 02 00 00       	call   107654 <free>                  
	return(close(fd));                                                   
  107427:	83 c4 10             	add    $0x10,%esp                     
  10742a:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
}                                                                     
  10742d:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  107430:	5b                   	pop    %ebx                           
  107431:	5e                   	pop    %esi                           
  107432:	c9                   	leave                                 
	fd = dirp->dd_fd;                                                    
	dirp->dd_fd = -1;                                                    
	dirp->dd_loc = 0;                                                    
	(void)free((void *)dirp->dd_buf);                                    
	(void)free((void *)dirp);                                            
	return(close(fd));                                                   
  107433:	e9 00 00 00 00       	jmp    107438 <close>                 
                                                                      

0010e6f2 <device_close>: */ int device_close( rtems_libio_t *iop ) {
  10e6f2:	55                   	push   %ebp                           
  10e6f3:	89 e5                	mov    %esp,%ebp                      
  10e6f5:	83 ec 1c             	sub    $0x1c,%esp                     
  10e6f8:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_open_close_args_t  args;                                
  rtems_status_code              status;                              
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode = iop->file_info;                                         
  10e6fb:	8b 50 2c             	mov    0x2c(%eax),%edx                
                                                                      
  args.iop   = iop;                                                   
  10e6fe:	89 45 f4             	mov    %eax,-0xc(%ebp)                
  args.flags = 0;                                                     
  10e701:	c7 45 f8 00 00 00 00 	movl   $0x0,-0x8(%ebp)                
  args.mode  = 0;                                                     
  10e708:	c7 45 fc 00 00 00 00 	movl   $0x0,-0x4(%ebp)                
                                                                      
  status = rtems_io_close(                                            
  10e70f:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10e712:	50                   	push   %eax                           
  10e713:	ff 72 54             	pushl  0x54(%edx)                     
  10e716:	ff 72 50             	pushl  0x50(%edx)                     
  10e719:	e8 de 06 00 00       	call   10edfc <rtems_io_close>        
  10e71e:	89 c2                	mov    %eax,%edx                      
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
  if ( status ) {                                                     
  10e720:	83 c4 10             	add    $0x10,%esp                     
  10e723:	31 c0                	xor    %eax,%eax                      
  10e725:	85 d2                	test   %edx,%edx                      
  10e727:	74 07                	je     10e730 <device_close+0x3e>     <== ALWAYS TAKEN
    return rtems_deviceio_errno(status);                              
  10e729:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  10e72b:	e8 bb fe ff ff       	call   10e5eb <rtems_deviceio_errno>  <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
  10e730:	c9                   	leave                                 
  10e731:	c3                   	ret                                   
                                                                      

0010e615 <device_ioctl>: int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) {
  10e615:	55                   	push   %ebp                           <== NOT EXECUTED
  10e616:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10e618:	83 ec 1c             	sub    $0x1c,%esp                     <== NOT EXECUTED
  10e61b:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  rtems_libio_ioctl_args_t  args;                                     
  rtems_status_code         status;                                   
  IMFS_jnode_t             *the_jnode;                                
                                                                      
  args.iop     = iop;                                                 
  10e61e:	89 55 f0             	mov    %edx,-0x10(%ebp)               <== NOT EXECUTED
  args.command = command;                                             
  10e621:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  10e624:	89 45 f4             	mov    %eax,-0xc(%ebp)                <== NOT EXECUTED
  args.buffer  = buffer;                                              
  10e627:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  10e62a:	89 45 f8             	mov    %eax,-0x8(%ebp)                <== NOT EXECUTED
                                                                      
  the_jnode = iop->file_info;                                         
  10e62d:	8b 52 2c             	mov    0x2c(%edx),%edx                <== NOT EXECUTED
                                                                      
  status = rtems_io_control(                                          
  10e630:	8d 45 f0             	lea    -0x10(%ebp),%eax               <== NOT EXECUTED
  10e633:	50                   	push   %eax                           <== NOT EXECUTED
  10e634:	ff 72 54             	pushl  0x54(%edx)                     <== NOT EXECUTED
  10e637:	ff 72 50             	pushl  0x50(%edx)                     <== NOT EXECUTED
  10e63a:	e8 fd 07 00 00       	call   10ee3c <rtems_io_control>      <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
  10e63f:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10e642:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10e644:	74 07                	je     10e64d <device_ioctl+0x38>     <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
  10e646:	e8 a0 ff ff ff       	call   10e5eb <rtems_deviceio_errno>  <== NOT EXECUTED
  10e64b:	eb 03                	jmp    10e650 <device_ioctl+0x3b>     <== NOT EXECUTED
                                                                      
  return args.ioctl_return;                                           
  10e64d:	8b 45 fc             	mov    -0x4(%ebp),%eax                <== NOT EXECUTED
}                                                                     
  10e650:	c9                   	leave                                 <== NOT EXECUTED
  10e651:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010e732 <device_open>: rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) {
  10e732:	55                   	push   %ebp                           
  10e733:	89 e5                	mov    %esp,%ebp                      
  10e735:	83 ec 1c             	sub    $0x1c,%esp                     
  10e738:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_open_close_args_t  args;                                
  rtems_status_code              status;                              
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode  = iop->file_info;                                        
  10e73b:	8b 50 2c             	mov    0x2c(%eax),%edx                
                                                                      
  args.iop   = iop;                                                   
  10e73e:	89 45 f4             	mov    %eax,-0xc(%ebp)                
  args.flags = iop->flags;                                            
  10e741:	8b 40 0c             	mov    0xc(%eax),%eax                 
  10e744:	89 45 f8             	mov    %eax,-0x8(%ebp)                
  args.mode  = mode;                                                  
  10e747:	8b 45 14             	mov    0x14(%ebp),%eax                
  10e74a:	89 45 fc             	mov    %eax,-0x4(%ebp)                
                                                                      
  status = rtems_io_open(                                             
  10e74d:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10e750:	50                   	push   %eax                           
  10e751:	ff 72 54             	pushl  0x54(%edx)                     
  10e754:	ff 72 50             	pushl  0x50(%edx)                     
  10e757:	e8 20 07 00 00       	call   10ee7c <rtems_io_open>         
  10e75c:	89 c2                	mov    %eax,%edx                      
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
  if ( status )                                                       
  10e75e:	83 c4 10             	add    $0x10,%esp                     
  10e761:	31 c0                	xor    %eax,%eax                      
  10e763:	85 d2                	test   %edx,%edx                      
  10e765:	74 07                	je     10e76e <device_open+0x3c>      <== ALWAYS TAKEN
    return rtems_deviceio_errno(status);                              
  10e767:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  10e769:	e8 7d fe ff ff       	call   10e5eb <rtems_deviceio_errno>  <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
  10e76e:	c9                   	leave                                 
  10e76f:	c3                   	ret                                   
                                                                      

0010e6a2 <device_read>: ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) {
  10e6a2:	55                   	push   %ebp                           <== NOT EXECUTED
  10e6a3:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10e6a5:	83 ec 2c             	sub    $0x2c,%esp                     <== NOT EXECUTED
  10e6a8:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->file_info;                                         
  10e6ab:	8b 4a 2c             	mov    0x2c(%edx),%ecx                <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  10e6ae:	89 55 e8             	mov    %edx,-0x18(%ebp)               <== NOT EXECUTED
  args.offset      = iop->offset;                                     
  10e6b1:	8b 42 08             	mov    0x8(%edx),%eax                 <== NOT EXECUTED
  10e6b4:	89 45 ec             	mov    %eax,-0x14(%ebp)               <== NOT EXECUTED
  args.buffer      = buffer;                                          
  10e6b7:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  10e6ba:	89 45 f0             	mov    %eax,-0x10(%ebp)               <== NOT EXECUTED
  args.count       = count;                                           
  10e6bd:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  10e6c0:	89 45 f4             	mov    %eax,-0xc(%ebp)                <== NOT EXECUTED
  args.flags       = iop->flags;                                      
  10e6c3:	8b 42 0c             	mov    0xc(%edx),%eax                 <== NOT EXECUTED
  10e6c6:	89 45 f8             	mov    %eax,-0x8(%ebp)                <== NOT EXECUTED
  args.bytes_moved = 0;                                               
  10e6c9:	c7 45 fc 00 00 00 00 	movl   $0x0,-0x4(%ebp)                <== NOT EXECUTED
                                                                      
  status = rtems_io_read(                                             
  10e6d0:	8d 45 e8             	lea    -0x18(%ebp),%eax               <== NOT EXECUTED
  10e6d3:	50                   	push   %eax                           <== NOT EXECUTED
  10e6d4:	ff 71 54             	pushl  0x54(%ecx)                     <== NOT EXECUTED
  10e6d7:	ff 71 50             	pushl  0x50(%ecx)                     <== NOT EXECUTED
  10e6da:	e8 dd 07 00 00       	call   10eebc <rtems_io_read>         <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
  10e6df:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10e6e2:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10e6e4:	74 07                	je     10e6ed <device_read+0x4b>      <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
  10e6e6:	e8 00 ff ff ff       	call   10e5eb <rtems_deviceio_errno>  <== NOT EXECUTED
  10e6eb:	eb 03                	jmp    10e6f0 <device_read+0x4e>      <== NOT EXECUTED
                                                                      
  return (ssize_t) args.bytes_moved;                                  
  10e6ed:	8b 45 fc             	mov    -0x4(%ebp),%eax                <== NOT EXECUTED
}                                                                     
  10e6f0:	c9                   	leave                                 <== NOT EXECUTED
  10e6f1:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010e652 <device_write>: ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
  10e652:	55                   	push   %ebp                           
  10e653:	89 e5                	mov    %esp,%ebp                      
  10e655:	83 ec 2c             	sub    $0x2c,%esp                     
  10e658:	8b 55 08             	mov    0x8(%ebp),%edx                 
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->file_info;                                         
  10e65b:	8b 4a 2c             	mov    0x2c(%edx),%ecx                
                                                                      
  args.iop         = iop;                                             
  10e65e:	89 55 e8             	mov    %edx,-0x18(%ebp)               
  args.offset      = iop->offset;                                     
  10e661:	8b 42 08             	mov    0x8(%edx),%eax                 
  10e664:	89 45 ec             	mov    %eax,-0x14(%ebp)               
  args.buffer      = (void *) buffer;                                 
  10e667:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10e66a:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  args.count       = count;                                           
  10e66d:	8b 45 10             	mov    0x10(%ebp),%eax                
  10e670:	89 45 f4             	mov    %eax,-0xc(%ebp)                
  args.flags       = iop->flags;                                      
  10e673:	8b 42 0c             	mov    0xc(%edx),%eax                 
  10e676:	89 45 f8             	mov    %eax,-0x8(%ebp)                
  args.bytes_moved = 0;                                               
  10e679:	c7 45 fc 00 00 00 00 	movl   $0x0,-0x4(%ebp)                
                                                                      
  status = rtems_io_write(                                            
  10e680:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  10e683:	50                   	push   %eax                           
  10e684:	ff 71 54             	pushl  0x54(%ecx)                     
  10e687:	ff 71 50             	pushl  0x50(%ecx)                     
  10e68a:	e8 6d 08 00 00       	call   10eefc <rtems_io_write>        
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
  10e68f:	83 c4 10             	add    $0x10,%esp                     
  10e692:	85 c0                	test   %eax,%eax                      
  10e694:	74 07                	je     10e69d <device_write+0x4b>     <== ALWAYS TAKEN
    return rtems_deviceio_errno(status);                              
  10e696:	e8 50 ff ff ff       	call   10e5eb <rtems_deviceio_errno>  <== NOT EXECUTED
  10e69b:	eb 03                	jmp    10e6a0 <device_write+0x4e>     <== NOT EXECUTED
                                                                      
  return (ssize_t) args.bytes_moved;                                  
  10e69d:	8b 45 fc             	mov    -0x4(%ebp),%eax                
}                                                                     
  10e6a0:	c9                   	leave                                 
  10e6a1:	c3                   	ret                                   
                                                                      

00107c82 <drainOutput>: /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) {
  107c82:	55                   	push   %ebp                           
  107c83:	89 e5                	mov    %esp,%ebp                      
  107c85:	53                   	push   %ebx                           
  107c86:	83 ec 04             	sub    $0x4,%esp                      
  107c89:	89 c3                	mov    %eax,%ebx                      
	rtems_interrupt_level level;                                         
	rtems_status_code sc;                                                
                                                                      
	if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {            
  107c8b:	83 b8 b4 00 00 00 00 	cmpl   $0x0,0xb4(%eax)                
  107c92:	74 46                	je     107cda <drainOutput+0x58>      <== NEVER TAKEN
		rtems_interrupt_disable (level);                                    
  107c94:	9c                   	pushf                                 
  107c95:	fa                   	cli                                   
  107c96:	59                   	pop    %ecx                           
  107c97:	eb 2f                	jmp    107cc8 <drainOutput+0x46>      
		while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {                
			tty->rawOutBufState = rob_wait;                                    
  107c99:	c7 83 94 00 00 00 02 	movl   $0x2,0x94(%ebx)                
  107ca0:	00 00 00                                                    
			rtems_interrupt_enable (level);                                    
  107ca3:	51                   	push   %ecx                           
  107ca4:	9d                   	popf                                  
			sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,             
  107ca5:	51                   	push   %ecx                           
  107ca6:	6a 00                	push   $0x0                           
  107ca8:	6a 00                	push   $0x0                           
  107caa:	ff b3 8c 00 00 00    	pushl  0x8c(%ebx)                     
  107cb0:	e8 bf 14 00 00       	call   109174 <rtems_semaphore_obtain>
							RTEMS_WAIT,                                                    
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
  107cb5:	83 c4 10             	add    $0x10,%esp                     
  107cb8:	85 c0                	test   %eax,%eax                      
  107cba:	74 09                	je     107cc5 <drainOutput+0x43>      <== ALWAYS TAKEN
				rtems_fatal_error_occurred (sc);                                  
  107cbc:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107cbf:	50                   	push   %eax                           <== NOT EXECUTED
  107cc0:	e8 cf 1a 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
			rtems_interrupt_disable (level);                                   
  107cc5:	9c                   	pushf                                 
  107cc6:	fa                   	cli                                   
  107cc7:	59                   	pop    %ecx                           
	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) {                
  107cc8:	8b 93 84 00 00 00    	mov    0x84(%ebx),%edx                
  107cce:	8b 83 80 00 00 00    	mov    0x80(%ebx),%eax                
  107cd4:	39 c2                	cmp    %eax,%edx                      
  107cd6:	75 c1                	jne    107c99 <drainOutput+0x17>      
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
				rtems_fatal_error_occurred (sc);                                  
			rtems_interrupt_disable (level);                                   
		}                                                                   
		rtems_interrupt_enable (level);                                     
  107cd8:	51                   	push   %ecx                           
  107cd9:	9d                   	popf                                  
	}                                                                    
}                                                                     
  107cda:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  107cdd:	c9                   	leave                                 
  107cde:	c3                   	ret                                   
                                                                      

00106ebc <dup2>: int dup2( int fildes, int fildes2 ) {
  106ebc:	55                   	push   %ebp                           
  106ebd:	89 e5                	mov    %esp,%ebp                      
  106ebf:	57                   	push   %edi                           
  106ec0:	56                   	push   %esi                           
  106ec1:	53                   	push   %ebx                           
  106ec2:	83 ec 64             	sub    $0x64,%esp                     
  106ec5:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  106ec8:	8b 75 0c             	mov    0xc(%ebp),%esi                 
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
  106ecb:	8d 5d a8             	lea    -0x58(%ebp),%ebx               
  106ece:	53                   	push   %ebx                           
  106ecf:	57                   	push   %edi                           
  106ed0:	e8 9b 04 00 00       	call   107370 <fstat>                 
  if ( status == -1 )                                                 
  106ed5:	83 c4 10             	add    $0x10,%esp                     
  106ed8:	40                   	inc    %eax                           
  106ed9:	74 1e                	je     106ef9 <dup2+0x3d>             <== NEVER TAKEN
                                                                      
  /*                                                                  
   *  If fildes2 is not valid, then we should not do anything either. 
   */                                                                 
                                                                      
  status = fstat( fildes2, &buf );                                    
  106edb:	52                   	push   %edx                           
  106edc:	52                   	push   %edx                           
  106edd:	53                   	push   %ebx                           
  106ede:	56                   	push   %esi                           
  106edf:	e8 8c 04 00 00       	call   107370 <fstat>                 
  if ( status == -1 )                                                 
  106ee4:	83 c4 10             	add    $0x10,%esp                     
  106ee7:	40                   	inc    %eax                           
  106ee8:	74 0f                	je     106ef9 <dup2+0x3d>             <== ALWAYS TAKEN
                                                                      
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
  106eea:	50                   	push   %eax                           <== NOT EXECUTED
  106eeb:	56                   	push   %esi                           <== NOT EXECUTED
  106eec:	6a 00                	push   $0x0                           <== NOT EXECUTED
  106eee:	57                   	push   %edi                           <== NOT EXECUTED
  106eef:	e8 bc 01 00 00       	call   1070b0 <fcntl>                 <== NOT EXECUTED
  106ef4:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106ef7:	eb 03                	jmp    106efc <dup2+0x40>             <== NOT EXECUTED
  106ef9:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  106efc:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106eff:	5b                   	pop    %ebx                           
  106f00:	5e                   	pop    %esi                           
  106f01:	5f                   	pop    %edi                           
  106f02:	c9                   	leave                                 
  106f03:	c3                   	ret                                   
                                                                      

001078b7 <echo>: /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) {
  1078b7:	55                   	push   %ebp                           <== NOT EXECUTED
  1078b8:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1078ba:	53                   	push   %ebx                           <== NOT EXECUTED
  1078bb:	83 ec 14             	sub    $0x14,%esp                     <== NOT EXECUTED
  1078be:	89 d3                	mov    %edx,%ebx                      <== NOT EXECUTED
  1078c0:	88 c1                	mov    %al,%cl                        <== NOT EXECUTED
	if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
  1078c2:	f6 42 3d 02          	testb  $0x2,0x3d(%edx)                <== NOT EXECUTED
  1078c6:	74 38                	je     107900 <echo+0x49>             <== NOT EXECUTED
  1078c8:	0f b6 d0             	movzbl %al,%edx                       <== NOT EXECUTED
  1078cb:	a1 00 b7 11 00       	mov    0x11b700,%eax                  <== NOT EXECUTED
  1078d0:	f6 04 10 20          	testb  $0x20,(%eax,%edx,1)            <== NOT EXECUTED
  1078d4:	74 2a                	je     107900 <echo+0x49>             <== NOT EXECUTED
  1078d6:	80 f9 09             	cmp    $0x9,%cl                       <== NOT EXECUTED
  1078d9:	74 25                	je     107900 <echo+0x49>             <== NOT EXECUTED
  1078db:	80 f9 0a             	cmp    $0xa,%cl                       <== NOT EXECUTED
  1078de:	74 20                	je     107900 <echo+0x49>             <== NOT EXECUTED
		char echobuf[2];                                                    
                                                                      
		echobuf[0] = '^';                                                   
  1078e0:	c6 45 fa 5e          	movb   $0x5e,-0x6(%ebp)               <== NOT EXECUTED
		echobuf[1] = c ^ 0x40;                                              
  1078e4:	83 f1 40             	xor    $0x40,%ecx                     <== NOT EXECUTED
  1078e7:	88 4d fb             	mov    %cl,-0x5(%ebp)                 <== NOT EXECUTED
		rtems_termios_puts (echobuf, 2, tty);                               
  1078ea:	50                   	push   %eax                           <== NOT EXECUTED
  1078eb:	53                   	push   %ebx                           <== NOT EXECUTED
  1078ec:	6a 02                	push   $0x2                           <== NOT EXECUTED
  1078ee:	8d 45 fa             	lea    -0x6(%ebp),%eax                <== NOT EXECUTED
  1078f1:	50                   	push   %eax                           <== NOT EXECUTED
  1078f2:	e8 9c fd ff ff       	call   107693 <rtems_termios_puts>    <== NOT EXECUTED
		tty->column += 2;                                                   
  1078f7:	83 43 28 02          	addl   $0x2,0x28(%ebx)                <== NOT EXECUTED
  1078fb:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1078fe:	eb 0a                	jmp    10790a <echo+0x53>             <== NOT EXECUTED
	}                                                                    
	else {                                                               
		oproc (c, tty);                                                     
  107900:	0f b6 c1             	movzbl %cl,%eax                       <== NOT EXECUTED
  107903:	89 da                	mov    %ebx,%edx                      <== NOT EXECUTED
  107905:	e8 9e fe ff ff       	call   1077a8 <oproc>                 <== NOT EXECUTED
	}                                                                    
}                                                                     
  10790a:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10790d:	c9                   	leave                                 <== NOT EXECUTED
  10790e:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010790f <erase>: * 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) {
  10790f:	55                   	push   %ebp                           <== NOT EXECUTED
  107910:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107912:	57                   	push   %edi                           <== NOT EXECUTED
  107913:	56                   	push   %esi                           <== NOT EXECUTED
  107914:	53                   	push   %ebx                           <== NOT EXECUTED
  107915:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107918:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
  10791a:	89 55 f0             	mov    %edx,-0x10(%ebp)               <== NOT EXECUTED
	if (tty->ccount == 0)                                                
  10791d:	83 78 20 00          	cmpl   $0x0,0x20(%eax)                <== NOT EXECUTED
  107921:	0f 84 4d 01 00 00    	je     107a74 <erase+0x165>           <== NOT EXECUTED
		return;                                                             
	if (lineFlag) {                                                      
  107927:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  107929:	0f 84 3a 01 00 00    	je     107a69 <erase+0x15a>           <== NOT EXECUTED
		if (!(tty->termios.c_lflag & ECHO)) {                               
  10792f:	8b 40 3c             	mov    0x3c(%eax),%eax                <== NOT EXECUTED
  107932:	a8 08                	test   $0x8,%al                       <== NOT EXECUTED
  107934:	75 0c                	jne    107942 <erase+0x33>            <== NOT EXECUTED
			tty->ccount = 0;                                                   
  107936:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)                <== NOT EXECUTED
  10793d:	e9 32 01 00 00       	jmp    107a74 <erase+0x165>           <== NOT EXECUTED
			return;                                                            
		}                                                                   
		if (!(tty->termios.c_lflag & ECHOE)) {                              
  107942:	a8 10                	test   $0x10,%al                      <== NOT EXECUTED
  107944:	0f 85 1f 01 00 00    	jne    107a69 <erase+0x15a>           <== NOT EXECUTED
			tty->ccount = 0;                                                   
  10794a:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)                <== NOT EXECUTED
			echo (tty->termios.c_cc[VKILL], tty);                              
  107951:	0f b6 43 44          	movzbl 0x44(%ebx),%eax                <== NOT EXECUTED
  107955:	89 da                	mov    %ebx,%edx                      <== NOT EXECUTED
  107957:	e8 5b ff ff ff       	call   1078b7 <echo>                  <== NOT EXECUTED
			if (tty->termios.c_lflag & ECHOK)                                  
  10795c:	f6 43 3c 20          	testb  $0x20,0x3c(%ebx)               <== NOT EXECUTED
  107960:	0f 84 0e 01 00 00    	je     107a74 <erase+0x165>           <== NOT EXECUTED
				echo ('\n', tty);                                                 
  107966:	89 da                	mov    %ebx,%edx                      <== NOT EXECUTED
  107968:	b8 0a 00 00 00       	mov    $0xa,%eax                      <== NOT EXECUTED
  10796d:	eb 28                	jmp    107997 <erase+0x88>            <== NOT EXECUTED
			return;                                                            
		}                                                                   
	}                                                                    
	while (tty->ccount) {                                                
		unsigned char c = tty->cbuf[--tty->ccount];                         
  10796f:	8b 53 1c             	mov    0x1c(%ebx),%edx                <== NOT EXECUTED
  107972:	8d 41 ff             	lea    -0x1(%ecx),%eax                <== NOT EXECUTED
  107975:	89 43 20             	mov    %eax,0x20(%ebx)                <== NOT EXECUTED
  107978:	8a 54 0a ff          	mov    -0x1(%edx,%ecx,1),%dl          <== NOT EXECUTED
                                                                      
		if (tty->termios.c_lflag & ECHO) {                                  
  10797c:	8b 43 3c             	mov    0x3c(%ebx),%eax                <== NOT EXECUTED
  10797f:	a8 08                	test   $0x8,%al                       <== NOT EXECUTED
  107981:	0f 84 dc 00 00 00    	je     107a63 <erase+0x154>           <== NOT EXECUTED
			if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {                
  107987:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               <== NOT EXECUTED
  10798b:	75 16                	jne    1079a3 <erase+0x94>            <== NOT EXECUTED
  10798d:	a8 10                	test   $0x10,%al                      <== NOT EXECUTED
  10798f:	75 12                	jne    1079a3 <erase+0x94>            <== NOT EXECUTED
				echo (tty->termios.c_cc[VERASE], tty);                            
  107991:	0f b6 43 43          	movzbl 0x43(%ebx),%eax                <== NOT EXECUTED
  107995:	89 da                	mov    %ebx,%edx                      <== NOT EXECUTED
			}                                                                  
		}                                                                   
		if (!lineFlag)                                                      
			break;                                                             
	}                                                                    
}                                                                     
  107997:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  10799a:	5b                   	pop    %ebx                           <== NOT EXECUTED
  10799b:	5e                   	pop    %esi                           <== NOT EXECUTED
  10799c:	5f                   	pop    %edi                           <== NOT EXECUTED
  10799d:	c9                   	leave                                 <== NOT EXECUTED
	while (tty->ccount) {                                                
		unsigned char c = tty->cbuf[--tty->ccount];                         
                                                                      
		if (tty->termios.c_lflag & ECHO) {                                  
			if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {                
				echo (tty->termios.c_cc[VERASE], tty);                            
  10799e:	e9 14 ff ff ff       	jmp    1078b7 <echo>                  <== NOT EXECUTED
			}                                                                  
			else if (c == '\t') {                                              
  1079a3:	80 fa 09             	cmp    $0x9,%dl                       <== NOT EXECUTED
  1079a6:	8b 3d 00 b7 11 00    	mov    0x11b700,%edi                  <== NOT EXECUTED
  1079ac:	75 5e                	jne    107a0c <erase+0xfd>            <== NOT EXECUTED
				int col = tty->read_start_column;                                 
  1079ae:	8b 73 2c             	mov    0x2c(%ebx),%esi                <== NOT EXECUTED
				while (i != tty->ccount) {                                        
					c = tty->cbuf[i++];                                              
					if (c == '\t') {                                                 
						col = (col | 7) + 1;                                            
					}                                                                
					else if (iscntrl (c)) {                                          
  1079b1:	ba 01 00 00 00       	mov    $0x1,%edx                      <== NOT EXECUTED
						if (tty->termios.c_lflag & ECHOCTL)                             
  1079b6:	25 00 02 00 00       	and    $0x200,%eax                    <== NOT EXECUTED
  1079bb:	89 45 ec             	mov    %eax,-0x14(%ebp)               <== NOT EXECUTED
  1079be:	eb 2b                	jmp    1079eb <erase+0xdc>            <== NOT EXECUTED
                                                                      
				/*                                                                
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
					c = tty->cbuf[i++];                                              
  1079c0:	8b 43 1c             	mov    0x1c(%ebx),%eax                <== NOT EXECUTED
  1079c3:	8a 44 10 ff          	mov    -0x1(%eax,%edx,1),%al          <== NOT EXECUTED
					if (c == '\t') {                                                 
  1079c7:	3c 09                	cmp    $0x9,%al                       <== NOT EXECUTED
  1079c9:	75 0a                	jne    1079d5 <erase+0xc6>            <== NOT EXECUTED
						col = (col | 7) + 1;                                            
  1079cb:	89 f0                	mov    %esi,%eax                      <== NOT EXECUTED
  1079cd:	83 c8 07             	or     $0x7,%eax                      <== NOT EXECUTED
  1079d0:	8d 70 01             	lea    0x1(%eax),%esi                 <== NOT EXECUTED
  1079d3:	eb 15                	jmp    1079ea <erase+0xdb>            <== NOT EXECUTED
					}                                                                
					else if (iscntrl (c)) {                                          
  1079d5:	0f b6 c0             	movzbl %al,%eax                       <== NOT EXECUTED
  1079d8:	f6 04 07 20          	testb  $0x20,(%edi,%eax,1)            <== NOT EXECUTED
  1079dc:	74 0b                	je     1079e9 <erase+0xda>            <== NOT EXECUTED
						if (tty->termios.c_lflag & ECHOCTL)                             
  1079de:	83 7d ec 00          	cmpl   $0x0,-0x14(%ebp)               <== NOT EXECUTED
  1079e2:	74 06                	je     1079ea <erase+0xdb>            <== NOT EXECUTED
							col += 2;                                                      
  1079e4:	83 c6 02             	add    $0x2,%esi                      <== NOT EXECUTED
  1079e7:	eb 01                	jmp    1079ea <erase+0xdb>            <== NOT EXECUTED
					}                                                                
					else {                                                           
						col++;                                                          
  1079e9:	46                   	inc    %esi                           <== NOT EXECUTED
  1079ea:	42                   	inc    %edx                           <== NOT EXECUTED
				int i = 0;                                                        
                                                                      
				/*                                                                
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
  1079eb:	39 ca                	cmp    %ecx,%edx                      <== NOT EXECUTED
  1079ed:	75 d1                	jne    1079c0 <erase+0xb1>            <== NOT EXECUTED
  1079ef:	eb 14                	jmp    107a05 <erase+0xf6>            <== NOT EXECUTED
                                                                      
				/*                                                                
				 * Back up over the tab                                           
				 */                                                               
				while (tty->column > col) {                                       
					rtems_termios_puts ("\b", 1, tty);                               
  1079f1:	50                   	push   %eax                           <== NOT EXECUTED
  1079f2:	53                   	push   %ebx                           <== NOT EXECUTED
  1079f3:	6a 01                	push   $0x1                           <== NOT EXECUTED
  1079f5:	68 54 72 11 00       	push   $0x117254                      <== NOT EXECUTED
  1079fa:	e8 94 fc ff ff       	call   107693 <rtems_termios_puts>    <== NOT EXECUTED
					tty->column--;                                                   
  1079ff:	ff 4b 28             	decl   0x28(%ebx)                     <== NOT EXECUTED
  107a02:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
				}                                                                 
                                                                      
				/*                                                                
				 * Back up over the tab                                           
				 */                                                               
				while (tty->column > col) {                                       
  107a05:	39 73 28             	cmp    %esi,0x28(%ebx)                <== NOT EXECUTED
  107a08:	7f e7                	jg     1079f1 <erase+0xe2>            <== NOT EXECUTED
  107a0a:	eb 57                	jmp    107a63 <erase+0x154>           <== NOT EXECUTED
					rtems_termios_puts ("\b", 1, tty);                               
					tty->column--;                                                   
				}                                                                 
			}                                                                  
			else {                                                             
				if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {            
  107a0c:	0f b6 f2             	movzbl %dl,%esi                       <== NOT EXECUTED
  107a0f:	f6 04 37 20          	testb  $0x20,(%edi,%esi,1)            <== NOT EXECUTED
  107a13:	74 21                	je     107a36 <erase+0x127>           <== NOT EXECUTED
  107a15:	f6 c4 02             	test   $0x2,%ah                       <== NOT EXECUTED
  107a18:	74 1c                	je     107a36 <erase+0x127>           <== NOT EXECUTED
					rtems_termios_puts ("\b \b", 3, tty);                            
  107a1a:	50                   	push   %eax                           <== NOT EXECUTED
  107a1b:	53                   	push   %ebx                           <== NOT EXECUTED
  107a1c:	6a 03                	push   $0x3                           <== NOT EXECUTED
  107a1e:	68 52 72 11 00       	push   $0x117252                      <== NOT EXECUTED
  107a23:	e8 6b fc ff ff       	call   107693 <rtems_termios_puts>    <== NOT EXECUTED
					if (tty->column)                                                 
  107a28:	8b 43 28             	mov    0x28(%ebx),%eax                <== NOT EXECUTED
  107a2b:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107a2e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107a30:	74 04                	je     107a36 <erase+0x127>           <== NOT EXECUTED
						tty->column--;                                                  
  107a32:	48                   	dec    %eax                           <== NOT EXECUTED
  107a33:	89 43 28             	mov    %eax,0x28(%ebx)                <== NOT EXECUTED
				}                                                                 
				if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {           
  107a36:	a1 00 b7 11 00       	mov    0x11b700,%eax                  <== NOT EXECUTED
  107a3b:	f6 04 30 20          	testb  $0x20,(%eax,%esi,1)            <== NOT EXECUTED
  107a3f:	74 06                	je     107a47 <erase+0x138>           <== NOT EXECUTED
  107a41:	f6 43 3d 02          	testb  $0x2,0x3d(%ebx)                <== NOT EXECUTED
  107a45:	74 1c                	je     107a63 <erase+0x154>           <== NOT EXECUTED
					rtems_termios_puts ("\b \b", 3, tty);                            
  107a47:	50                   	push   %eax                           <== NOT EXECUTED
  107a48:	53                   	push   %ebx                           <== NOT EXECUTED
  107a49:	6a 03                	push   $0x3                           <== NOT EXECUTED
  107a4b:	68 52 72 11 00       	push   $0x117252                      <== NOT EXECUTED
  107a50:	e8 3e fc ff ff       	call   107693 <rtems_termios_puts>    <== NOT EXECUTED
					if (tty->column)                                                 
  107a55:	8b 43 28             	mov    0x28(%ebx),%eax                <== NOT EXECUTED
  107a58:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107a5b:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107a5d:	74 04                	je     107a63 <erase+0x154>           <== NOT EXECUTED
						tty->column--;                                                  
  107a5f:	48                   	dec    %eax                           <== NOT EXECUTED
  107a60:	89 43 28             	mov    %eax,0x28(%ebx)                <== NOT EXECUTED
				}                                                                 
			}                                                                  
		}                                                                   
		if (!lineFlag)                                                      
  107a63:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               <== NOT EXECUTED
  107a67:	74 0b                	je     107a74 <erase+0x165>           <== NOT EXECUTED
			if (tty->termios.c_lflag & ECHOK)                                  
				echo ('\n', tty);                                                 
			return;                                                            
		}                                                                   
	}                                                                    
	while (tty->ccount) {                                                
  107a69:	8b 4b 20             	mov    0x20(%ebx),%ecx                <== NOT EXECUTED
  107a6c:	85 c9                	test   %ecx,%ecx                      <== NOT EXECUTED
  107a6e:	0f 85 fb fe ff ff    	jne    10796f <erase+0x60>            <== NOT EXECUTED
			}                                                                  
		}                                                                   
		if (!lineFlag)                                                      
			break;                                                             
	}                                                                    
}                                                                     
  107a74:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  107a77:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107a78:	5e                   	pop    %esi                           <== NOT EXECUTED
  107a79:	5f                   	pop    %edi                           <== NOT EXECUTED
  107a7a:	c9                   	leave                                 <== NOT EXECUTED
  107a7b:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001070b0 <fcntl>: int fcntl( int fd, int cmd, ... ) {
  1070b0:	55                   	push   %ebp                           
  1070b1:	89 e5                	mov    %esp,%ebp                      
  1070b3:	57                   	push   %edi                           
  1070b4:	56                   	push   %esi                           
  1070b5:	53                   	push   %ebx                           
  1070b6:	83 ec 0c             	sub    $0xc,%esp                      
  1070b9:	8b 45 08             	mov    0x8(%ebp),%eax                 
  1070bc:	8d 55 10             	lea    0x10(%ebp),%edx                
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  1070bf:	8b 0d 38 d0 11 00    	mov    0x11d038,%ecx                  
  1070c5:	39 c8                	cmp    %ecx,%eax                      
  1070c7:	73 14                	jae    1070dd <fcntl+0x2d>            <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  1070c9:	8b 35 68 13 12 00    	mov    0x121368,%esi                  
  1070cf:	6b c0 34             	imul   $0x34,%eax,%eax                
  1070d2:	8d 1c 06             	lea    (%esi,%eax,1),%ebx             
  rtems_libio_check_is_open(iop);                                     
  1070d5:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  1070d8:	f6 c4 01             	test   $0x1,%ah                       
  1070db:	75 10                	jne    1070ed <fcntl+0x3d>            <== ALWAYS TAKEN
  1070dd:	e8 fe 9e 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  1070e2:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  1070e8:	e9 fc 00 00 00       	jmp    1071e9 <fcntl+0x139>           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
  1070ed:	83 7d 0c 09          	cmpl   $0x9,0xc(%ebp)                 
  1070f1:	0f 87 bf 00 00 00    	ja     1071b6 <fcntl+0x106>           
  1070f7:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  1070fa:	ff 24 bd 08 ad 11 00 	jmp    *0x11ad08(,%edi,4)             
    case F_DUPFD:        /* dup */                                    
      fd2 = va_arg( ap, int );                                        
  107101:	8b 02                	mov    (%edx),%eax                    
      if ( fd2 )                                                      
  107103:	85 c0                	test   %eax,%eax                      
  107105:	74 0e                	je     107115 <fcntl+0x65>            <== ALWAYS TAKEN
        diop = rtems_libio_iop( fd2 );                                
  107107:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  107109:	39 c8                	cmp    %ecx,%eax                      <== NOT EXECUTED
  10710b:	73 1a                	jae    107127 <fcntl+0x77>            <== NOT EXECUTED
  10710d:	6b c0 34             	imul   $0x34,%eax,%eax                <== NOT EXECUTED
  107110:	8d 14 06             	lea    (%esi,%eax,1),%edx             <== NOT EXECUTED
  107113:	eb 12                	jmp    107127 <fcntl+0x77>            <== NOT EXECUTED
      else {                                                          
        /* allocate a file control block */                           
        diop = rtems_libio_allocate();                                
  107115:	e8 93 05 00 00       	call   1076ad <rtems_libio_allocate>  
  10711a:	89 c2                	mov    %eax,%edx                      
        if ( diop == 0 ) {                                            
  10711c:	83 ce ff             	or     $0xffffffff,%esi               
  10711f:	85 c0                	test   %eax,%eax                      
  107121:	0f 84 c5 00 00 00    	je     1071ec <fcntl+0x13c>           <== NEVER TAKEN
          ret = -1;                                                   
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->handlers   = iop->handlers;                               
  107127:	8b 43 30             	mov    0x30(%ebx),%eax                
  10712a:	89 42 30             	mov    %eax,0x30(%edx)                
      diop->file_info  = iop->file_info;                              
  10712d:	8b 43 2c             	mov    0x2c(%ebx),%eax                
  107130:	89 42 2c             	mov    %eax,0x2c(%edx)                
      diop->flags      = iop->flags;                                  
  107133:	8b 43 0c             	mov    0xc(%ebx),%eax                 
  107136:	89 42 0c             	mov    %eax,0xc(%edx)                 
      diop->pathinfo   = iop->pathinfo;                               
  107139:	8d 7a 10             	lea    0x10(%edx),%edi                
  10713c:	8d 73 10             	lea    0x10(%ebx),%esi                
  10713f:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  107144:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
      ret = (int) (diop - rtems_libio_iops);                          
  107146:	2b 15 68 13 12 00    	sub    0x121368,%edx                  
  10714c:	c1 fa 02             	sar    $0x2,%edx                      
  10714f:	69 f2 c5 4e ec c4    	imul   $0xc4ec4ec5,%edx,%esi          
  107155:	eb 6c                	jmp    1071c3 <fcntl+0x113>           
      break;                                                          
                                                                      
    case F_GETFD:        /* get f_flags */                            
      ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);          
  107157:	89 c6                	mov    %eax,%esi                      
  107159:	c1 ee 0b             	shr    $0xb,%esi                      
  10715c:	83 e6 01             	and    $0x1,%esi                      
  10715f:	eb 66                	jmp    1071c7 <fcntl+0x117>           
       *  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 ) )                                        
  107161:	83 3a 00             	cmpl   $0x0,(%edx)                    
  107164:	74 05                	je     10716b <fcntl+0xbb>            <== NEVER TAKEN
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
  107166:	80 cc 08             	or     $0x8,%ah                       
  107169:	eb 03                	jmp    10716e <fcntl+0xbe>            
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
  10716b:	80 e4 f7             	and    $0xf7,%ah                      <== NOT EXECUTED
  10716e:	89 43 0c             	mov    %eax,0xc(%ebx)                 
  107171:	31 f6                	xor    %esi,%esi                      
  107173:	eb 52                	jmp    1071c7 <fcntl+0x117>           
      break;                                                          
                                                                      
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
  107175:	83 ec 0c             	sub    $0xc,%esp                      
  107178:	50                   	push   %eax                           
  107179:	e8 e2 03 00 00       	call   107560 <rtems_libio_to_fcntl_flags>
  10717e:	89 c6                	mov    %eax,%esi                      
  107180:	83 c4 10             	add    $0x10,%esp                     
  107183:	eb 3e                	jmp    1071c3 <fcntl+0x113>           
      break;                                                          
                                                                      
    case F_SETFL:                                                     
      flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );           
  107185:	83 ec 0c             	sub    $0xc,%esp                      
  107188:	ff 32                	pushl  (%edx)                         
  10718a:	e8 b0 05 00 00       	call   10773f <rtems_libio_fcntl_flags>
                                                                      
      /*                                                              
       *  XXX If we are turning on append, should we seek to the end? 
       */                                                             
                                                                      
      iop->flags = (iop->flags & ~mask) | (flags & mask);             
  10718f:	25 01 02 00 00       	and    $0x201,%eax                    
  107194:	8b 53 0c             	mov    0xc(%ebx),%edx                 
  107197:	81 e2 fe fd ff ff    	and    $0xfffffdfe,%edx               
  10719d:	09 c2                	or     %eax,%edx                      
  10719f:	89 53 0c             	mov    %edx,0xc(%ebx)                 
  1071a2:	31 f6                	xor    %esi,%esi                      
  1071a4:	83 c4 10             	add    $0x10,%esp                     
  1071a7:	eb 1e                	jmp    1071c7 <fcntl+0x117>           
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    case F_GETOWN:       /*  for sockets. */                          
      errno = ENOTSUP;                                                
  1071a9:	e8 32 9e 00 00       	call   110fe0 <__errno>               
  1071ae:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   
  1071b4:	eb 33                	jmp    1071e9 <fcntl+0x139>           
      ret = -1;                                                       
      break;                                                          
                                                                      
    default:                                                          
      errno = EINVAL;                                                 
  1071b6:	e8 25 9e 00 00       	call   110fe0 <__errno>               
  1071bb:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  1071c1:	eb 26                	jmp    1071e9 <fcntl+0x139>           
  /*                                                                  
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
  1071c3:	85 f6                	test   %esi,%esi                      
  1071c5:	78 25                	js     1071ec <fcntl+0x13c>           <== NEVER TAKEN
    if (iop->handlers->fcntl_h) {                                     
  1071c7:	8b 43 30             	mov    0x30(%ebx),%eax                
  1071ca:	8b 40 30             	mov    0x30(%eax),%eax                
  1071cd:	85 c0                	test   %eax,%eax                      
  1071cf:	74 1b                	je     1071ec <fcntl+0x13c>           <== NEVER TAKEN
      int err = (*iop->handlers->fcntl_h)( cmd, iop );                
  1071d1:	52                   	push   %edx                           
  1071d2:	52                   	push   %edx                           
  1071d3:	53                   	push   %ebx                           
  1071d4:	ff 75 0c             	pushl  0xc(%ebp)                      
  1071d7:	ff d0                	call   *%eax                          
  1071d9:	89 c3                	mov    %eax,%ebx                      
      if (err) {                                                      
  1071db:	83 c4 10             	add    $0x10,%esp                     
  1071de:	85 c0                	test   %eax,%eax                      
  1071e0:	74 0a                	je     1071ec <fcntl+0x13c>           <== ALWAYS TAKEN
        errno = err;                                                  
  1071e2:	e8 f9 9d 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  1071e7:	89 18                	mov    %ebx,(%eax)                    <== NOT EXECUTED
  1071e9:	83 ce ff             	or     $0xffffffff,%esi               
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
  1071ec:	89 f0                	mov    %esi,%eax                      
  1071ee:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1071f1:	5b                   	pop    %ebx                           
  1071f2:	5e                   	pop    %esi                           
  1071f3:	5f                   	pop    %edi                           
  1071f4:	c9                   	leave                                 
  1071f5:	c3                   	ret                                   
                                                                      

00107214 <fdatasync>: #include <rtems/seterr.h> int fdatasync( int fd ) {
  107214:	55                   	push   %ebp                           
  107215:	89 e5                	mov    %esp,%ebp                      
  107217:	83 ec 08             	sub    $0x8,%esp                      
  10721a:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  10721d:	3b 05 38 d0 11 00    	cmp    0x11d038,%eax                  
  107223:	73 15                	jae    10723a <fdatasync+0x26>        <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  107225:	6b d0 34             	imul   $0x34,%eax,%edx                
  107228:	03 15 68 13 12 00    	add    0x121368,%edx                  
  rtems_libio_check_is_open(iop);                                     
  10722e:	8b 42 0c             	mov    0xc(%edx),%eax                 
  107231:	f6 c4 01             	test   $0x1,%ah                       
  107234:	74 04                	je     10723a <fdatasync+0x26>        <== NEVER TAKEN
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
  107236:	a8 04                	test   $0x4,%al                       
  107238:	75 0d                	jne    107247 <fdatasync+0x33>        
  10723a:	e8 a1 9d 00 00       	call   110fe0 <__errno>               
  10723f:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    
  107245:	eb 1d                	jmp    107264 <fdatasync+0x50>        
                                                                      
  /*                                                                  
   *  Now process the fdatasync().                                    
   */                                                                 
                                                                      
  if ( !iop->handlers->fdatasync_h )                                  
  107247:	8b 42 30             	mov    0x30(%edx),%eax                
  10724a:	8b 48 2c             	mov    0x2c(%eax),%ecx                
  10724d:	85 c9                	test   %ecx,%ecx                      
  10724f:	75 0d                	jne    10725e <fdatasync+0x4a>        <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  107251:	e8 8a 9d 00 00       	call   110fe0 <__errno>               
  107256:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   
  10725c:	eb 06                	jmp    107264 <fdatasync+0x50>        
                                                                      
  return (*iop->handlers->fdatasync_h)( iop );                        
  10725e:	89 55 08             	mov    %edx,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  107261:	c9                   	leave                                 <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( !iop->handlers->fdatasync_h )                                  
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  return (*iop->handlers->fdatasync_h)( iop );                        
  107262:	ff e1                	jmp    *%ecx                          <== NOT EXECUTED
}                                                                     
  107264:	83 c8 ff             	or     $0xffffffff,%eax               
  107267:	c9                   	leave                                 
  107268:	c3                   	ret                                   
                                                                      

0010a432 <file_systems_below_this_mountpoint>: bool file_systems_below_this_mountpoint( const char *path, rtems_filesystem_location_info_t *fs_root_loc, rtems_filesystem_mount_table_entry_t *fs_to_unmount ) {
  10a432:	55                   	push   %ebp                           <== NOT EXECUTED
  10a433:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10a435:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 <== NOT EXECUTED
  /*                                                                  
   * Search the mount table for any mount entries referencing this    
   * mount entry.                                                     
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
  10a438:	8b 15 94 29 12 00    	mov    0x122994,%edx                  <== NOT EXECUTED
  10a43e:	eb 0e                	jmp    10a44e <file_systems_below_this_mountpoint+0x1c><== NOT EXECUTED
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
        the_node = the_node->next ) {                                 
     the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node;
     if (the_mount_entry->mt_point_node.mt_entry  == fs_root_loc->mt_entry ) {
  10a440:	8b 42 14             	mov    0x14(%edx),%eax                <== NOT EXECUTED
  10a443:	3b 41 0c             	cmp    0xc(%ecx),%eax                 <== NOT EXECUTED
  10a446:	75 04                	jne    10a44c <file_systems_below_this_mountpoint+0x1a><== NOT EXECUTED
  10a448:	b0 01                	mov    $0x1,%al                       <== NOT EXECUTED
  10a44a:	eb 0c                	jmp    10a458 <file_systems_below_this_mountpoint+0x26><== NOT EXECUTED
   * mount entry.                                                     
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
        the_node = the_node->next ) {                                 
  10a44c:	8b 12                	mov    (%edx),%edx                    <== NOT EXECUTED
   * Search the mount table for any mount entries referencing this    
   * mount entry.                                                     
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
  10a44e:	81 fa 98 29 12 00    	cmp    $0x122998,%edx                 <== NOT EXECUTED
  10a454:	75 ea                	jne    10a440 <file_systems_below_this_mountpoint+0xe><== NOT EXECUTED
  10a456:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
        return true;                                                  
     }                                                                
  }                                                                   
                                                                      
  return false;                                                       
}                                                                     
  10a458:	c9                   	leave                                 <== NOT EXECUTED
  10a459:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010726c <fpathconf>: long fpathconf( int fd, int name ) {
  10726c:	55                   	push   %ebp                           
  10726d:	89 e5                	mov    %esp,%ebp                      
  10726f:	83 ec 08             	sub    $0x8,%esp                      
  107272:	8b 45 08             	mov    0x8(%ebp),%eax                 
  107275:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  long                                    return_value;               
  rtems_libio_t                          *iop;                        
  rtems_filesystem_limits_and_options_t  *the_limits;                 
                                                                      
  rtems_libio_check_fd(fd);                                           
  107278:	3b 05 38 d0 11 00    	cmp    0x11d038,%eax                  
  10727e:	73 0f                	jae    10728f <fpathconf+0x23>        
  iop = rtems_libio_iop(fd);                                          
  107280:	6b c0 34             	imul   $0x34,%eax,%eax                
  107283:	03 05 68 13 12 00    	add    0x121368,%eax                  
  rtems_libio_check_is_open(iop);                                     
  107289:	f6 40 0d 01          	testb  $0x1,0xd(%eax)                 
  10728d:	75 0d                	jne    10729c <fpathconf+0x30>        <== ALWAYS TAKEN
  10728f:	e8 4c 9d 00 00       	call   110fe0 <__errno>               
  107294:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    
  10729a:	eb 56                	jmp    1072f2 <fpathconf+0x86>        
                                                                      
  /*                                                                  
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;  
  10729c:	8b 40 1c             	mov    0x1c(%eax),%eax                
                                                                      
  switch ( name ) {                                                   
  10729f:	83 fa 0b             	cmp    $0xb,%edx                      
  1072a2:	77 43                	ja     1072e7 <fpathconf+0x7b>        
  1072a4:	ff 24 95 30 ad 11 00 	jmp    *0x11ad30(,%edx,4)             
    case _PC_LINK_MAX:                                                
      return_value = the_limits->link_max;                            
  1072ab:	8b 40 30             	mov    0x30(%eax),%eax                
  1072ae:	eb 45                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_MAX_CANON:                                               
      return_value = the_limits->max_canon;                           
  1072b0:	8b 40 34             	mov    0x34(%eax),%eax                
  1072b3:	eb 40                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_MAX_INPUT:                                               
      return_value = the_limits->max_input;                           
  1072b5:	8b 40 38             	mov    0x38(%eax),%eax                
  1072b8:	eb 3b                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_NAME_MAX:                                                
      return_value = the_limits->name_max;                            
  1072ba:	8b 40 3c             	mov    0x3c(%eax),%eax                
  1072bd:	eb 36                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_PATH_MAX:                                                
      return_value = the_limits->path_max;                            
  1072bf:	8b 40 40             	mov    0x40(%eax),%eax                
  1072c2:	eb 31                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_PIPE_BUF:                                                
      return_value = the_limits->pipe_buf;                            
  1072c4:	8b 40 44             	mov    0x44(%eax),%eax                
  1072c7:	eb 2c                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_CHOWN_RESTRICTED:                                        
      return_value = the_limits->posix_chown_restrictions;            
  1072c9:	8b 40 4c             	mov    0x4c(%eax),%eax                
  1072cc:	eb 27                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_NO_TRUNC:                                                
      return_value = the_limits->posix_no_trunc;                      
  1072ce:	8b 40 50             	mov    0x50(%eax),%eax                
  1072d1:	eb 22                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_VDISABLE:                                                
      return_value = the_limits->posix_vdisable;                      
  1072d3:	8b 40 5c             	mov    0x5c(%eax),%eax                
  1072d6:	eb 1d                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_ASYNC_IO:                                                
      return_value = the_limits->posix_async_io;                      
  1072d8:	8b 40 48             	mov    0x48(%eax),%eax                
  1072db:	eb 18                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
  1072dd:	8b 40 54             	mov    0x54(%eax),%eax                
  1072e0:	eb 13                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    case _PC_SYNC_IO:                                                 
      return_value = the_limits->posix_sync_io;                       
  1072e2:	8b 40 58             	mov    0x58(%eax),%eax                
  1072e5:	eb 0e                	jmp    1072f5 <fpathconf+0x89>        
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  1072e7:	e8 f4 9c 00 00       	call   110fe0 <__errno>               
  1072ec:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  1072f2:	83 c8 ff             	or     $0xffffffff,%eax               
      break;                                                          
  }                                                                   
                                                                      
  return return_value;                                                
}                                                                     
  1072f5:	c9                   	leave                                 
  1072f6:	c3                   	ret                                   
                                                                      

00106478 <free>: void free( void *ptr ) { MSBUMP(free_calls, 1);
  106478:	55                   	push   %ebp                           
  106479:	89 e5                	mov    %esp,%ebp                      
  10647b:	53                   	push   %ebx                           
  10647c:	83 ec 04             	sub    $0x4,%esp                      
  10647f:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  106482:	ff 05 b4 d6 11 00    	incl   0x11d6b4                       
                                                                      
  if ( !ptr )                                                         
  106488:	85 db                	test   %ebx,%ebx                      
  10648a:	74 5f                	je     1064eb <free+0x73>             
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
                                                                      
  if ( _System_state_Is_up(_System_state_Get()) &&                    
  10648c:	83 3d 38 d9 11 00 03 	cmpl   $0x3,0x11d938                  
  106493:	75 15                	jne    1064aa <free+0x32>             <== NEVER TAKEN
  106495:	e8 de 00 00 00       	call   106578 <malloc_is_system_state_OK>
  10649a:	84 c0                	test   %al,%al                        
  10649c:	75 0c                	jne    1064aa <free+0x32>             <== ALWAYS TAKEN
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
  10649e:	89 5d 08             	mov    %ebx,0x8(%ebp)                 <== NOT EXECUTED
      RTEMS_Malloc_Heap.begin,                                        
      RTEMS_Malloc_Heap.end                                           
    );                                                                
  }                                                                   
                                                                      
}                                                                     
  1064a1:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  1064a4:	c9                   	leave                                 <== NOT EXECUTED
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
                                                                      
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
  1064a5:	e9 0d 01 00 00       	jmp    1065b7 <malloc_deferred_free>  <== NOT EXECUTED
  #endif                                                              
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
  1064aa:	a1 d4 bb 11 00       	mov    0x11bbd4,%eax                  
  1064af:	85 c0                	test   %eax,%eax                      
  1064b1:	74 0a                	je     1064bd <free+0x45>             <== ALWAYS TAKEN
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
  1064b3:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1064b6:	53                   	push   %ebx                           <== NOT EXECUTED
  1064b7:	ff 50 08             	call   *0x8(%eax)                     <== NOT EXECUTED
  1064ba:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
  if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) {           
  1064bd:	50                   	push   %eax                           
  1064be:	50                   	push   %eax                           
  1064bf:	53                   	push   %ebx                           
  1064c0:	68 50 d6 11 00       	push   $0x11d650                      
  1064c5:	e8 a2 44 00 00       	call   10a96c <_Protected_heap_Free>  
  1064ca:	83 c4 10             	add    $0x10,%esp                     
  1064cd:	84 c0                	test   %al,%al                        
  1064cf:	75 1a                	jne    1064eb <free+0x73>             <== ALWAYS TAKEN
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
  1064d1:	ff 35 6c d6 11 00    	pushl  0x11d66c                       <== NOT EXECUTED
  1064d7:	ff 35 68 d6 11 00    	pushl  0x11d668                       <== NOT EXECUTED
  1064dd:	53                   	push   %ebx                           <== NOT EXECUTED
  1064de:	68 fc 71 11 00       	push   $0x1171fc                      <== NOT EXECUTED
  1064e3:	e8 76 0b 00 00       	call   10705e <printk>                <== NOT EXECUTED
  1064e8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
      RTEMS_Malloc_Heap.begin,                                        
      RTEMS_Malloc_Heap.end                                           
    );                                                                
  }                                                                   
                                                                      
}                                                                     
  1064eb:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  1064ee:	c9                   	leave                                 
  1064ef:	c3                   	ret                                   
                                                                      

00107a74 <free_user_env>: * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) {
  107a74:	55                   	push   %ebp                           <== NOT EXECUTED
  107a75:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107a77:	53                   	push   %ebx                           <== NOT EXECUTED
  107a78:	83 ec 04             	sub    $0x4,%esp                      <== NOT EXECUTED
  107a7b:	8b 5d 08             	mov    0x8(%ebp),%ebx                 <== NOT EXECUTED
  rtems_user_env_t *env = (rtems_user_env_t*) venv ;                  
                                                                      
	if (env != &rtems_global_user_env                                    
  107a7e:	81 fb 00 0a 12 00    	cmp    $0x120a00,%ebx                 <== NOT EXECUTED
  107a84:	74 40                	je     107ac6 <free_user_env+0x52>    <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT                                            
		&& --env->refcnt <= 0                                               
#endif                                                                
		) {                                                                 
		rtems_filesystem_freenode( &env->current_directory);                
  107a86:	8b 43 0c             	mov    0xc(%ebx),%eax                 <== NOT EXECUTED
  107a89:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107a8b:	74 13                	je     107aa0 <free_user_env+0x2c>    <== NOT EXECUTED
  107a8d:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  107a90:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  107a92:	74 0c                	je     107aa0 <free_user_env+0x2c>    <== NOT EXECUTED
  107a94:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107a97:	8d 43 04             	lea    0x4(%ebx),%eax                 <== NOT EXECUTED
  107a9a:	50                   	push   %eax                           <== NOT EXECUTED
  107a9b:	ff d2                	call   *%edx                          <== NOT EXECUTED
  107a9d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
		rtems_filesystem_freenode( &env->root_directory);                   
  107aa0:	8b 43 1c             	mov    0x1c(%ebx),%eax                <== NOT EXECUTED
  107aa3:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107aa5:	74 13                	je     107aba <free_user_env+0x46>    <== NOT EXECUTED
  107aa7:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  107aaa:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  107aac:	74 0c                	je     107aba <free_user_env+0x46>    <== NOT EXECUTED
  107aae:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107ab1:	8d 43 14             	lea    0x14(%ebx),%eax                <== NOT EXECUTED
  107ab4:	50                   	push   %eax                           <== NOT EXECUTED
  107ab5:	ff d2                	call   *%edx                          <== NOT EXECUTED
  107ab7:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
		free(env);                                                          
  107aba:	89 5d 08             	mov    %ebx,0x8(%ebp)                 <== NOT EXECUTED
	}                                                                    
}                                                                     
  107abd:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  107ac0:	c9                   	leave                                 <== NOT EXECUTED
		&& --env->refcnt <= 0                                               
#endif                                                                
		) {                                                                 
		rtems_filesystem_freenode( &env->current_directory);                
		rtems_filesystem_freenode( &env->root_directory);                   
		free(env);                                                          
  107ac1:	e9 0e f1 ff ff       	jmp    106bd4 <free>                  <== NOT EXECUTED
	}                                                                    
}                                                                     
  107ac6:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  107ac9:	c9                   	leave                                 <== NOT EXECUTED
  107aca:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00115538 <fstat>: int fstat( int fd, struct stat *sbuf ) {
  115538:	55                   	push   %ebp                           
  115539:	89 e5                	mov    %esp,%ebp                      
  11553b:	57                   	push   %edi                           
  11553c:	56                   	push   %esi                           
  11553d:	53                   	push   %ebx                           
  11553e:	83 ec 0c             	sub    $0xc,%esp                      
  115541:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115544:	8b 75 0c             	mov    0xc(%ebp),%esi                 
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !sbuf )                                                        
  115547:	85 f6                	test   %esi,%esi                      
  115549:	75 0d                	jne    115558 <fstat+0x20>            
    rtems_set_errno_and_return_minus_one( EFAULT );                   
  11554b:	e8 d8 9b ff ff       	call   10f128 <__errno>               
  115550:	c7 00 0e 00 00 00    	movl   $0xe,(%eax)                    
  115556:	eb 54                	jmp    1155ac <fstat+0x74>            
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
                                                                      
  iop = rtems_libio_iop( fd );                                        
  115558:	3b 05 d8 92 11 00    	cmp    0x1192d8,%eax                  
  11555e:	73 57                	jae    1155b7 <fstat+0x7f>            
  115560:	6b d8 34             	imul   $0x34,%eax,%ebx                
  115563:	03 1d 38 d6 11 00    	add    0x11d638,%ebx                  
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
  115569:	f6 43 0d 01          	testb  $0x1,0xd(%ebx)                 
  11556d:	74 48                	je     1155b7 <fstat+0x7f>            <== NEVER TAKEN
                                                                      
  if ( !iop->handlers )                                               
  11556f:	8b 43 30             	mov    0x30(%ebx),%eax                
  115572:	85 c0                	test   %eax,%eax                      
  115574:	74 41                	je     1155b7 <fstat+0x7f>            <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( EBADF );                    
                                                                      
  if ( !iop->handlers->fstat_h )                                      
  115576:	83 78 18 00          	cmpl   $0x0,0x18(%eax)                
  11557a:	75 0d                	jne    115589 <fstat+0x51>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  11557c:	e8 a7 9b ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  115581:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  115587:	eb 23                	jmp    1155ac <fstat+0x74>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
  memset( sbuf, 0, sizeof(struct stat) );                             
  115589:	b9 13 00 00 00       	mov    $0x13,%ecx                     
  11558e:	31 c0                	xor    %eax,%eax                      
  115590:	89 f7                	mov    %esi,%edi                      
  115592:	f3 ab                	rep stos %eax,%es:(%edi)              
                                                                      
  return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );           
  115594:	8b 53 30             	mov    0x30(%ebx),%edx                
  115597:	89 75 0c             	mov    %esi,0xc(%ebp)                 
  11559a:	8d 43 10             	lea    0x10(%ebx),%eax                
  11559d:	89 45 08             	mov    %eax,0x8(%ebp)                 
  1155a0:	8b 4a 18             	mov    0x18(%edx),%ecx                
}                                                                     
  1155a3:	83 c4 0c             	add    $0xc,%esp                      
  1155a6:	5b                   	pop    %ebx                           
  1155a7:	5e                   	pop    %esi                           
  1155a8:	5f                   	pop    %edi                           
  1155a9:	c9                   	leave                                 
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
  memset( sbuf, 0, sizeof(struct stat) );                             
                                                                      
  return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );           
  1155aa:	ff e1                	jmp    *%ecx                          
}                                                                     
  1155ac:	83 c8 ff             	or     $0xffffffff,%eax               
  1155af:	83 c4 0c             	add    $0xc,%esp                      
  1155b2:	5b                   	pop    %ebx                           
  1155b3:	5e                   	pop    %esi                           
  1155b4:	5f                   	pop    %edi                           
  1155b5:	c9                   	leave                                 
  1155b6:	c3                   	ret                                   
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
                                                                      
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_fd( fd );                                         
  1155b7:	e8 6c 9b ff ff       	call   10f128 <__errno>               
  1155bc:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    
  1155c2:	eb e8                	jmp    1155ac <fstat+0x74>            
                                                                      

00107414 <fsync>: #include <rtems/seterr.h> int fsync( int fd ) {
  107414:	55                   	push   %ebp                           
  107415:	89 e5                	mov    %esp,%ebp                      
  107417:	83 ec 08             	sub    $0x8,%esp                      
  10741a:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  10741d:	3b 05 38 d0 11 00    	cmp    0x11d038,%eax                  
  107423:	73 16                	jae    10743b <fsync+0x27>            <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  107425:	6b c0 34             	imul   $0x34,%eax,%eax                
  107428:	03 05 68 13 12 00    	add    0x121368,%eax                  
  rtems_libio_check_is_open(iop);                                     
  10742e:	f6 40 0d 01          	testb  $0x1,0xd(%eax)                 
  107432:	74 07                	je     10743b <fsync+0x27>            <== NEVER TAKEN
                                                                      
  /*                                                                  
   *  Now process the fsync().                                        
   */                                                                 
                                                                      
  if ( !iop->handlers )                                               
  107434:	8b 50 30             	mov    0x30(%eax),%edx                
  107437:	85 d2                	test   %edx,%edx                      
  107439:	75 0d                	jne    107448 <fsync+0x34>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EBADF );                    
  10743b:	e8 a0 9b 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  107440:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  107446:	eb 1a                	jmp    107462 <fsync+0x4e>            <== NOT EXECUTED
                                                                      
  if ( !iop->handlers->fsync_h )                                      
  107448:	8b 4a 28             	mov    0x28(%edx),%ecx                
  10744b:	85 c9                	test   %ecx,%ecx                      
  10744d:	75 0d                	jne    10745c <fsync+0x48>            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10744f:	e8 8c 9b 00 00       	call   110fe0 <__errno>               
  107454:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   
  10745a:	eb 06                	jmp    107462 <fsync+0x4e>            
                                                                      
  return (*iop->handlers->fsync_h)( iop );                            
  10745c:	89 45 08             	mov    %eax,0x8(%ebp)                 
}                                                                     
  10745f:	c9                   	leave                                 
    rtems_set_errno_and_return_minus_one( EBADF );                    
                                                                      
  if ( !iop->handlers->fsync_h )                                      
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  return (*iop->handlers->fsync_h)( iop );                            
  107460:	ff e1                	jmp    *%ecx                          
}                                                                     
  107462:	83 c8 ff             	or     $0xffffffff,%eax               
  107465:	c9                   	leave                                 
  107466:	c3                   	ret                                   
                                                                      

0010cd90 <ftruncate>: int ftruncate( int fd, off_t length ) {
  10cd90:	55                   	push   %ebp                           
  10cd91:	89 e5                	mov    %esp,%ebp                      
  10cd93:	57                   	push   %edi                           
  10cd94:	56                   	push   %esi                           
  10cd95:	53                   	push   %ebx                           
  10cd96:	83 ec 1c             	sub    $0x1c,%esp                     
  10cd99:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
  10cd9c:	3b 05 d8 92 11 00    	cmp    0x1192d8,%eax                  
  10cda2:	73 0f                	jae    10cdb3 <ftruncate+0x23>        <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  10cda4:	6b d8 34             	imul   $0x34,%eax,%ebx                
  10cda7:	03 1d 38 d6 11 00    	add    0x11d638,%ebx                  
  rtems_libio_check_is_open(iop);                                     
  10cdad:	f6 43 0d 01          	testb  $0x1,0xd(%ebx)                 
  10cdb1:	75 0d                	jne    10cdc0 <ftruncate+0x30>        <== ALWAYS TAKEN
  10cdb3:	e8 70 23 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10cdb8:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  10cdbe:	eb 5b                	jmp    10ce1b <ftruncate+0x8b>        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
  10cdc0:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  10cdc3:	8d 73 10             	lea    0x10(%ebx),%esi                
  10cdc6:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10cdcb:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  if ( !loc.ops->node_type_h )                                        
  10cdcd:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10cdd0:	8b 50 10             	mov    0x10(%eax),%edx                
  10cdd3:	85 d2                	test   %edx,%edx                      
  10cdd5:	74 39                	je     10ce10 <ftruncate+0x80>        <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
  10cdd7:	83 ec 0c             	sub    $0xc,%esp                      
  10cdda:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  10cddd:	50                   	push   %eax                           
  10cdde:	ff d2                	call   *%edx                          
  10cde0:	83 c4 10             	add    $0x10,%esp                     
  10cde3:	48                   	dec    %eax                           
  10cde4:	75 0d                	jne    10cdf3 <ftruncate+0x63>        
    rtems_set_errno_and_return_minus_one( EISDIR );                   
  10cde6:	e8 3d 23 00 00       	call   10f128 <__errno>               
  10cdeb:	c7 00 15 00 00 00    	movl   $0x15,(%eax)                   
  10cdf1:	eb 28                	jmp    10ce1b <ftruncate+0x8b>        
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
  10cdf3:	f6 43 0c 04          	testb  $0x4,0xc(%ebx)                 
  10cdf7:	75 0d                	jne    10ce06 <ftruncate+0x76>        <== ALWAYS TAKEN
  10cdf9:	e8 2a 23 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10cdfe:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  10ce04:	eb 15                	jmp    10ce1b <ftruncate+0x8b>        <== NOT EXECUTED
                                                                      
  if ( !iop->handlers->ftruncate_h )                                  
  10ce06:	8b 43 30             	mov    0x30(%ebx),%eax                
  10ce09:	8b 40 20             	mov    0x20(%eax),%eax                
  10ce0c:	85 c0                	test   %eax,%eax                      
  10ce0e:	75 10                	jne    10ce20 <ftruncate+0x90>        <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10ce10:	e8 13 23 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10ce15:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10ce1b:	83 c8 ff             	or     $0xffffffff,%eax               
  10ce1e:	eb 0b                	jmp    10ce2b <ftruncate+0x9b>        
                                                                      
  return (*iop->handlers->ftruncate_h)( iop, length );                
  10ce20:	52                   	push   %edx                           
  10ce21:	52                   	push   %edx                           
  10ce22:	ff 75 0c             	pushl  0xc(%ebp)                      
  10ce25:	53                   	push   %ebx                           
  10ce26:	ff d0                	call   *%eax                          
  10ce28:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  10ce2b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10ce2e:	5b                   	pop    %ebx                           
  10ce2f:	5e                   	pop    %esi                           
  10ce30:	5f                   	pop    %edi                           
  10ce31:	c9                   	leave                                 
  10ce32:	c3                   	ret                                   
                                                                      

0010efcc <getdents>: int getdents( int dd_fd, char *dd_buf, int dd_len ) {
  10efcc:	55                   	push   %ebp                           
  10efcd:	89 e5                	mov    %esp,%ebp                      
  10efcf:	57                   	push   %edi                           
  10efd0:	56                   	push   %esi                           
  10efd1:	53                   	push   %ebx                           
  10efd2:	83 ec 1c             	sub    $0x1c,%esp                     
  10efd5:	8b 45 08             	mov    0x8(%ebp),%eax                 
                                                                      
  /*                                                                  
   *  Get the file control block structure associated with the file descriptor
   */                                                                 
                                                                      
  iop = rtems_libio_iop( dd_fd );                                     
  10efd8:	31 db                	xor    %ebx,%ebx                      
  10efda:	3b 05 18 e2 11 00    	cmp    0x11e218,%eax                  
  10efe0:	73 09                	jae    10efeb <getdents+0x1f>         <== NEVER TAKEN
  10efe2:	6b d8 34             	imul   $0x34,%eax,%ebx                
  10efe5:	03 1d 18 26 12 00    	add    0x122618,%ebx                  
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
  10efeb:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  10efee:	8d 73 10             	lea    0x10(%ebx),%esi                
  10eff1:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10eff6:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  if ( !loc.ops->node_type_h )                                        
  10eff8:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10effb:	8b 50 10             	mov    0x10(%eax),%edx                
  10effe:	85 d2                	test   %edx,%edx                      
  10f000:	74 29                	je     10f02b <getdents+0x5f>         <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
  10f002:	83 ec 0c             	sub    $0xc,%esp                      
  10f005:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  10f008:	50                   	push   %eax                           
  10f009:	ff d2                	call   *%edx                          
  10f00b:	83 c4 10             	add    $0x10,%esp                     
  10f00e:	48                   	dec    %eax                           
  10f00f:	74 10                	je     10f021 <getdents+0x55>         
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  10f011:	e8 ca 2d 00 00       	call   111de0 <__errno>               
  10f016:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   
  10f01c:	83 c8 ff             	or     $0xffffffff,%eax               
  10f01f:	eb 24                	jmp    10f045 <getdents+0x79>         
  /*                                                                  
   *  Return the number of bytes that were actually transfered as a result
   *  of the read attempt.                                            
   */                                                                 
                                                                      
  if ( !iop->handlers->read_h )                                       
  10f021:	8b 43 30             	mov    0x30(%ebx),%eax                
  10f024:	8b 40 08             	mov    0x8(%eax),%eax                 
  10f027:	85 c0                	test   %eax,%eax                      
  10f029:	75 0d                	jne    10f038 <getdents+0x6c>         <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10f02b:	e8 b0 2d 00 00       	call   111de0 <__errno>               <== NOT EXECUTED
  10f030:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10f036:	eb e4                	jmp    10f01c <getdents+0x50>         <== NOT EXECUTED
                                                                      
  return (*iop->handlers->read_h)( iop, dd_buf, dd_len  );            
  10f038:	52                   	push   %edx                           
  10f039:	ff 75 10             	pushl  0x10(%ebp)                     
  10f03c:	ff 75 0c             	pushl  0xc(%ebp)                      
  10f03f:	53                   	push   %ebx                           
  10f040:	ff d0                	call   *%eax                          
  10f042:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  10f045:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10f048:	5b                   	pop    %ebx                           
  10f049:	5e                   	pop    %esi                           
  10f04a:	5f                   	pop    %edi                           
  10f04b:	c9                   	leave                                 
  10f04c:	c3                   	ret                                   
                                                                      

0010ce54 <gettimeofday>: int gettimeofday( struct timeval *tp, void * __tz ) {
  10ce54:	55                   	push   %ebp                           
  10ce55:	89 e5                	mov    %esp,%ebp                      
  10ce57:	56                   	push   %esi                           
  10ce58:	53                   	push   %ebx                           
  10ce59:	83 ec 20             	sub    $0x20,%esp                     
  10ce5c:	8b 75 08             	mov    0x8(%ebp),%esi                 
  /* struct timezone* tzp = (struct timezone*) __tz; */               
  if ( !tp ) {                                                        
  10ce5f:	85 f6                	test   %esi,%esi                      
  10ce61:	75 10                	jne    10ce73 <gettimeofday+0x1f>     <== ALWAYS TAKEN
    errno = EFAULT;                                                   
  10ce63:	e8 c0 22 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10ce68:	c7 00 0e 00 00 00    	movl   $0xe,(%eax)                    <== NOT EXECUTED
  10ce6e:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10ce71:	eb 2a                	jmp    10ce9d <gettimeofday+0x49>     <== NOT EXECUTED
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
  10ce73:	9c                   	pushf                                 
  10ce74:	fa                   	cli                                   
  10ce75:	5b                   	pop    %ebx                           
 *  This routine grows @a the_heap memory area using the size bytes which
  10ce76:	83 ec 0c             	sub    $0xc,%esp                      
  10ce79:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10ce7c:	50                   	push   %eax                           
  10ce7d:	e8 ba d0 ff ff       	call   109f3c <_TOD_Get>              
 *  begin at @a starting_address.                                     
  10ce82:	53                   	push   %ebx                           
  10ce83:	9d                   	popf                                  
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  10ce84:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10ce87:	89 06                	mov    %eax,(%esi)                    
 *  @param[in] starting_address is the starting address of the memory 
  10ce89:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  10ce8c:	b9 e8 03 00 00       	mov    $0x3e8,%ecx                    
  10ce91:	31 d2                	xor    %edx,%edx                      
  10ce93:	f7 f1                	div    %ecx                           
  10ce95:	89 46 04             	mov    %eax,0x4(%esi)                 
  10ce98:	31 c0                	xor    %eax,%eax                      
  10ce9a:	83 c4 10             	add    $0x10,%esp                     
   *  with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X    
   *  do it.  This puts us in good company.                           
   */                                                                 
                                                                      
  return 0;                                                           
}                                                                     
  10ce9d:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10cea0:	5b                   	pop    %ebx                           
  10cea1:	5e                   	pop    %esi                           
  10cea2:	c9                   	leave                                 
  10cea3:	c3                   	ret                                   
                                                                      

0011052c <imfs_dir_open>: rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) {
  11052c:	55                   	push   %ebp                           
  11052d:	89 e5                	mov    %esp,%ebp                      
  11052f:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  IMFS_jnode_t      *the_jnode;                                       
                                                                      
  /* Is the node a directory ? */                                     
  the_jnode = (IMFS_jnode_t *) iop->file_info;                        
                                                                      
  if ( the_jnode->type != IMFS_DIRECTORY )                            
  110532:	8b 41 2c             	mov    0x2c(%ecx),%eax                
  110535:	83 ca ff             	or     $0xffffffff,%edx               
  110538:	83 78 4c 01          	cmpl   $0x1,0x4c(%eax)                
  11053c:	75 09                	jne    110547 <imfs_dir_open+0x1b>    <== NEVER TAKEN
     return -1;      /* It wasn't a directory --> return error */     
                                                                      
  iop->offset = 0;                                                    
  11053e:	c7 41 08 00 00 00 00 	movl   $0x0,0x8(%ecx)                 
  110545:	31 d2                	xor    %edx,%edx                      
  return 0;                                                           
}                                                                     
  110547:	89 d0                	mov    %edx,%eax                      
  110549:	c9                   	leave                                 
  11054a:	c3                   	ret                                   
                                                                      

00110615 <imfs_dir_rmnod>: */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) {
  110615:	55                   	push   %ebp                           
  110616:	89 e5                	mov    %esp,%ebp                      
  110618:	56                   	push   %esi                           
  110619:	53                   	push   %ebx                           
  11061a:	83 ec 10             	sub    $0x10,%esp                     
  11061d:	8b 75 08             	mov    0x8(%ebp),%esi                 
  IMFS_jnode_t *the_jnode;                                            
                                                                      
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;                  
  110620:	8b 1e                	mov    (%esi),%ebx                    
                                                                      
  /*                                                                  
   * You cannot remove a node that still has children                 
   */                                                                 
                                                                      
  if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 
  110622:	8d 43 54             	lea    0x54(%ebx),%eax                
  110625:	39 43 50             	cmp    %eax,0x50(%ebx)                
  110628:	74 0d                	je     110637 <imfs_dir_rmnod+0x22>   
     rtems_set_errno_and_return_minus_one( ENOTEMPTY );               
  11062a:	e8 b1 09 00 00       	call   110fe0 <__errno>               
  11062f:	c7 00 5a 00 00 00    	movl   $0x5a,(%eax)                   
  110635:	eb 19                	jmp    110650 <imfs_dir_rmnod+0x3b>   
                                                                      
  /*                                                                  
   * You cannot remove the file system root node.                     
   */                                                                 
                                                                      
  if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
  110637:	8b 46 0c             	mov    0xc(%esi),%eax                 
  11063a:	39 58 18             	cmp    %ebx,0x18(%eax)                
  11063d:	74 06                	je     110645 <imfs_dir_rmnod+0x30>   
                                                                      
  /*                                                                  
   * You cannot remove a mountpoint.                                  
   */                                                                 
                                                                      
   if ( the_jnode->info.directory.mt_fs != NULL )                     
  11063f:	83 7b 5c 00          	cmpl   $0x0,0x5c(%ebx)                
  110643:	74 10                	je     110655 <imfs_dir_rmnod+0x40>   <== ALWAYS TAKEN
     rtems_set_errno_and_return_minus_one( EBUSY );                   
  110645:	e8 96 09 00 00       	call   110fe0 <__errno>               
  11064a:	c7 00 10 00 00 00    	movl   $0x10,(%eax)                   
  110650:	83 c8 ff             	or     $0xffffffff,%eax               
  110653:	eb 6c                	jmp    1106c1 <imfs_dir_rmnod+0xac>   
                                                                      
  /*                                                                  
   * Take the node out of the parent's chain that contains this node  
   */                                                                 
                                                                      
  if ( the_jnode->Parent != NULL ) {                                  
  110655:	83 7b 08 00          	cmpl   $0x0,0x8(%ebx)                 
  110659:	74 13                	je     11066e <imfs_dir_rmnod+0x59>   
  11065b:	83 ec 0c             	sub    $0xc,%esp                      
  11065e:	53                   	push   %ebx                           
  11065f:	e8 d0 e9 ff ff       	call   10f034 <_Chain_Extract>        
    rtems_chain_extract( (rtems_chain_node *) the_jnode );            
    the_jnode->Parent = NULL;                                         
  110664:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)                 
  11066b:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   * Decrement the link counter and see if we can free the space.     
   */                                                                 
                                                                      
  the_jnode->st_nlink--;                                              
  11066e:	66 ff 4b 34          	decw   0x34(%ebx)                     
  IMFS_update_ctime( the_jnode );                                     
  110672:	51                   	push   %ecx                           
  110673:	51                   	push   %ecx                           
  110674:	6a 00                	push   $0x0                           
  110676:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  110679:	50                   	push   %eax                           
  11067a:	e8 e9 6d ff ff       	call   107468 <gettimeofday>          
  11067f:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  110682:	89 43 48             	mov    %eax,0x48(%ebx)                
                                                                      
  /*                                                                  
   * The file cannot be open and the link must be less than 1 to free.
   */                                                                 
                                                                      
  if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
  110685:	89 1c 24             	mov    %ebx,(%esp)                    
  110688:	e8 13 6f ff ff       	call   1075a0 <rtems_libio_is_file_open>
  11068d:	83 c4 10             	add    $0x10,%esp                     
  110690:	85 c0                	test   %eax,%eax                      
  110692:	75 2b                	jne    1106bf <imfs_dir_rmnod+0xaa>   
  110694:	66 83 7b 34 00       	cmpw   $0x0,0x34(%ebx)                
  110699:	75 24                	jne    1106bf <imfs_dir_rmnod+0xaa>   
                                                                      
    /*                                                                
     * Is the rtems_filesystem_current is this node?                  
     */                                                               
                                                                      
    if ( rtems_filesystem_current.node_access == pathloc->node_access )
  11069b:	8b 15 cc f3 11 00    	mov    0x11f3cc,%edx                  
  1106a1:	8b 42 04             	mov    0x4(%edx),%eax                 
  1106a4:	3b 06                	cmp    (%esi),%eax                    
  1106a6:	75 07                	jne    1106af <imfs_dir_rmnod+0x9a>   <== ALWAYS TAKEN
       rtems_filesystem_current.node_access = NULL;                   
  1106a8:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * Free memory associated with a memory file.                     
     */                                                               
                                                                      
    free( the_jnode );                                                
  1106af:	83 ec 0c             	sub    $0xc,%esp                      
  1106b2:	53                   	push   %ebx                           
  1106b3:	e8 40 6c ff ff       	call   1072f8 <free>                  
  1106b8:	31 c0                	xor    %eax,%eax                      
  1106ba:	83 c4 10             	add    $0x10,%esp                     
  1106bd:	eb 02                	jmp    1106c1 <imfs_dir_rmnod+0xac>   
  1106bf:	31 c0                	xor    %eax,%eax                      
  }                                                                   
                                                                      
  return 0;                                                           
                                                                      
}                                                                     
  1106c1:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1106c4:	5b                   	pop    %ebx                           
  1106c5:	5e                   	pop    %esi                           
  1106c6:	c9                   	leave                                 
  1106c7:	c3                   	ret                                   
                                                                      

0010f8e0 <ioctl>: int ioctl( int fd, ioctl_command_t command, ... ) {
  10f8e0:	55                   	push   %ebp                           
  10f8e1:	89 e5                	mov    %esp,%ebp                      
  10f8e3:	83 ec 08             	sub    $0x8,%esp                      
  10f8e6:	8b 45 08             	mov    0x8(%ebp),%eax                 
  va_list            ap;                                              
  rtems_status_code  rc;                                              
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
  10f8e9:	3b 05 38 f0 11 00    	cmp    0x11f038,%eax                  
  10f8ef:	73 19                	jae    10f90a <ioctl+0x2a>            <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  10f8f1:	6b c0 34             	imul   $0x34,%eax,%eax                
  10f8f4:	03 05 a8 3b 12 00    	add    0x123ba8,%eax                  
  rtems_libio_check_is_open(iop);                                     
  10f8fa:	f6 40 0d 01          	testb  $0x1,0xd(%eax)                 
  10f8fe:	74 0a                	je     10f90a <ioctl+0x2a>            <== NEVER TAKEN
                                                                      
  va_start(ap, command);                                              
                                                                      
  buffer = va_arg(ap, void *);                                        
  10f900:	8b 4d 10             	mov    0x10(%ebp),%ecx                
                                                                      
  /*                                                                  
   *  Now process the ioctl().                                        
   */                                                                 
                                                                      
  if ( !iop->handlers )                                               
  10f903:	8b 50 30             	mov    0x30(%eax),%edx                
  10f906:	85 d2                	test   %edx,%edx                      
  10f908:	75 0d                	jne    10f917 <ioctl+0x37>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EBADF );                    
  10f90a:	e8 e9 29 00 00       	call   1122f8 <__errno>               <== NOT EXECUTED
  10f90f:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  10f915:	eb 12                	jmp    10f929 <ioctl+0x49>            <== NOT EXECUTED
                                                                      
  if ( !iop->handlers->ioctl_h )                                      
  10f917:	8b 52 10             	mov    0x10(%edx),%edx                
  10f91a:	85 d2                	test   %edx,%edx                      
  10f91c:	75 10                	jne    10f92e <ioctl+0x4e>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10f91e:	e8 d5 29 00 00       	call   1122f8 <__errno>               <== NOT EXECUTED
  10f923:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10f929:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10f92c:	eb 0d                	jmp    10f93b <ioctl+0x5b>            <== NOT EXECUTED
                                                                      
  rc = (*iop->handlers->ioctl_h)( iop, command, buffer );             
  10f92e:	83 ec 04             	sub    $0x4,%esp                      
  10f931:	51                   	push   %ecx                           
  10f932:	ff 75 0c             	pushl  0xc(%ebp)                      
  10f935:	50                   	push   %eax                           
  10f936:	ff d2                	call   *%edx                          
  10f938:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return rc;                                                          
}                                                                     
  10f93b:	c9                   	leave                                 
  10f93c:	c3                   	ret                                   
                                                                      

00107a7c <iproc>: /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) {
  107a7c:	55                   	push   %ebp                           <== NOT EXECUTED
  107a7d:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107a7f:	56                   	push   %esi                           <== NOT EXECUTED
  107a80:	53                   	push   %ebx                           <== NOT EXECUTED
  107a81:	89 d6                	mov    %edx,%esi                      <== NOT EXECUTED
  107a83:	88 c3                	mov    %al,%bl                        <== NOT EXECUTED
	if (tty->termios.c_iflag & ISTRIP)                                   
  107a85:	8b 4a 30             	mov    0x30(%edx),%ecx                <== NOT EXECUTED
  107a88:	f6 c1 20             	test   $0x20,%cl                      <== NOT EXECUTED
  107a8b:	74 03                	je     107a90 <iproc+0x14>            <== NOT EXECUTED
		c &= 0x7f;                                                          
  107a8d:	83 e3 7f             	and    $0x7f,%ebx                     <== NOT EXECUTED
	if (tty->termios.c_iflag & IUCLC)                                    
  107a90:	f6 c5 02             	test   $0x2,%ch                       <== NOT EXECUTED
  107a93:	74 13                	je     107aa8 <iproc+0x2c>            <== NOT EXECUTED
		c = tolower (c);                                                    
  107a95:	0f b6 d3             	movzbl %bl,%edx                       <== NOT EXECUTED
  107a98:	a1 00 b7 11 00       	mov    0x11b700,%eax                  <== NOT EXECUTED
  107a9d:	f6 04 10 01          	testb  $0x1,(%eax,%edx,1)             <== NOT EXECUTED
  107aa1:	74 03                	je     107aa6 <iproc+0x2a>            <== NOT EXECUTED
  107aa3:	83 c2 20             	add    $0x20,%edx                     <== NOT EXECUTED
  107aa6:	88 d3                	mov    %dl,%bl                        <== NOT EXECUTED
	if (c == '\r') {                                                     
  107aa8:	80 fb 0d             	cmp    $0xd,%bl                       <== NOT EXECUTED
  107aab:	75 11                	jne    107abe <iproc+0x42>            <== NOT EXECUTED
		if (tty->termios.c_iflag & IGNCR)                                   
  107aad:	84 c9                	test   %cl,%cl                        <== NOT EXECUTED
  107aaf:	0f 88 c9 00 00 00    	js     107b7e <iproc+0x102>           <== NOT EXECUTED
			return 0;                                                          
		if (tty->termios.c_iflag & ICRNL)                                   
  107ab5:	80 e5 01             	and    $0x1,%ch                       <== NOT EXECUTED
  107ab8:	74 1c                	je     107ad6 <iproc+0x5a>            <== NOT EXECUTED
  107aba:	b3 0a                	mov    $0xa,%bl                       <== NOT EXECUTED
  107abc:	eb 18                	jmp    107ad6 <iproc+0x5a>            <== NOT EXECUTED
			c = '\n';                                                          
	}                                                                    
	else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {            
  107abe:	80 fb 0a             	cmp    $0xa,%bl                       <== NOT EXECUTED
  107ac1:	75 0b                	jne    107ace <iproc+0x52>            <== NOT EXECUTED
  107ac3:	80 e1 40             	and    $0x40,%cl                      <== NOT EXECUTED
  107ac6:	0f 85 b8 00 00 00    	jne    107b84 <iproc+0x108>           <== NOT EXECUTED
  107acc:	eb 08                	jmp    107ad6 <iproc+0x5a>            <== NOT EXECUTED
		c = '\r';                                                           
	}                                                                    
	if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {                
  107ace:	84 db                	test   %bl,%bl                        <== NOT EXECUTED
  107ad0:	0f 84 80 00 00 00    	je     107b56 <iproc+0xda>            <== NOT EXECUTED
  107ad6:	8b 56 3c             	mov    0x3c(%esi),%edx                <== NOT EXECUTED
  107ad9:	f6 c2 02             	test   $0x2,%dl                       <== NOT EXECUTED
  107adc:	74 78                	je     107b56 <iproc+0xda>            <== NOT EXECUTED
		if (c == tty->termios.c_cc[VERASE]) {                               
  107ade:	3a 5e 43             	cmp    0x43(%esi),%bl                 <== NOT EXECUTED
  107ae1:	75 04                	jne    107ae7 <iproc+0x6b>            <== NOT EXECUTED
			erase (tty, 0);                                                    
  107ae3:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  107ae5:	eb 0a                	jmp    107af1 <iproc+0x75>            <== NOT EXECUTED
			return 0;                                                          
		}                                                                   
		else if (c == tty->termios.c_cc[VKILL]) {                           
  107ae7:	3a 5e 44             	cmp    0x44(%esi),%bl                 <== NOT EXECUTED
  107aea:	75 11                	jne    107afd <iproc+0x81>            <== NOT EXECUTED
			erase (tty, 1);                                                    
  107aec:	ba 01 00 00 00       	mov    $0x1,%edx                      <== NOT EXECUTED
  107af1:	89 f0                	mov    %esi,%eax                      <== NOT EXECUTED
  107af3:	e8 17 fe ff ff       	call   10790f <erase>                 <== NOT EXECUTED
  107af8:	e9 81 00 00 00       	jmp    107b7e <iproc+0x102>           <== NOT EXECUTED
			return 0;                                                          
		}                                                                   
		else if (c == tty->termios.c_cc[VEOF]) {                            
  107afd:	b8 01 00 00 00       	mov    $0x1,%eax                      <== NOT EXECUTED
  107b02:	3a 5e 45             	cmp    0x45(%esi),%bl                 <== NOT EXECUTED
  107b05:	74 79                	je     107b80 <iproc+0x104>           <== NOT EXECUTED
			return 1;                                                          
		}                                                                   
		else if (c == '\n') {                                               
  107b07:	80 fb 0a             	cmp    $0xa,%bl                       <== NOT EXECUTED
  107b0a:	75 1d                	jne    107b29 <iproc+0xad>            <== NOT EXECUTED
			if (tty->termios.c_lflag & (ECHO | ECHONL))                        
  107b0c:	80 e2 48             	and    $0x48,%dl                      <== NOT EXECUTED
  107b0f:	74 0c                	je     107b1d <iproc+0xa1>            <== NOT EXECUTED
				echo (c, tty);                                                    
  107b11:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107b13:	b8 0a 00 00 00       	mov    $0xa,%eax                      <== NOT EXECUTED
  107b18:	e8 9a fd ff ff       	call   1078b7 <echo>                  <== NOT EXECUTED
			tty->cbuf[tty->ccount++] = c;                                      
  107b1d:	8b 46 20             	mov    0x20(%esi),%eax                <== NOT EXECUTED
  107b20:	8b 56 1c             	mov    0x1c(%esi),%edx                <== NOT EXECUTED
  107b23:	c6 04 02 0a          	movb   $0xa,(%edx,%eax,1)             <== NOT EXECUTED
  107b27:	eb 22                	jmp    107b4b <iproc+0xcf>            <== NOT EXECUTED
			return 1;                                                          
		}                                                                   
		else if ((c == tty->termios.c_cc[VEOL])                             
  107b29:	3a 5e 4c             	cmp    0x4c(%esi),%bl                 <== NOT EXECUTED
  107b2c:	74 05                	je     107b33 <iproc+0xb7>            <== NOT EXECUTED
  107b2e:	3a 5e 51             	cmp    0x51(%esi),%bl                 <== NOT EXECUTED
  107b31:	75 23                	jne    107b56 <iproc+0xda>            <== NOT EXECUTED
		      || (c == tty->termios.c_cc[VEOL2])) {                         
			if (tty->termios.c_lflag & ECHO)                                   
  107b33:	80 e2 08             	and    $0x8,%dl                       <== NOT EXECUTED
  107b36:	74 0a                	je     107b42 <iproc+0xc6>            <== NOT EXECUTED
				echo (c, tty);                                                    
  107b38:	0f b6 c3             	movzbl %bl,%eax                       <== NOT EXECUTED
  107b3b:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107b3d:	e8 75 fd ff ff       	call   1078b7 <echo>                  <== NOT EXECUTED
			tty->cbuf[tty->ccount++] = c;                                      
  107b42:	8b 46 20             	mov    0x20(%esi),%eax                <== NOT EXECUTED
  107b45:	8b 56 1c             	mov    0x1c(%esi),%edx                <== NOT EXECUTED
  107b48:	88 1c 02             	mov    %bl,(%edx,%eax,1)              <== NOT EXECUTED
  107b4b:	40                   	inc    %eax                           <== NOT EXECUTED
  107b4c:	89 46 20             	mov    %eax,0x20(%esi)                <== NOT EXECUTED
  107b4f:	b8 01 00 00 00       	mov    $0x1,%eax                      <== NOT EXECUTED
  107b54:	eb 2a                	jmp    107b80 <iproc+0x104>           <== NOT EXECUTED
	}                                                                    
                                                                      
	/*                                                                   
	 * FIXME: Should do IMAXBEL handling somehow                         
	 */                                                                  
	if (tty->ccount < (CBUFSIZE-1)) {                                    
  107b56:	a1 3c b6 11 00       	mov    0x11b63c,%eax                  <== NOT EXECUTED
  107b5b:	48                   	dec    %eax                           <== NOT EXECUTED
  107b5c:	39 46 20             	cmp    %eax,0x20(%esi)                <== NOT EXECUTED
  107b5f:	7d 1d                	jge    107b7e <iproc+0x102>           <== NOT EXECUTED
		if (tty->termios.c_lflag & ECHO)                                    
  107b61:	f6 46 3c 08          	testb  $0x8,0x3c(%esi)                <== NOT EXECUTED
  107b65:	74 0a                	je     107b71 <iproc+0xf5>            <== NOT EXECUTED
			echo (c, tty);                                                     
  107b67:	0f b6 c3             	movzbl %bl,%eax                       <== NOT EXECUTED
  107b6a:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107b6c:	e8 46 fd ff ff       	call   1078b7 <echo>                  <== NOT EXECUTED
		tty->cbuf[tty->ccount++] = c;                                       
  107b71:	8b 46 20             	mov    0x20(%esi),%eax                <== NOT EXECUTED
  107b74:	8b 56 1c             	mov    0x1c(%esi),%edx                <== NOT EXECUTED
  107b77:	88 1c 02             	mov    %bl,(%edx,%eax,1)              <== NOT EXECUTED
  107b7a:	40                   	inc    %eax                           <== NOT EXECUTED
  107b7b:	89 46 20             	mov    %eax,0x20(%esi)                <== NOT EXECUTED
  107b7e:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
	}                                                                    
	return 0;                                                            
}                                                                     
  107b80:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107b81:	5e                   	pop    %esi                           <== NOT EXECUTED
  107b82:	c9                   	leave                                 <== NOT EXECUTED
  107b83:	c3                   	ret                                   <== NOT EXECUTED
	 * FIXME: Should do IMAXBEL handling somehow                         
	 */                                                                  
	if (tty->ccount < (CBUFSIZE-1)) {                                    
		if (tty->termios.c_lflag & ECHO)                                    
			echo (c, tty);                                                     
		tty->cbuf[tty->ccount++] = c;                                       
  107b84:	b3 0d                	mov    $0xd,%bl                       <== NOT EXECUTED
  107b86:	e9 4b ff ff ff       	jmp    107ad6 <iproc+0x5a>            <== NOT EXECUTED
                                                                      

001155dc <isatty>: #include <sys/stat.h> int isatty( int fd ) {
  1155dc:	55                   	push   %ebp                           
  1155dd:	89 e5                	mov    %esp,%ebp                      
  1155df:	83 ec 60             	sub    $0x60,%esp                     
  struct stat buf;                                                    
                                                                      
  if (fstat (fd, &buf) < 0)                                           
  1155e2:	8d 45 b4             	lea    -0x4c(%ebp),%eax               
  1155e5:	50                   	push   %eax                           
  1155e6:	ff 75 08             	pushl  0x8(%ebp)                      
  1155e9:	e8 4a ff ff ff       	call   115538 <fstat>                 
  1155ee:	83 c4 10             	add    $0x10,%esp                     
  1155f1:	31 d2                	xor    %edx,%edx                      
  1155f3:	85 c0                	test   %eax,%eax                      
  1155f5:	78 12                	js     115609 <isatty+0x2d>           <== NEVER TAKEN
  1155f7:	8b 45 c0             	mov    -0x40(%ebp),%eax               
  1155fa:	25 00 f0 00 00       	and    $0xf000,%eax                   
  1155ff:	31 d2                	xor    %edx,%edx                      
  115601:	3d 00 20 00 00       	cmp    $0x2000,%eax                   
  115606:	0f 94 c2             	sete   %dl                            
                                                                      
  if (S_ISCHR (buf.st_mode))                                          
    return 1;                                                         
                                                                      
  return 0;                                                           
}                                                                     
  115609:	89 d0                	mov    %edx,%eax                      
  11560b:	c9                   	leave                                 
  11560c:	c3                   	ret                                   
                                                                      

0011841c <killinfo>: int killinfo( pid_t pid, int sig, const union sigval *value ) {
  11841c:	55                   	push   %ebp                           
  11841d:	89 e5                	mov    %esp,%ebp                      
  11841f:	57                   	push   %edi                           
  118420:	56                   	push   %esi                           
  118421:	53                   	push   %ebx                           
  118422:	83 ec 2c             	sub    $0x2c,%esp                     
  118425:	8b 75 10             	mov    0x10(%ebp),%esi                
                                                                      
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid != getpid() )                                              
  118428:	e8 7f fc ff ff       	call   1180ac <getpid>                
  11842d:	39 45 08             	cmp    %eax,0x8(%ebp)                 
  118430:	74 0d                	je     11843f <killinfo+0x23>         <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ESRCH );                    
  118432:	e8 e5 81 ff ff       	call   11061c <__errno>               <== NOT EXECUTED
  118437:	c7 00 03 00 00 00    	movl   $0x3,(%eax)                    <== NOT EXECUTED
  11843d:	eb 11                	jmp    118450 <killinfo+0x34>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Validate the signal passed.                                     
   */                                                                 
                                                                      
  if ( !sig )                                                         
  11843f:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  118443:	75 13                	jne    118458 <killinfo+0x3c>         <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  118445:	e8 d2 81 ff ff       	call   11061c <__errno>               <== NOT EXECUTED
  11844a:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  118450:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  118453:	e9 05 02 00 00       	jmp    11865d <killinfo+0x241>        <== NOT EXECUTED
                                                                      
  if ( !is_valid_signo(sig) )                                         
  118458:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  11845b:	49                   	dec    %ecx                           
  11845c:	83 f9 1f             	cmp    $0x1f,%ecx                     
  11845f:	77 e4                	ja     118445 <killinfo+0x29>         <== NEVER TAKEN
                                                                      
  /*                                                                  
   *  If the signal is being ignored, then we are out of here.        
   */                                                                 
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {        
  118461:	6b 45 0c 0c          	imul   $0xc,0xc(%ebp),%eax            
  118465:	31 d2                	xor    %edx,%edx                      
  118467:	83 b8 88 98 12 00 01 	cmpl   $0x1,0x129888(%eax)            
  11846e:	0f 84 e9 01 00 00    	je     11865d <killinfo+0x241>        
   *  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 ) )      
  118474:	83 7d 0c 08          	cmpl   $0x8,0xc(%ebp)                 
  118478:	74 0c                	je     118486 <killinfo+0x6a>         
  11847a:	83 7d 0c 04          	cmpl   $0x4,0xc(%ebp)                 
  11847e:	74 06                	je     118486 <killinfo+0x6a>         
  118480:	83 7d 0c 0b          	cmpl   $0xb,0xc(%ebp)                 
  118484:	75 1a                	jne    1184a0 <killinfo+0x84>         
      return pthread_kill( pthread_self(), sig );                     
  118486:	e8 99 03 00 00       	call   118824 <pthread_self>          
  11848b:	53                   	push   %ebx                           
  11848c:	53                   	push   %ebx                           
  11848d:	ff 75 0c             	pushl  0xc(%ebp)                      
  118490:	50                   	push   %eax                           
  118491:	e8 e6 02 00 00       	call   11877c <pthread_kill>          
  118496:	89 c2                	mov    %eax,%edx                      
  118498:	83 c4 10             	add    $0x10,%esp                     
  11849b:	e9 bd 01 00 00       	jmp    11865d <killinfo+0x241>        
                                                                      
  mask = signo_to_mask( sig );                                        
  1184a0:	bb 01 00 00 00       	mov    $0x1,%ebx                      
  1184a5:	d3 e3                	shl    %cl,%ebx                       
  /*                                                                  
   *  Build up a siginfo structure                                    
   */                                                                 
                                                                      
  siginfo = &siginfo_struct;                                          
  siginfo->si_signo = sig;                                            
  1184a7:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1184aa:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  siginfo->si_code = SI_USER;                                         
  1184ad:	c7 45 ec 01 00 00 00 	movl   $0x1,-0x14(%ebp)               
  if ( !value ) {                                                     
  1184b4:	85 f6                	test   %esi,%esi                      
  1184b6:	75 09                	jne    1184c1 <killinfo+0xa5>         
    siginfo->si_value.sival_int = 0;                                  
  1184b8:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)               
  1184bf:	eb 05                	jmp    1184c6 <killinfo+0xaa>         
  } else {                                                            
    siginfo->si_value = *value;                                       
  1184c1:	8b 06                	mov    (%esi),%eax                    
  1184c3:	89 45 f0             	mov    %eax,-0x10(%ebp)               
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
  1184c6:	a1 94 92 12 00       	mov    0x129294,%eax                  
  1184cb:	40                   	inc    %eax                           
  1184cc:	a3 94 92 12 00       	mov    %eax,0x129294                  
  /*                                                                  
   *  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;                                     
  1184d1:	8b 35 54 93 12 00    	mov    0x129354,%esi                  
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  if ( _POSIX_signals_Is_interested( api, mask ) ) {                  
  1184d7:	8b 86 f8 00 00 00    	mov    0xf8(%esi),%eax                
  1184dd:	8b 80 c4 00 00 00    	mov    0xc4(%eax),%eax                
  1184e3:	f7 d0                	not    %eax                           
  1184e5:	85 c3                	test   %eax,%ebx                      
  1184e7:	0f 85 f4 00 00 00    	jne    1185e1 <killinfo+0x1c5>        
    goto process_it;                                                  
  1184ed:	b9 0c 9a 12 00       	mov    $0x129a0c,%ecx                 
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
                                                                      
    the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ];  
                                                                      
    for ( the_node = the_chain->first ;                               
  1184f2:	8b 11                	mov    (%ecx),%edx                    
    _Context_Restore_fp( &_Thread_Executing->fp_context );            
#endif                                                                
                                                                      
  _CPU_Context_Restart_self( &_Thread_Executing->Registers );         
}                                                                     
                                                                      
  1184f4:	8d 79 04             	lea    0x4(%ecx),%edi                 
  1184f7:	eb 23                	jmp    11851c <killinfo+0x100>        
          !_Chain_Is_tail( the_chain, the_node ) ;                    
          the_node = the_node->next ) {                               
                                                                      
      the_thread = (Thread_Control *)the_node;                        
  1184f9:	89 d6                	mov    %edx,%esi                      
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
  1184fb:	8b 82 f8 00 00 00    	mov    0xf8(%edx),%eax                
                                                                      
      if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) {
  118501:	85 5a 30             	test   %ebx,0x30(%edx)                
  118504:	0f 85 d7 00 00 00    	jne    1185e1 <killinfo+0x1c5>        <== ALWAYS TAKEN
  11850a:	8b 80 c4 00 00 00    	mov    0xc4(%eax),%eax                <== NOT EXECUTED
  118510:	f7 d0                	not    %eax                           <== NOT EXECUTED
  118512:	85 c3                	test   %eax,%ebx                      <== NOT EXECUTED
  118514:	0f 85 c7 00 00 00    	jne    1185e1 <killinfo+0x1c5>        <== NOT EXECUTED
                                                                      
    the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ];  
                                                                      
    for ( the_node = the_chain->first ;                               
          !_Chain_Is_tail( the_chain, the_node ) ;                    
          the_node = the_node->next ) {                               
  11851a:	8b 12                	mov    (%edx),%edx                    <== NOT EXECUTED
       index++ ) {                                                    
                                                                      
    the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ];  
                                                                      
    for ( the_node = the_chain->first ;                               
          !_Chain_Is_tail( the_chain, the_node ) ;                    
  11851c:	39 fa                	cmp    %edi,%edx                      
  11851e:	75 d9                	jne    1184f9 <killinfo+0xdd>         
  118520:	83 c1 0c             	add    $0xc,%ecx                      
   */                                                                 
                                                                      
  /* XXX violation of visibility -- need to define thread queue support */
                                                                      
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
  118523:	81 f9 3c 9a 12 00    	cmp    $0x129a3c,%ecx                 
  118529:	75 c7                	jne    1184f2 <killinfo+0xd6>         
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
                                                                      
  interested_thread = NULL;                                           
  interested_priority = PRIORITY_MAXIMUM + 1;                         
  11852b:	0f b6 05 e4 d0 11 00 	movzbl 0x11d0e4,%eax                  
  118532:	40                   	inc    %eax                           
  118533:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  118536:	c7 45 d0 02 00 00 00 	movl   $0x2,-0x30(%ebp)               
  11853d:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               
        the_api++ ) {                                                 
                                                                      
    /*                                                                
     *  Thie can occur when no one is interested and ITRON is not configured.
     */                                                               
    if ( !_Objects_Information_table[ the_api ] )                     
  118544:	8b 55 d0             	mov    -0x30(%ebp),%edx               
  118547:	8b 04 95 68 92 12 00 	mov    0x129268(,%edx,4),%eax         
  11854e:	85 c0                	test   %eax,%eax                      
  118550:	74 79                	je     1185cb <killinfo+0x1af>        
      continue;                                                       
                                                                      
    the_info = _Objects_Information_table[ the_api ][ 1 ];            
  118552:	8b 40 04             	mov    0x4(%eax),%eax                 
    /*                                                                
     *  This cannot happen in the current (as of Dec 2007) implementation
     *  of initialization but at some point, the object information   
     *  structure for a particular manager may not be installed.      
     */                                                               
    if ( !the_info )                                                  
  118555:	85 c0                	test   %eax,%eax                      
  118557:	74 72                	je     1185cb <killinfo+0x1af>        <== NEVER TAKEN
      continue;                                                       
                                                                      
    maximum = the_info->maximum;                                      
  118559:	0f b7 50 10          	movzwl 0x10(%eax),%edx                
  11855d:	89 55 d4             	mov    %edx,-0x2c(%ebp)               
    object_table = the_info->local_table;                             
  118560:	8b 40 1c             	mov    0x1c(%eax),%eax                
  118563:	89 45 d8             	mov    %eax,-0x28(%ebp)               
  118566:	bf 01 00 00 00       	mov    $0x1,%edi                      
  11856b:	eb 59                	jmp    1185c6 <killinfo+0x1aa>        
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
      the_thread = (Thread_Control *) object_table[ index ];          
  11856d:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  118570:	8b 14 b8             	mov    (%eax,%edi,4),%edx             
                                                                      
      if ( !the_thread )                                              
  118573:	85 d2                	test   %edx,%edx                      
  118575:	74 43                	je     1185ba <killinfo+0x19e>        
      /*                                                              
       *  If this thread is of lower priority than the interested thread,
       *  go on to the next thread.                                   
       */                                                             
                                                                      
      if ( the_thread->current_priority > interested_priority )       
  118577:	8b 72 14             	mov    0x14(%edx),%esi                
  11857a:	3b 75 e0             	cmp    -0x20(%ebp),%esi               
  11857d:	77 3b                	ja     1185ba <killinfo+0x19e>        <== NEVER TAKEN
                                                                      
      /*                                                              
       *  If this thread is not interested, then go on to the next thread.
       */                                                             
                                                                      
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
  11857f:	8b 82 f8 00 00 00    	mov    0xf8(%edx),%eax                
                                                                      
      if ( !api || !_POSIX_signals_Is_interested( api, mask ) )       
  118585:	85 c0                	test   %eax,%eax                      
  118587:	74 31                	je     1185ba <killinfo+0x19e>        <== NEVER TAKEN
  118589:	8b 80 c4 00 00 00    	mov    0xc4(%eax),%eax                
  11858f:	f7 d0                	not    %eax                           
  118591:	85 c3                	test   %eax,%ebx                      
  118593:	74 25                	je     1185ba <killinfo+0x19e>        
       *  Now we know the thread under connsideration is interested.  
       *  If the thread under consideration is of higher priority, then
       *  it becomes the interested thread.                           
       */                                                             
                                                                      
      if ( the_thread->current_priority < interested_priority ) {     
  118595:	3b 75 e0             	cmp    -0x20(%ebp),%esi               
  118598:	72 25                	jb     1185bf <killinfo+0x1a3>        <== ALWAYS TAKEN
       *  Now the thread and the interested thread have the same priority.
       *  If the interested thread is ready, then we don't need to send it
       *  to a blocked thread.                                        
       */                                                             
                                                                      
      if ( _States_Is_ready( interested_thread->current_state ) )     
  11859a:	8b 45 dc             	mov    -0x24(%ebp),%eax               <== NOT EXECUTED
  11859d:	8b 48 10             	mov    0x10(%eax),%ecx                <== NOT EXECUTED
  1185a0:	85 c9                	test   %ecx,%ecx                      <== NOT EXECUTED
  1185a2:	74 16                	je     1185ba <killinfo+0x19e>        <== NOT EXECUTED
       *  Now the interested thread is blocked.                       
       *  If the thread we are considering is not, the it becomes the 
       *  interested thread.                                          
       */                                                             
                                                                      
      if ( _States_Is_ready( the_thread->current_state ) ) {          
  1185a4:	8b 42 10             	mov    0x10(%edx),%eax                <== NOT EXECUTED
  1185a7:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1185a9:	74 14                	je     1185bf <killinfo+0x1a3>        <== NOT EXECUTED
       *  Now we know both threads are blocked.                       
       *  If the interested thread is interruptible, then just use it.
       */                                                             
                                                                      
      /* XXX need a new states macro */                               
      if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL )
  1185ab:	81 e1 00 00 00 10    	and    $0x10000000,%ecx               <== NOT EXECUTED
  1185b1:	75 07                	jne    1185ba <killinfo+0x19e>        <== NOT EXECUTED
       *  If the thread under consideration is interruptible by a signal,
       *  then it becomes the interested thread.                      
       */                                                             
                                                                      
      /* XXX need a new states macro */                               
      if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) {
  1185b3:	a9 00 00 00 10       	test   $0x10000000,%eax               <== NOT EXECUTED
  1185b8:	75 05                	jne    1185bf <killinfo+0x1a3>        <== NOT EXECUTED
  1185ba:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  1185bd:	eb 03                	jmp    1185c2 <killinfo+0x1a6>        
  1185bf:	89 55 dc             	mov    %edx,-0x24(%ebp)               
      continue;                                                       
                                                                      
    maximum = the_info->maximum;                                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
  1185c2:	47                   	inc    %edi                           
  1185c3:	89 75 e0             	mov    %esi,-0x20(%ebp)               
  1185c6:	3b 7d d4             	cmp    -0x2c(%ebp),%edi               
  1185c9:	76 a2                	jbe    11856d <killinfo+0x151>        
  interested_thread = NULL;                                           
  interested_priority = PRIORITY_MAXIMUM + 1;                         
                                                                      
  for ( the_api = OBJECTS_CLASSIC_API;                                
        the_api <= OBJECTS_APIS_LAST;                                 
        the_api++ ) {                                                 
  1185cb:	ff 45 d0             	incl   -0x30(%ebp)                    
                                                                      
  interested_thread = NULL;                                           
  interested_priority = PRIORITY_MAXIMUM + 1;                         
                                                                      
  for ( the_api = OBJECTS_CLASSIC_API;                                
        the_api <= OBJECTS_APIS_LAST;                                 
  1185ce:	83 7d d0 05          	cmpl   $0x5,-0x30(%ebp)               
  1185d2:	0f 85 6c ff ff ff    	jne    118544 <killinfo+0x128>        
        interested_priority = the_thread->current_priority;           
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( interested_thread ) {                                          
  1185d8:	83 7d dc 00          	cmpl   $0x0,-0x24(%ebp)               
  1185dc:	74 1c                	je     1185fa <killinfo+0x1de>        
  1185de:	8b 75 dc             	mov    -0x24(%ebp),%esi               
   *  evaluate the signals pending.                                   
   */                                                                 
                                                                      
process_it:                                                           
                                                                      
  the_thread->do_post_task_switch_extension = true;                   
  1185e1:	c6 46 75 01          	movb   $0x1,0x75(%esi)                
  /*                                                                  
   *  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 ) ) {  
  1185e5:	51                   	push   %ecx                           
  1185e6:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  1185e9:	50                   	push   %eax                           
  1185ea:	ff 75 0c             	pushl  0xc(%ebp)                      
  1185ed:	56                   	push   %esi                           
  1185ee:	e8 99 00 00 00       	call   11868c <_POSIX_signals_Unblock_thread>
  1185f3:	83 c4 10             	add    $0x10,%esp                     
  1185f6:	84 c0                	test   %al,%al                        
  1185f8:	75 5c                	jne    118656 <killinfo+0x23a>        
  /*                                                                  
   *  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 );                         
  1185fa:	83 ec 0c             	sub    $0xc,%esp                      
  1185fd:	53                   	push   %ebx                           
  1185fe:	e8 65 00 00 00       	call   118668 <_POSIX_signals_Set_process_signals>
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
  118603:	6b 5d 0c 0c          	imul   $0xc,0xc(%ebp),%ebx            
  118607:	83 c4 10             	add    $0x10,%esp                     
  11860a:	83 bb 80 98 12 00 02 	cmpl   $0x2,0x129880(%ebx)            
  118611:	75 43                	jne    118656 <killinfo+0x23a>        
                                                                      
    psiginfo = (POSIX_signals_Siginfo_node *)                         
  118613:	83 ec 0c             	sub    $0xc,%esp                      
  118616:	68 00 9a 12 00       	push   $0x129a00                      
  11861b:	e8 90 26 ff ff       	call   10acb0 <_Chain_Get>            
               _Chain_Get( &_POSIX_signals_Inactive_siginfo );        
    if ( !psiginfo ) {                                                
  118620:	83 c4 10             	add    $0x10,%esp                     
  118623:	85 c0                	test   %eax,%eax                      
  118625:	75 10                	jne    118637 <killinfo+0x21b>        <== ALWAYS TAKEN
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
  118627:	e8 f0 7f ff ff       	call   11061c <__errno>               <== NOT EXECUTED
  11862c:	c7 00 0b 00 00 00    	movl   $0xb,(%eax)                    <== NOT EXECUTED
  118632:	e9 19 fe ff ff       	jmp    118450 <killinfo+0x34>         <== NOT EXECUTED
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
  118637:	8d 78 08             	lea    0x8(%eax),%edi                 
  11863a:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  11863d:	b9 03 00 00 00       	mov    $0x3,%ecx                      
  118642:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
  118644:	52                   	push   %edx                           
  118645:	52                   	push   %edx                           
  118646:	50                   	push   %eax                           
  118647:	8d 83 50 9a 12 00    	lea    0x129a50(%ebx),%eax            
  11864d:	50                   	push   %eax                           
  11864e:	e8 39 26 ff ff       	call   10ac8c <_Chain_Append>         
  118653:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
  118656:	e8 b1 3b ff ff       	call   10c20c <_Thread_Enable_dispatch>
  11865b:	31 d2                	xor    %edx,%edx                      
  return 0;                                                           
}                                                                     
  11865d:	89 d0                	mov    %edx,%eax                      
  11865f:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  118662:	5b                   	pop    %ebx                           
  118663:	5e                   	pop    %esi                           
  118664:	5f                   	pop    %edi                           
  118665:	c9                   	leave                                 
  118666:	c3                   	ret                                   
                                                                      

00106844 <libc_delete_hook>: rtems_extension libc_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) {
  106844:	55                   	push   %ebp                           
  106845:	89 e5                	mov    %esp,%ebp                      
  106847:	57                   	push   %edi                           
  106848:	56                   	push   %esi                           
  106849:	53                   	push   %ebx                           
  10684a:	83 ec 0c             	sub    $0xc,%esp                      
  10684d:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  106850:	8b 75 0c             	mov    0xc(%ebp),%esi                 
                                                                      
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
  106853:	39 f7                	cmp    %esi,%edi                      
  106855:	75 08                	jne    10685f <libc_delete_hook+0x1b> 
    ptr = _REENT;                                                     
  106857:	8b 1d 20 b7 11 00    	mov    0x11b720,%ebx                  
  10685d:	eb 06                	jmp    106865 <libc_delete_hook+0x21> 
  } else {                                                            
    ptr = deleted_task->libc_reent;                                   
  10685f:	8b 9e f0 00 00 00    	mov    0xf0(%esi),%ebx                
  }                                                                   
                                                                      
  if (ptr && ptr != &libc_global_reent) {                             
  106865:	85 db                	test   %ebx,%ebx                      
  106867:	74 20                	je     106889 <libc_delete_hook+0x45> <== NEVER TAKEN
  106869:	81 fb 38 b2 11 00    	cmp    $0x11b238,%ebx                 
  10686f:	74 18                	je     106889 <libc_delete_hook+0x45> 
    _reclaim_reent(ptr);                                              
*/                                                                    
    /*                                                                
     *  Just in case there are some buffers lying around.             
     */                                                               
    _fwalk(ptr, newlib_free_buffers);                                 
  106871:	50                   	push   %eax                           
  106872:	50                   	push   %eax                           
  106873:	68 a9 68 10 00       	push   $0x1068a9                      
  106878:	53                   	push   %ebx                           
  106879:	e8 62 8f 00 00       	call   10f7e0 <_fwalk>                
#if REENT_MALLOCED                                                    
    free(ptr);                                                        
#else                                                                 
    _Workspace_Free(ptr);                                             
  10687e:	89 1c 24             	mov    %ebx,(%esp)                    
  106881:	e8 8e 55 00 00       	call   10be14 <_Workspace_Free>       
  106886:	83 c4 10             	add    $0x10,%esp                     
#endif                                                                
  }                                                                   
                                                                      
  deleted_task->libc_reent = NULL;                                    
  106889:	c7 86 f0 00 00 00 00 	movl   $0x0,0xf0(%esi)                
  106890:	00 00 00                                                    
                                                                      
  /*                                                                  
   * Require the switch back to another task to install its own       
   */                                                                 
                                                                      
  if ( current_task == deleted_task ) {                               
  106893:	39 f7                	cmp    %esi,%edi                      
  106895:	75 0a                	jne    1068a1 <libc_delete_hook+0x5d> 
    _REENT = 0;                                                       
  106897:	c7 05 20 b7 11 00 00 	movl   $0x0,0x11b720                  
  10689e:	00 00 00                                                    
  }                                                                   
}                                                                     
  1068a1:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1068a4:	5b                   	pop    %ebx                           
  1068a5:	5e                   	pop    %esi                           
  1068a6:	5f                   	pop    %edi                           
  1068a7:	c9                   	leave                                 
  1068a8:	c3                   	ret                                   
                                                                      

001156d4 <libc_wrapup>: extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) {
  1156d4:	55                   	push   %ebp                           
  1156d5:	89 e5                	mov    %esp,%ebp                      
  1156d7:	83 ec 08             	sub    $0x8,%esp                      
  /*                                                                  
   *  In case RTEMS is already down, don't do this.  It could be      
   *  dangerous.                                                      
   */                                                                 
                                                                      
  if (!_System_state_Is_up(_System_state_Get()))                      
  1156da:	83 3d 38 d9 11 00 03 	cmpl   $0x3,0x11d938                  
  1156e1:	75 55                	jne    115738 <libc_wrapup+0x64>      <== NEVER TAKEN
  /*                                                                  
   *  This was already done if the user called exit() directly .      
  _wrapup_reent(0);                                                   
   */                                                                 
                                                                      
  if (_REENT != &libc_global_reent) {                                 
  1156e3:	81 3d 20 b7 11 00 38 	cmpl   $0x11b238,0x11b720             
  1156ea:	b2 11 00                                                    
  1156ed:	74 1a                	je     115709 <libc_wrapup+0x35>      
      _wrapup_reent(&libc_global_reent);                              
  1156ef:	83 ec 0c             	sub    $0xc,%esp                      
  1156f2:	68 38 b2 11 00       	push   $0x11b238                      
  1156f7:	e8 b8 05 00 00       	call   115cb4 <_wrapup_reent>         
      /*  Don't reclaim this one, just in case we do printfs          
       *  on the way out to ROM.                                      
       */                                                             
      _reclaim_reent(&libc_global_reent);                             
#endif                                                                
      _REENT = &libc_global_reent;                                    
  1156fc:	c7 05 20 b7 11 00 38 	movl   $0x11b238,0x11b720             
  115703:	b2 11 00                                                    
  115706:	83 c4 10             	add    $0x10,%esp                     
   *                                                                  
   * Should this be changed to do *all* file streams?                 
   *    _fwalk (_REENT, fclose);                                      
   */                                                                 
                                                                      
  fclose (stdin);                                                     
  115709:	83 ec 0c             	sub    $0xc,%esp                      
  11570c:	a1 20 b7 11 00       	mov    0x11b720,%eax                  
  115711:	ff 70 04             	pushl  0x4(%eax)                      
  115714:	e8 5b 9b ff ff       	call   10f274 <fclose>                
  fclose (stdout);                                                    
  115719:	5a                   	pop    %edx                           
  11571a:	a1 20 b7 11 00       	mov    0x11b720,%eax                  
  11571f:	ff 70 08             	pushl  0x8(%eax)                      
  115722:	e8 4d 9b ff ff       	call   10f274 <fclose>                
  fclose (stderr);                                                    
  115727:	58                   	pop    %eax                           
  115728:	a1 20 b7 11 00       	mov    0x11b720,%eax                  
  11572d:	ff 70 0c             	pushl  0xc(%eax)                      
  115730:	e8 3f 9b ff ff       	call   10f274 <fclose>                
  115735:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  115738:	c9                   	leave                                 
  115739:	c3                   	ret                                   
                                                                      

001079d8 <link>: int link( const char *existing, const char *new ) {
  1079d8:	55                   	push   %ebp                           
  1079d9:	89 e5                	mov    %esp,%ebp                      
  1079db:	57                   	push   %edi                           
  1079dc:	56                   	push   %esi                           
  1079dd:	53                   	push   %ebx                           
  1079de:	83 ec 3c             	sub    $0x3c,%esp                     
  1079e1:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
                                                                      
  /*                                                                  
   * Get the node we are linking to.                                  
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path( existing, 0, &existing_loc, true );
  1079e4:	6a 01                	push   $0x1                           
  1079e6:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  1079e9:	50                   	push   %eax                           
  1079ea:	6a 00                	push   $0x0                           
  1079ec:	ff 75 08             	pushl  0x8(%ebp)                      
  1079ef:	e8 3e fb ff ff       	call   107532 <rtems_filesystem_evaluate_path>
  if ( result != 0 )                                                  
  1079f4:	83 c4 10             	add    $0x10,%esp                     
  1079f7:	83 ce ff             	or     $0xffffffff,%esi               
  1079fa:	85 c0                	test   %eax,%eax                      
  1079fc:	0f 85 7a 01 00 00    	jne    107b7c <link+0x1a4>            
                                                                      
  /*                                                                  
   * Get the parent of the node we are creating.                      
   */                                                                 
                                                                      
  rtems_filesystem_get_start_loc( new, &i, &parent_loc );             
  107a02:	8a 03                	mov    (%ebx),%al                     
  107a04:	3c 2f                	cmp    $0x2f,%al                      
  107a06:	74 08                	je     107a10 <link+0x38>             
  107a08:	3c 5c                	cmp    $0x5c,%al                      
  107a0a:	74 04                	je     107a10 <link+0x38>             <== NEVER TAKEN
  107a0c:	84 c0                	test   %al,%al                        
  107a0e:	75 16                	jne    107a26 <link+0x4e>             <== ALWAYS TAKEN
  107a10:	8d 7d d0             	lea    -0x30(%ebp),%edi               
  107a13:	a1 4c 09 12 00       	mov    0x12094c,%eax                  
  107a18:	8d 70 14             	lea    0x14(%eax),%esi                
  107a1b:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  107a20:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  107a22:	b1 01                	mov    $0x1,%cl                       
  107a24:	eb 12                	jmp    107a38 <link+0x60>             
  107a26:	8d 7d d0             	lea    -0x30(%ebp),%edi               
  107a29:	a1 4c 09 12 00       	mov    0x12094c,%eax                  
  107a2e:	8d 70 04             	lea    0x4(%eax),%esi                 
  107a31:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  107a36:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  if ( !parent_loc.ops->evalformake_h ) {                             
  107a38:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  107a3b:	8b 50 04             	mov    0x4(%eax),%edx                 
  107a3e:	85 d2                	test   %edx,%edx                      
  107a40:	75 21                	jne    107a63 <link+0x8b>             <== ALWAYS TAKEN
    rtems_filesystem_freenode( &existing_loc );                       
  107a42:	8b 45 e8             	mov    -0x18(%ebp),%eax               <== NOT EXECUTED
  107a45:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107a47:	0f 84 de 00 00 00    	je     107b2b <link+0x153>            <== NOT EXECUTED
  107a4d:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  107a50:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  107a52:	0f 84 d3 00 00 00    	je     107b2b <link+0x153>            <== NOT EXECUTED
  107a58:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107a5b:	8d 45 e0             	lea    -0x20(%ebp),%eax               <== NOT EXECUTED
  107a5e:	e9 c2 00 00 00       	jmp    107b25 <link+0x14d>            <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
  107a63:	56                   	push   %esi                           
  107a64:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  107a67:	50                   	push   %eax                           
  107a68:	8d 7d d0             	lea    -0x30(%ebp),%edi               
  107a6b:	57                   	push   %edi                           
  107a6c:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax             
  107a6f:	50                   	push   %eax                           
  107a70:	ff d2                	call   *%edx                          
  107a72:	89 c6                	mov    %eax,%esi                      
  if ( result != 0 ) {                                                
  107a74:	83 c4 10             	add    $0x10,%esp                     
  107a77:	85 c0                	test   %eax,%eax                      
  107a79:	74 29                	je     107aa4 <link+0xcc>             
    rtems_filesystem_freenode( &existing_loc );                       
  107a7b:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  107a7e:	85 c0                	test   %eax,%eax                      
  107a80:	74 13                	je     107a95 <link+0xbd>             <== NEVER TAKEN
  107a82:	8b 50 1c             	mov    0x1c(%eax),%edx                
  107a85:	85 d2                	test   %edx,%edx                      
  107a87:	74 0c                	je     107a95 <link+0xbd>             <== NEVER TAKEN
  107a89:	83 ec 0c             	sub    $0xc,%esp                      
  107a8c:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  107a8f:	50                   	push   %eax                           
  107a90:	ff d2                	call   *%edx                          
  107a92:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( result );                   
  107a95:	e8 16 9b 00 00       	call   1115b0 <__errno>               
  107a9a:	89 30                	mov    %esi,(%eax)                    
  107a9c:	83 ce ff             	or     $0xffffffff,%esi               
  107a9f:	e9 d8 00 00 00       	jmp    107b7c <link+0x1a4>            
  /*                                                                  
   *  Check to see if the caller is trying to link across file system 
   *  boundaries.                                                     
   */                                                                 
                                                                      
  if ( parent_loc.mt_entry != existing_loc.mt_entry ) {               
  107aa4:	8b 45 dc             	mov    -0x24(%ebp),%eax               
  107aa7:	3b 45 ec             	cmp    -0x14(%ebp),%eax               
  107aaa:	74 41                	je     107aed <link+0x115>            
    rtems_filesystem_freenode( &existing_loc );                       
  107aac:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  107aaf:	85 c0                	test   %eax,%eax                      
  107ab1:	74 13                	je     107ac6 <link+0xee>             <== NEVER TAKEN
  107ab3:	8b 50 1c             	mov    0x1c(%eax),%edx                
  107ab6:	85 d2                	test   %edx,%edx                      
  107ab8:	74 0c                	je     107ac6 <link+0xee>             <== NEVER TAKEN
  107aba:	83 ec 0c             	sub    $0xc,%esp                      
  107abd:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  107ac0:	50                   	push   %eax                           
  107ac1:	ff d2                	call   *%edx                          
  107ac3:	83 c4 10             	add    $0x10,%esp                     
    rtems_filesystem_freenode( &parent_loc );                         
  107ac6:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  107ac9:	85 c0                	test   %eax,%eax                      
  107acb:	74 13                	je     107ae0 <link+0x108>            <== NEVER TAKEN
  107acd:	8b 50 1c             	mov    0x1c(%eax),%edx                
  107ad0:	85 d2                	test   %edx,%edx                      
  107ad2:	74 0c                	je     107ae0 <link+0x108>            <== NEVER TAKEN
  107ad4:	83 ec 0c             	sub    $0xc,%esp                      
  107ad7:	8d 45 d0             	lea    -0x30(%ebp),%eax               
  107ada:	50                   	push   %eax                           
  107adb:	ff d2                	call   *%edx                          
  107add:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( EXDEV );                    
  107ae0:	e8 cb 9a 00 00       	call   1115b0 <__errno>               
  107ae5:	c7 00 12 00 00 00    	movl   $0x12,(%eax)                   
  107aeb:	eb af                	jmp    107a9c <link+0xc4>             
  }                                                                   
                                                                      
  if ( !parent_loc.ops->link_h ) {                                    
  107aed:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  107af0:	8b 40 08             	mov    0x8(%eax),%eax                 
  107af3:	85 c0                	test   %eax,%eax                      
  107af5:	75 44                	jne    107b3b <link+0x163>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &existing_loc );                       
  107af7:	8b 45 e8             	mov    -0x18(%ebp),%eax               <== NOT EXECUTED
  107afa:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107afc:	74 13                	je     107b11 <link+0x139>            <== NOT EXECUTED
  107afe:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  107b01:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  107b03:	74 0c                	je     107b11 <link+0x139>            <== NOT EXECUTED
  107b05:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107b08:	8d 45 e0             	lea    -0x20(%ebp),%eax               <== NOT EXECUTED
  107b0b:	50                   	push   %eax                           <== NOT EXECUTED
  107b0c:	ff d2                	call   *%edx                          <== NOT EXECUTED
  107b0e:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_filesystem_freenode( &parent_loc );                         
  107b11:	8b 45 d8             	mov    -0x28(%ebp),%eax               <== NOT EXECUTED
  107b14:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107b16:	74 13                	je     107b2b <link+0x153>            <== NOT EXECUTED
  107b18:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  107b1b:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  107b1d:	74 0c                	je     107b2b <link+0x153>            <== NOT EXECUTED
  107b1f:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107b22:	8d 45 d0             	lea    -0x30(%ebp),%eax               <== NOT EXECUTED
  107b25:	50                   	push   %eax                           <== NOT EXECUTED
  107b26:	ff d2                	call   *%edx                          <== NOT EXECUTED
  107b28:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  107b2b:	e8 80 9a 00 00       	call   1115b0 <__errno>               <== NOT EXECUTED
  107b30:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  107b36:	e9 61 ff ff ff       	jmp    107a9c <link+0xc4>             <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
  107b3b:	52                   	push   %edx                           
  107b3c:	ff 75 f0             	pushl  -0x10(%ebp)                    
  107b3f:	57                   	push   %edi                           
  107b40:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  107b43:	57                   	push   %edi                           
  107b44:	ff d0                	call   *%eax                          
  107b46:	89 c6                	mov    %eax,%esi                      
                                                                      
  rtems_filesystem_freenode( &existing_loc );                         
  107b48:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  107b4b:	83 c4 10             	add    $0x10,%esp                     
  107b4e:	85 c0                	test   %eax,%eax                      
  107b50:	74 10                	je     107b62 <link+0x18a>            <== NEVER TAKEN
  107b52:	8b 40 1c             	mov    0x1c(%eax),%eax                
  107b55:	85 c0                	test   %eax,%eax                      
  107b57:	74 09                	je     107b62 <link+0x18a>            <== NEVER TAKEN
  107b59:	83 ec 0c             	sub    $0xc,%esp                      
  107b5c:	57                   	push   %edi                           
  107b5d:	ff d0                	call   *%eax                          
  107b5f:	83 c4 10             	add    $0x10,%esp                     
  rtems_filesystem_freenode( &parent_loc );                           
  107b62:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  107b65:	85 c0                	test   %eax,%eax                      
  107b67:	74 13                	je     107b7c <link+0x1a4>            <== NEVER TAKEN
  107b69:	8b 50 1c             	mov    0x1c(%eax),%edx                
  107b6c:	85 d2                	test   %edx,%edx                      
  107b6e:	74 0c                	je     107b7c <link+0x1a4>            <== NEVER TAKEN
  107b70:	83 ec 0c             	sub    $0xc,%esp                      
  107b73:	8d 45 d0             	lea    -0x30(%ebp),%eax               
  107b76:	50                   	push   %eax                           
  107b77:	ff d2                	call   *%edx                          
  107b79:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  107b7c:	89 f0                	mov    %esi,%eax                      
  107b7e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  107b81:	5b                   	pop    %ebx                           
  107b82:	5e                   	pop    %esi                           
  107b83:	5f                   	pop    %edi                           
  107b84:	c9                   	leave                                 
  107b85:	c3                   	ret                                   
                                                                      

00115610 <lseek>: off_t lseek( int fd, off_t offset, int whence ) {
  115610:	55                   	push   %ebp                           
  115611:	89 e5                	mov    %esp,%ebp                      
  115613:	56                   	push   %esi                           
  115614:	53                   	push   %ebx                           
  115615:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115618:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  11561b:	8b 55 10             	mov    0x10(%ebp),%edx                
  rtems_libio_t *iop;                                                 
  off_t          old_offset;                                          
  off_t          status;                                              
                                                                      
  rtems_libio_check_fd( fd );                                         
  11561e:	3b 05 d8 92 11 00    	cmp    0x1192d8,%eax                  
  115624:	73 0f                	jae    115635 <lseek+0x25>            <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  115626:	6b d8 34             	imul   $0x34,%eax,%ebx                
  115629:	03 1d 38 d6 11 00    	add    0x11d638,%ebx                  
  rtems_libio_check_is_open(iop);                                     
  11562f:	f6 43 0d 01          	testb  $0x1,0xd(%ebx)                 
  115633:	75 0d                	jne    115642 <lseek+0x32>            <== ALWAYS TAKEN
  115635:	e8 ee 9a ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  11563a:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  115640:	eb 46                	jmp    115688 <lseek+0x78>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check as many errors as possible before touching iop->offset.   
   */                                                                 
                                                                      
  if ( !iop->handlers->lseek_h )                                      
  115642:	8b 43 30             	mov    0x30(%ebx),%eax                
  115645:	83 78 14 00          	cmpl   $0x0,0x14(%eax)                
  115649:	75 0d                	jne    115658 <lseek+0x48>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  11564b:	e8 d8 9a ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  115650:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  115656:	eb 30                	jmp    115688 <lseek+0x78>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the lseek().                                        
   */                                                                 
                                                                      
  old_offset = iop->offset;                                           
  115658:	8b 73 08             	mov    0x8(%ebx),%esi                 
  switch ( whence ) {                                                 
  11565b:	83 fa 01             	cmp    $0x1,%edx                      
  11565e:	74 0e                	je     11566e <lseek+0x5e>            
  115660:	83 fa 02             	cmp    $0x2,%edx                      
  115663:	74 0e                	je     115673 <lseek+0x63>            
  115665:	85 d2                	test   %edx,%edx                      
  115667:	75 14                	jne    11567d <lseek+0x6d>            
    case SEEK_SET:                                                    
      iop->offset = offset;                                           
  115669:	89 4b 08             	mov    %ecx,0x8(%ebx)                 
  11566c:	eb 1f                	jmp    11568d <lseek+0x7d>            
      break;                                                          
                                                                      
    case SEEK_CUR:                                                    
      iop->offset += offset;                                          
  11566e:	8d 04 31             	lea    (%ecx,%esi,1),%eax             
  115671:	eb 05                	jmp    115678 <lseek+0x68>            
      break;                                                          
                                                                      
    case SEEK_END:                                                    
      iop->offset = iop->size + offset;                               
  115673:	89 c8                	mov    %ecx,%eax                      
  115675:	03 43 04             	add    0x4(%ebx),%eax                 
  115678:	89 43 08             	mov    %eax,0x8(%ebx)                 
  11567b:	eb 10                	jmp    11568d <lseek+0x7d>            
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  11567d:	e8 a6 9a ff ff       	call   10f128 <__errno>               
  115682:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  115688:	83 c8 ff             	or     $0xffffffff,%eax               
  11568b:	eb 15                	jmp    1156a2 <lseek+0x92>            
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->handlers->lseek_h)( iop, offset, whence );          
  11568d:	50                   	push   %eax                           
  11568e:	8b 43 30             	mov    0x30(%ebx),%eax                
  115691:	52                   	push   %edx                           
  115692:	51                   	push   %ecx                           
  115693:	53                   	push   %ebx                           
  115694:	ff 50 14             	call   *0x14(%eax)                    
  if ( status == (off_t) -1 )                                         
  115697:	83 c4 10             	add    $0x10,%esp                     
  11569a:	83 f8 ff             	cmp    $0xffffffff,%eax               
  11569d:	75 03                	jne    1156a2 <lseek+0x92>            
    iop->offset = old_offset;                                         
  11569f:	89 73 08             	mov    %esi,0x8(%ebx)                 
  /*                                                                  
   *  So if the operation failed, we have to restore iop->offset.     
   */                                                                 
                                                                      
  return status;                                                      
}                                                                     
  1156a2:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1156a5:	5b                   	pop    %ebx                           
  1156a6:	5e                   	pop    %esi                           
  1156a7:	c9                   	leave                                 
  1156a8:	c3                   	ret                                   
                                                                      

00106674 <malloc>: size_t size ) { void *return_this; MSBUMP(malloc_calls, 1);
  106674:	55                   	push   %ebp                           
  106675:	89 e5                	mov    %esp,%ebp                      
  106677:	56                   	push   %esi                           
  106678:	53                   	push   %ebx                           
  106679:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10667c:	ff 05 ac d6 11 00    	incl   0x11d6ac                       
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
  106682:	e8 48 ff ff ff       	call   1065cf <malloc_deferred_frees_process>
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
  106687:	85 f6                	test   %esi,%esi                      
  106689:	74 75                	je     106700 <malloc+0x8c>           <== NEVER TAKEN
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
  10668b:	83 3d 38 d9 11 00 03 	cmpl   $0x3,0x11d938                  
  106692:	75 09                	jne    10669d <malloc+0x29>           
  106694:	e8 df fe ff ff       	call   106578 <malloc_is_system_state_OK>
  106699:	84 c0                	test   %al,%al                        
  10669b:	74 63                	je     106700 <malloc+0x8c>           <== NEVER TAKEN
   * Try to give a segment in the current heap if there is not        
   * enough space then try to grow the heap.                          
   * If this fails then return a NULL pointer.                        
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 
  10669d:	51                   	push   %ecx                           
  10669e:	51                   	push   %ecx                           
  10669f:	56                   	push   %esi                           
  1066a0:	68 50 d6 11 00       	push   $0x11d650                      
  1066a5:	e8 8e 42 00 00       	call   10a938 <_Protected_heap_Allocate>
  1066aa:	89 c3                	mov    %eax,%ebx                      
                                                                      
  if ( !return_this ) {                                               
  1066ac:	83 c4 10             	add    $0x10,%esp                     
  1066af:	85 c0                	test   %eax,%eax                      
  1066b1:	75 26                	jne    1066d9 <malloc+0x65>           <== ALWAYS TAKEN
    if (rtems_malloc_sbrk_helpers)                                    
  1066b3:	a1 d8 bb 11 00       	mov    0x11bbd8,%eax                  <== NOT EXECUTED
  1066b8:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1066ba:	74 0e                	je     1066ca <malloc+0x56>           <== NOT EXECUTED
      return_this = (*rtems_malloc_sbrk_helpers->extend)( size );     
  1066bc:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1066bf:	56                   	push   %esi                           <== NOT EXECUTED
  1066c0:	ff 50 04             	call   *0x4(%eax)                     <== NOT EXECUTED
    if ( !return_this ) {                                             
  1066c3:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1066c6:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1066c8:	75 0d                	jne    1066d7 <malloc+0x63>           <== NOT EXECUTED
      errno = ENOMEM;                                                 
  1066ca:	e8 59 8a 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  1066cf:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  1066d5:	eb 2b                	jmp    106702 <malloc+0x8e>           <== NOT EXECUTED
      return (void *) 0;                                              
  1066d7:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  If the user wants us to dirty the allocated memory, then do it. 
   */                                                                 
  if ( rtems_malloc_dirty_helper )                                    
  1066d9:	a1 dc bb 11 00       	mov    0x11bbdc,%eax                  
  1066de:	85 c0                	test   %eax,%eax                      
  1066e0:	74 09                	je     1066eb <malloc+0x77>           <== ALWAYS TAKEN
    (*rtems_malloc_dirty_helper)( return_this, size );                
  1066e2:	52                   	push   %edx                           <== NOT EXECUTED
  1066e3:	52                   	push   %edx                           <== NOT EXECUTED
  1066e4:	56                   	push   %esi                           <== NOT EXECUTED
  1066e5:	53                   	push   %ebx                           <== NOT EXECUTED
  1066e6:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1066e8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
  1066eb:	a1 d4 bb 11 00       	mov    0x11bbd4,%eax                  
  1066f0:	85 c0                	test   %eax,%eax                      
  1066f2:	74 0e                	je     106702 <malloc+0x8e>           <== ALWAYS TAKEN
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
  1066f4:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1066f7:	53                   	push   %ebx                           <== NOT EXECUTED
  1066f8:	ff 50 04             	call   *0x4(%eax)                     <== NOT EXECUTED
  1066fb:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1066fe:	eb 02                	jmp    106702 <malloc+0x8e>           <== NOT EXECUTED
  106700:	31 db                	xor    %ebx,%ebx                      
    if (rtems_malloc_boundary_helpers)                                
      (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); 
  #endif                                                              
                                                                      
  return return_this;                                                 
}                                                                     
  106702:	89 d8                	mov    %ebx,%eax                      
  106704:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  106707:	5b                   	pop    %ebx                           
  106708:	5e                   	pop    %esi                           
  106709:	c9                   	leave                                 
  10670a:	c3                   	ret                                   
                                                                      

001065b7 <malloc_deferred_free>: } void malloc_deferred_free( void *pointer ) {
  1065b7:	55                   	push   %ebp                           <== NOT EXECUTED
  1065b8:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1065ba:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
  1065bd:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  1065c0:	68 44 d6 11 00       	push   $0x11d644                      <== NOT EXECUTED
  1065c5:	e8 22 35 00 00       	call   109aec <_Chain_Append>         <== NOT EXECUTED
  1065ca:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer);
}                                                                     
  1065cd:	c9                   	leave                                 <== NOT EXECUTED
  1065ce:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001065cf <malloc_deferred_frees_process>: { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) {
  1065cf:	55                   	push   %ebp                           
  1065d0:	89 e5                	mov    %esp,%ebp                      
  1065d2:	83 ec 08             	sub    $0x8,%esp                      
  1065d5:	eb 0c                	jmp    1065e3 <malloc_deferred_frees_process+0x14>
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
    free(to_be_freed);                                                
  1065d7:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1065da:	50                   	push   %eax                           <== NOT EXECUTED
  1065db:	e8 98 fe ff ff       	call   106478 <free>                  <== NOT EXECUTED
  1065e0:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1065e3:	83 ec 0c             	sub    $0xc,%esp                      
  1065e6:	68 44 d6 11 00       	push   $0x11d644                      
  1065eb:	e8 20 35 00 00       	call   109b10 <_Chain_Get>            
  rtems_chain_node  *to_be_freed;                                     
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
  1065f0:	83 c4 10             	add    $0x10,%esp                     
  1065f3:	85 c0                	test   %eax,%eax                      
  1065f5:	75 e0                	jne    1065d7 <malloc_deferred_frees_process+0x8><== NEVER TAKEN
    free(to_be_freed);                                                
}                                                                     
  1065f7:	c9                   	leave                                 
  1065f8:	c3                   	ret                                   
                                                                      

00106578 <malloc_is_system_state_OK>: #include "malloc_p.h" rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) {
  106578:	55                   	push   %ebp                           
  106579:	89 e5                	mov    %esp,%ebp                      
  if ( _Thread_Dispatch_disable_level > 0 )                           
  10657b:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  106580:	31 d2                	xor    %edx,%edx                      
  106582:	85 c0                	test   %eax,%eax                      
  106584:	75 0a                	jne    106590 <malloc_is_system_state_OK+0x18><== NEVER TAKEN
    return false;                                                     
                                                                      
  if ( _ISR_Nest_level > 0 )                                          
  106586:	a1 34 d8 11 00       	mov    0x11d834,%eax                  
  10658b:	85 c0                	test   %eax,%eax                      
  10658d:	0f 94 c2             	sete   %dl                            
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
  106590:	88 d0                	mov    %dl,%al                        
  106592:	c9                   	leave                                 
  106593:	c3                   	ret                                   
                                                                      

0010f8ec <memfile_alloc_block>: */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) {
  10f8ec:	55                   	push   %ebp                           
  10f8ed:	89 e5                	mov    %esp,%ebp                      
  10f8ef:	83 ec 10             	sub    $0x10,%esp                     
  void *memory;                                                       
                                                                      
  memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);           
  10f8f2:	ff 35 ac 11 12 00    	pushl  0x1211ac                       
  10f8f8:	6a 01                	push   $0x1                           
  10f8fa:	e8 fd 74 ff ff       	call   106dfc <calloc>                
  if ( memory )                                                       
  10f8ff:	83 c4 10             	add    $0x10,%esp                     
  10f902:	85 c0                	test   %eax,%eax                      
  10f904:	74 06                	je     10f90c <memfile_alloc_block+0x20><== NEVER TAKEN
    memfile_blocks_allocated++;                                       
  10f906:	ff 05 b8 12 12 00    	incl   0x1212b8                       
                                                                      
  return memory;                                                      
}                                                                     
  10f90c:	c9                   	leave                                 
  10f90d:	c3                   	ret                                   
                                                                      

0010fc6d <memfile_check_rmnod>: return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){
  10fc6d:	55                   	push   %ebp                           
  10fc6e:	89 e5                	mov    %esp,%ebp                      
  10fc70:	53                   	push   %ebx                           
  10fc71:	83 ec 10             	sub    $0x10,%esp                     
  10fc74:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
                                                                      
  /*                                                                  
   * The file cannot be open and the link must be less than 1 to free.
   */                                                                 
                                                                      
  if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
  10fc77:	53                   	push   %ebx                           
  10fc78:	e8 23 79 ff ff       	call   1075a0 <rtems_libio_is_file_open>
  10fc7d:	83 c4 10             	add    $0x10,%esp                     
  10fc80:	85 c0                	test   %eax,%eax                      
  10fc82:	75 36                	jne    10fcba <memfile_check_rmnod+0x4d>
  10fc84:	66 83 7b 34 00       	cmpw   $0x0,0x34(%ebx)                
  10fc89:	75 2f                	jne    10fcba <memfile_check_rmnod+0x4d><== NEVER TAKEN
                                                                      
    /*                                                                
     * Is the rtems_filesystem_current is this node?                  
     */                                                               
                                                                      
    if ( rtems_filesystem_current.node_access == the_jnode )          
  10fc8b:	a1 cc f3 11 00       	mov    0x11f3cc,%eax                  
  10fc90:	39 58 04             	cmp    %ebx,0x4(%eax)                 
  10fc93:	75 07                	jne    10fc9c <memfile_check_rmnod+0x2f><== ALWAYS TAKEN
       rtems_filesystem_current.node_access = NULL;                   
  10fc95:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * Free memory associated with a memory file.                     
     */                                                               
    if (the_jnode->type != IMFS_LINEAR_FILE)                          
  10fc9c:	83 7b 4c 06          	cmpl   $0x6,0x4c(%ebx)                
  10fca0:	74 0c                	je     10fcae <memfile_check_rmnod+0x41><== NEVER TAKEN
      IMFS_memfile_remove( the_jnode );                               
  10fca2:	83 ec 0c             	sub    $0xc,%esp                      
  10fca5:	53                   	push   %ebx                           
  10fca6:	e8 7b fe ff ff       	call   10fb26 <IMFS_memfile_remove>   
  10fcab:	83 c4 10             	add    $0x10,%esp                     
                                                                      
    free( the_jnode );                                                
  10fcae:	83 ec 0c             	sub    $0xc,%esp                      
  10fcb1:	53                   	push   %ebx                           
  10fcb2:	e8 41 76 ff ff       	call   1072f8 <free>                  
  10fcb7:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  10fcba:	31 c0                	xor    %eax,%eax                      
  10fcbc:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10fcbf:	c9                   	leave                                 
  10fcc0:	c3                   	ret                                   
                                                                      

0010fabc <memfile_free_blocks_in_table>: void memfile_free_blocks_in_table( block_p **block_table, int entries ) {
  10fabc:	55                   	push   %ebp                           
  10fabd:	89 e5                	mov    %esp,%ebp                      
  10fabf:	57                   	push   %edi                           
  10fac0:	56                   	push   %esi                           
  10fac1:	53                   	push   %ebx                           
  10fac2:	83 ec 0c             	sub    $0xc,%esp                      
  10fac5:	8b 75 08             	mov    0x8(%ebp),%esi                 
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( block_table );                                              
  10fac8:	85 f6                	test   %esi,%esi                      
  10faca:	75 19                	jne    10fae5 <memfile_free_blocks_in_table+0x29><== ALWAYS TAKEN
  10facc:	68 36 b6 11 00       	push   $0x11b636                      <== NOT EXECUTED
  10fad1:	68 28 b7 11 00       	push   $0x11b728                      <== NOT EXECUTED
  10fad6:	68 b1 01 00 00       	push   $0x1b1                         <== NOT EXECUTED
  10fadb:	68 c6 b5 11 00       	push   $0x11b5c6                      <== NOT EXECUTED
  10fae0:	e8 bf 72 ff ff       	call   106da4 <__assert_func>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
                                                                      
  b = *block_table;                                                   
  10fae5:	8b 3e                	mov    (%esi),%edi                    
  10fae7:	31 db                	xor    %ebx,%ebx                      
  10fae9:	eb 1b                	jmp    10fb06 <memfile_free_blocks_in_table+0x4a>
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
    if ( b[i] ) {                                                     
  10faeb:	8b 04 9f             	mov    (%edi,%ebx,4),%eax             
  10faee:	85 c0                	test   %eax,%eax                      
  10faf0:	74 13                	je     10fb05 <memfile_free_blocks_in_table+0x49>
      memfile_free_block( b[i] );                                     
  10faf2:	83 ec 0c             	sub    $0xc,%esp                      
  10faf5:	50                   	push   %eax                           
  10faf6:	e8 d8 fd ff ff       	call   10f8d3 <memfile_free_block>    
      b[i] = 0;                                                       
  10fafb:	c7 04 9f 00 00 00 00 	movl   $0x0,(%edi,%ebx,4)             
  10fb02:	83 c4 10             	add    $0x10,%esp                     
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
                                                                      
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
  10fb05:	43                   	inc    %ebx                           
  10fb06:	3b 5d 0c             	cmp    0xc(%ebp),%ebx                 
  10fb09:	7c e0                	jl     10faeb <memfile_free_blocks_in_table+0x2f>
  /*                                                                  
   *  Now that all the blocks in the block table are free, we can     
   *  free the block table itself.                                    
   */                                                                 
                                                                      
  memfile_free_block( *block_table );                                 
  10fb0b:	83 ec 0c             	sub    $0xc,%esp                      
  10fb0e:	ff 36                	pushl  (%esi)                         
  10fb10:	e8 be fd ff ff       	call   10f8d3 <memfile_free_block>    
  *block_table = 0;                                                   
  10fb15:	c7 06 00 00 00 00    	movl   $0x0,(%esi)                    
  10fb1b:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  10fb1e:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10fb21:	5b                   	pop    %ebx                           
  10fb22:	5e                   	pop    %esi                           
  10fb23:	5f                   	pop    %edi                           
  10fb24:	c9                   	leave                                 
  10fb25:	c3                   	ret                                   
                                                                      

0010fe71 <memfile_ftruncate>: int memfile_ftruncate( rtems_libio_t *iop, off_t length ) {
  10fe71:	55                   	push   %ebp                           
  10fe72:	89 e5                	mov    %esp,%ebp                      
  10fe74:	53                   	push   %ebx                           
  10fe75:	83 ec 14             	sub    $0x14,%esp                     
  10fe78:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10fe7b:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->file_info;                                         
  10fe7e:	8b 5a 2c             	mov    0x2c(%edx),%ebx                
   *  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 )                           
  10fe81:	3b 43 50             	cmp    0x50(%ebx),%eax                
  10fe84:	7e 0b                	jle    10fe91 <memfile_ftruncate+0x20><== ALWAYS TAKEN
    return IMFS_memfile_extend( the_jnode, length );                  
  10fe86:	52                   	push   %edx                           <== NOT EXECUTED
  10fe87:	52                   	push   %edx                           <== NOT EXECUTED
  10fe88:	50                   	push   %eax                           <== NOT EXECUTED
  10fe89:	53                   	push   %ebx                           <== NOT EXECUTED
  10fe8a:	e8 0f ff ff ff       	call   10fd9e <IMFS_memfile_extend>   <== NOT EXECUTED
  10fe8f:	eb 1b                	jmp    10feac <memfile_ftruncate+0x3b><== NOT EXECUTED
   *  The in-memory files do not currently reclaim memory until the file is
   *  deleted.  So we leave the previously allocated blocks in place for
   *  future use and just set the length.                             
   */                                                                 
                                                                      
  the_jnode->info.file.size = length;                                 
  10fe91:	89 43 50             	mov    %eax,0x50(%ebx)                
  iop->size = the_jnode->info.file.size;                              
  10fe94:	89 42 04             	mov    %eax,0x4(%edx)                 
                                                                      
  IMFS_update_atime( the_jnode );                                     
  10fe97:	50                   	push   %eax                           
  10fe98:	50                   	push   %eax                           
  10fe99:	6a 00                	push   $0x0                           
  10fe9b:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10fe9e:	50                   	push   %eax                           
  10fe9f:	e8 c4 75 ff ff       	call   107468 <gettimeofday>          
  10fea4:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  10fea7:	89 43 40             	mov    %eax,0x40(%ebx)                
  10feaa:	31 c0                	xor    %eax,%eax                      
  10feac:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return 0;                                                           
}                                                                     
  10feaf:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10feb2:	c9                   	leave                                 
  10feb3:	c3                   	ret                                   
                                                                      

0010feb4 <memfile_lseek>: off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) {
  10feb4:	55                   	push   %ebp                           
  10feb5:	89 e5                	mov    %esp,%ebp                      
  10feb7:	56                   	push   %esi                           
  10feb8:	53                   	push   %ebx                           
  10feb9:	8b 75 08             	mov    0x8(%ebp),%esi                 
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->file_info;                                         
  10febc:	8b 5e 2c             	mov    0x2c(%esi),%ebx                
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
  10febf:	83 7b 4c 06          	cmpl   $0x6,0x4c(%ebx)                
  10fec3:	75 0d                	jne    10fed2 <memfile_lseek+0x1e>    <== ALWAYS TAKEN
    if (iop->offset > the_jnode->info.linearfile.size)                
  10fec5:	8b 43 50             	mov    0x50(%ebx),%eax                <== NOT EXECUTED
  10fec8:	39 46 08             	cmp    %eax,0x8(%esi)                 <== NOT EXECUTED
  10fecb:	7e 2d                	jle    10fefa <memfile_lseek+0x46>    <== NOT EXECUTED
      iop->offset = the_jnode->info.linearfile.size;                  
  10fecd:	89 46 08             	mov    %eax,0x8(%esi)                 <== NOT EXECUTED
  10fed0:	eb 28                	jmp    10fefa <memfile_lseek+0x46>    <== NOT EXECUTED
  }                                                                   
  else {  /* Must be a block file (IMFS_MEMORY_FILE). */              
    if (IMFS_memfile_extend( the_jnode, iop->offset ))                
  10fed2:	51                   	push   %ecx                           
  10fed3:	51                   	push   %ecx                           
  10fed4:	ff 76 08             	pushl  0x8(%esi)                      
  10fed7:	53                   	push   %ebx                           
  10fed8:	e8 c1 fe ff ff       	call   10fd9e <IMFS_memfile_extend>   
  10fedd:	83 c4 10             	add    $0x10,%esp                     
  10fee0:	85 c0                	test   %eax,%eax                      
  10fee2:	74 10                	je     10fef4 <memfile_lseek+0x40>    <== ALWAYS TAKEN
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
  10fee4:	e8 f7 10 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  10fee9:	c7 00 1c 00 00 00    	movl   $0x1c,(%eax)                   <== NOT EXECUTED
  10feef:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10fef2:	eb 09                	jmp    10fefd <memfile_lseek+0x49>    <== NOT EXECUTED
                                                                      
    iop->size = the_jnode->info.file.size;                            
  10fef4:	8b 43 50             	mov    0x50(%ebx),%eax                
  10fef7:	89 46 04             	mov    %eax,0x4(%esi)                 
  }                                                                   
  return iop->offset;                                                 
  10fefa:	8b 46 08             	mov    0x8(%esi),%eax                 
}                                                                     
  10fefd:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10ff00:	5b                   	pop    %ebx                           
  10ff01:	5e                   	pop    %esi                           
  10ff02:	c9                   	leave                                 
  10ff03:	c3                   	ret                                   
                                                                      

001100fb <memfile_open>: rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) {
  1100fb:	55                   	push   %ebp                           
  1100fc:	89 e5                	mov    %esp,%ebp                      
  1100fe:	56                   	push   %esi                           
  1100ff:	53                   	push   %ebx                           
  110100:	8b 75 08             	mov    0x8(%ebp),%esi                 
  IMFS_jnode_t  *the_jnode;                                           
                                                                      
  the_jnode = iop->file_info;                                         
  110103:	8b 5e 2c             	mov    0x2c(%esi),%ebx                
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
  110106:	f7 46 0c 04 02 00 00 	testl  $0x204,0xc(%esi)               
  11010d:	74 46                	je     110155 <memfile_open+0x5a>     
  11010f:	83 7b 4c 06          	cmpl   $0x6,0x4c(%ebx)                
  110113:	75 40                	jne    110155 <memfile_open+0x5a>     <== ALWAYS TAKEN
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
    uint32_t   count = the_jnode->info.linearfile.size;               
  110115:	8b 43 50             	mov    0x50(%ebx),%eax                <== NOT EXECUTED
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
  110118:	8b 53 54             	mov    0x54(%ebx),%edx                <== NOT EXECUTED
                                                                      
    the_jnode->type = IMFS_MEMORY_FILE;                               
  11011b:	c7 43 4c 05 00 00 00 	movl   $0x5,0x4c(%ebx)                <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
  110122:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)                <== NOT EXECUTED
    the_jnode->info.file.indirect        = 0;                         
  110129:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                <== NOT EXECUTED
    the_jnode->info.file.doubly_indirect = 0;                         
  110130:	c7 43 58 00 00 00 00 	movl   $0x0,0x58(%ebx)                <== NOT EXECUTED
    the_jnode->info.file.triply_indirect = 0;                         
  110137:	c7 43 5c 00 00 00 00 	movl   $0x0,0x5c(%ebx)                <== NOT EXECUTED
    if ((count != 0)                                                  
  11013e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  110140:	74 13                	je     110155 <memfile_open+0x5a>     <== NOT EXECUTED
  110142:	50                   	push   %eax                           <== NOT EXECUTED
  110143:	52                   	push   %edx                           <== NOT EXECUTED
  110144:	6a 00                	push   $0x0                           <== NOT EXECUTED
  110146:	53                   	push   %ebx                           <== NOT EXECUTED
  110147:	e8 b8 fd ff ff       	call   10ff04 <IMFS_memfile_write>    <== NOT EXECUTED
  11014c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  11014f:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  110152:	40                   	inc    %eax                           <== NOT EXECUTED
  110153:	74 14                	je     110169 <memfile_open+0x6e>     <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
        return -1;                                                    
  }                                                                   
  if (iop->flags & LIBIO_FLAGS_APPEND)                                
  110155:	f6 46 0d 02          	testb  $0x2,0xd(%esi)                 
  110159:	74 06                	je     110161 <memfile_open+0x66>     
    iop->offset = the_jnode->info.file.size;                          
  11015b:	8b 43 50             	mov    0x50(%ebx),%eax                
  11015e:	89 46 08             	mov    %eax,0x8(%esi)                 
                                                                      
  iop->size = the_jnode->info.file.size;                              
  110161:	8b 43 50             	mov    0x50(%ebx),%eax                
  110164:	89 46 04             	mov    %eax,0x4(%esi)                 
  110167:	31 d2                	xor    %edx,%edx                      
  return 0;                                                           
}                                                                     
  110169:	89 d0                	mov    %edx,%eax                      
  11016b:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  11016e:	5b                   	pop    %ebx                           
  11016f:	5e                   	pop    %esi                           
  110170:	c9                   	leave                                 
  110171:	c3                   	ret                                   
                                                                      

0010fcc1 <memfile_rmnod>: */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) {
  10fcc1:	55                   	push   %ebp                           
  10fcc2:	89 e5                	mov    %esp,%ebp                      
  10fcc4:	53                   	push   %ebx                           
  10fcc5:	83 ec 14             	sub    $0x14,%esp                     
  IMFS_jnode_t *the_jnode;                                            
                                                                      
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;                  
  10fcc8:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10fccb:	8b 18                	mov    (%eax),%ebx                    
                                                                      
  /*                                                                  
   * Take the node out of the parent's chain that contains this node  
   */                                                                 
                                                                      
  if ( the_jnode->Parent != NULL ) {                                  
  10fccd:	83 7b 08 00          	cmpl   $0x0,0x8(%ebx)                 
  10fcd1:	74 13                	je     10fce6 <memfile_rmnod+0x25>    <== NEVER TAKEN
  10fcd3:	83 ec 0c             	sub    $0xc,%esp                      
  10fcd6:	53                   	push   %ebx                           
  10fcd7:	e8 58 f3 ff ff       	call   10f034 <_Chain_Extract>        
    rtems_chain_extract( (rtems_chain_node *) the_jnode );            
    the_jnode->Parent = NULL;                                         
  10fcdc:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)                 
  10fce3:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   * Decrement the link counter and see if we can free the space.     
   */                                                                 
                                                                      
  the_jnode->st_nlink--;                                              
  10fce6:	66 ff 4b 34          	decw   0x34(%ebx)                     
  IMFS_update_ctime( the_jnode );                                     
  10fcea:	50                   	push   %eax                           
  10fceb:	50                   	push   %eax                           
  10fcec:	6a 00                	push   $0x0                           
  10fcee:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10fcf1:	50                   	push   %eax                           
  10fcf2:	e8 71 77 ff ff       	call   107468 <gettimeofday>          
  10fcf7:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  10fcfa:	89 43 48             	mov    %eax,0x48(%ebx)                
                                                                      
  return memfile_check_rmnod( the_jnode );                            
  10fcfd:	89 1c 24             	mov    %ebx,(%esp)                    
  10fd00:	e8 68 ff ff ff       	call   10fc6d <memfile_check_rmnod>   
}                                                                     
  10fd05:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10fd08:	c9                   	leave                                 
  10fd09:	c3                   	ret                                   
                                                                      

0010670c <mknod>: int mknod( const char *pathname, mode_t mode, dev_t dev ) {
  10670c:	55                   	push   %ebp                           
  10670d:	89 e5                	mov    %esp,%ebp                      
  10670f:	57                   	push   %edi                           
  106710:	56                   	push   %esi                           
  106711:	53                   	push   %ebx                           
  106712:	83 ec 2c             	sub    $0x2c,%esp                     
  106715:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  106718:	8b 45 10             	mov    0x10(%ebp),%eax                
  10671b:	8b 55 14             	mov    0x14(%ebp),%edx                
  10671e:	89 45 c8             	mov    %eax,-0x38(%ebp)               
  106721:	89 55 cc             	mov    %edx,-0x34(%ebp)               
  int                                 result;                         
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & S_IFMT) {                                            
  106724:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  106727:	25 00 f0 00 00       	and    $0xf000,%eax                   
  10672c:	3d 00 40 00 00       	cmp    $0x4000,%eax                   
  106731:	74 2b                	je     10675e <mknod+0x52>            
  106733:	77 0e                	ja     106743 <mknod+0x37>            
  106735:	3d 00 10 00 00       	cmp    $0x1000,%eax                   
  10673a:	74 29                	je     106765 <mknod+0x59>            
  10673c:	3d 00 20 00 00       	cmp    $0x2000,%eax                   
  106741:	eb 0c                	jmp    10674f <mknod+0x43>            
  106743:	3d 00 60 00 00       	cmp    $0x6000,%eax                   
  106748:	74 14                	je     10675e <mknod+0x52>            <== NEVER TAKEN
  10674a:	3d 00 80 00 00       	cmp    $0x8000,%eax                   
  10674f:	74 0d                	je     10675e <mknod+0x52>            <== ALWAYS TAKEN
    case S_IFBLK:                                                     
    case S_IFREG:                                                     
    case S_IFIFO:                                                     
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  106751:	e8 d2 89 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  106756:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  10675c:	eb 12                	jmp    106770 <mknod+0x64>            <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( S_ISFIFO(mode) )                                               
  10675e:	3d 00 10 00 00       	cmp    $0x1000,%eax                   
  106763:	75 13                	jne    106778 <mknod+0x6c>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  106765:	e8 be 89 00 00       	call   10f128 <__errno>               
  10676a:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   
  106770:	83 ce ff             	or     $0xffffffff,%esi               
  106773:	e9 a6 00 00 00       	jmp    10681e <mknod+0x112>           
                                                                      
  rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );          
  106778:	8a 03                	mov    (%ebx),%al                     
  10677a:	3c 2f                	cmp    $0x2f,%al                      
  10677c:	74 08                	je     106786 <mknod+0x7a>            
  10677e:	3c 5c                	cmp    $0x5c,%al                      
  106780:	74 04                	je     106786 <mknod+0x7a>            <== NEVER TAKEN
  106782:	84 c0                	test   %al,%al                        
  106784:	75 16                	jne    10679c <mknod+0x90>            <== ALWAYS TAKEN
  106786:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  106789:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10678e:	8d 70 14             	lea    0x14(%eax),%esi                
  106791:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  106796:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  106798:	b1 01                	mov    $0x1,%cl                       
  10679a:	eb 12                	jmp    1067ae <mknod+0xa2>            
  10679c:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  10679f:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  1067a4:	8d 70 04             	lea    0x4(%eax),%esi                 
  1067a7:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  1067ac:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  if ( !temp_loc.ops->evalformake_h ) {                               
  1067ae:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  1067b1:	8b 50 04             	mov    0x4(%eax),%edx                 
  1067b4:	85 d2                	test   %edx,%edx                      
  1067b6:	74 ad                	je     106765 <mknod+0x59>            <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*temp_loc.ops->evalformake_h)(                            
  1067b8:	50                   	push   %eax                           
  1067b9:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  1067bc:	50                   	push   %eax                           
  1067bd:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  1067c0:	57                   	push   %edi                           
  1067c1:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax             
  1067c4:	50                   	push   %eax                           
  1067c5:	ff d2                	call   *%edx                          
    &pathname[i],                                                     
    &temp_loc,                                                        
    &name_start                                                       
  );                                                                  
  if ( result != 0 )                                                  
  1067c7:	83 c4 10             	add    $0x10,%esp                     
  1067ca:	83 ce ff             	or     $0xffffffff,%esi               
  1067cd:	85 c0                	test   %eax,%eax                      
  1067cf:	75 4d                	jne    10681e <mknod+0x112>           
    return -1;                                                        
                                                                      
  if ( !temp_loc.ops->mknod_h ) {                                     
  1067d1:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  1067d4:	8b 50 14             	mov    0x14(%eax),%edx                
  1067d7:	85 d2                	test   %edx,%edx                      
  1067d9:	75 15                	jne    1067f0 <mknod+0xe4>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &temp_loc );                           
  1067db:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  1067de:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1067e0:	74 83                	je     106765 <mknod+0x59>            <== NOT EXECUTED
  1067e2:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1067e5:	57                   	push   %edi                           <== NOT EXECUTED
  1067e6:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1067e8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1067eb:	e9 75 ff ff ff       	jmp    106765 <mknod+0x59>            <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result =  (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
  1067f0:	83 ec 0c             	sub    $0xc,%esp                      
  1067f3:	57                   	push   %edi                           
  1067f4:	ff 75 cc             	pushl  -0x34(%ebp)                    
  1067f7:	ff 75 c8             	pushl  -0x38(%ebp)                    
  1067fa:	ff 75 0c             	pushl  0xc(%ebp)                      
  1067fd:	ff 75 ec             	pushl  -0x14(%ebp)                    
  106800:	ff d2                	call   *%edx                          
  106802:	89 c6                	mov    %eax,%esi                      
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
  106804:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  106807:	83 c4 20             	add    $0x20,%esp                     
  10680a:	85 c0                	test   %eax,%eax                      
  10680c:	74 10                	je     10681e <mknod+0x112>           <== NEVER TAKEN
  10680e:	8b 40 1c             	mov    0x1c(%eax),%eax                
  106811:	85 c0                	test   %eax,%eax                      
  106813:	74 09                	je     10681e <mknod+0x112>           
  106815:	83 ec 0c             	sub    $0xc,%esp                      
  106818:	57                   	push   %edi                           
  106819:	ff d0                	call   *%eax                          
  10681b:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  10681e:	89 f0                	mov    %esi,%eax                      
  106820:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106823:	5b                   	pop    %ebx                           
  106824:	5e                   	pop    %esi                           
  106825:	5f                   	pop    %edi                           
  106826:	c9                   	leave                                 
  106827:	c3                   	ret                                   
                                                                      

0010d119 <mount>: const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) {
  10d119:	55                   	push   %ebp                           
  10d11a:	89 e5                	mov    %esp,%ebp                      
  10d11c:	57                   	push   %edi                           
  10d11d:	56                   	push   %esi                           
  10d11e:	53                   	push   %ebx                           
  10d11f:	83 ec 1c             	sub    $0x1c,%esp                     
  10d122:	8b 75 10             	mov    0x10(%ebp),%esi                
                                                                      
  /*                                                                  
   *  Is there a file system operations table?                        
   */                                                                 
                                                                      
  if ( fs_ops == NULL ) {                                             
  10d125:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  10d129:	74 05                	je     10d130 <mount+0x17>            
                                                                      
  /*                                                                  
   *  Are the file system options valid?                              
   */                                                                 
                                                                      
  if ( options != RTEMS_FILESYSTEM_READ_ONLY &&                       
  10d12b:	83 fe 01             	cmp    $0x1,%esi                      
  10d12e:	76 10                	jbe    10d140 <mount+0x27>            
       options != RTEMS_FILESYSTEM_READ_WRITE ) {                     
    errno = EINVAL;                                                   
  10d130:	e8 f3 1f 00 00       	call   10f128 <__errno>               
  10d135:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10d13b:	e9 e4 01 00 00       	jmp    10d324 <mount+0x20b>           
    return -1;                                                        
  }                                                                   
                                                                      
  /* Do they support being mounted at all ? */                        
  if ( !fs_ops->fsmount_me_h ) {                                      
  10d140:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10d143:	83 78 24 00          	cmpl   $0x0,0x24(%eax)                
  10d147:	75 17                	jne    10d160 <mount+0x47>            <== ALWAYS TAKEN
    errno = ENOTSUP;                                                  
  10d149:	e8 da 1f 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10d14e:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10d154:	c7 45 e0 00 00 00 00 	movl   $0x0,-0x20(%ebp)               <== NOT EXECUTED
  10d15b:	e9 94 01 00 00       	jmp    10d2f4 <mount+0x1db>           <== NOT EXECUTED
  /*                                                                  
   * Allocate a mount table entry                                     
   */                                                                 
                                                                      
   size = sizeof(rtems_filesystem_mount_table_entry_t);               
   if ( device )                                                      
  10d160:	b8 64 00 00 00       	mov    $0x64,%eax                     
  10d165:	83 7d 14 00          	cmpl   $0x0,0x14(%ebp)                
  10d169:	74 0f                	je     10d17a <mount+0x61>            <== ALWAYS TAKEN
     size += strlen( device ) + 1;                                    
  10d16b:	31 c0                	xor    %eax,%eax                      
  10d16d:	83 c9 ff             	or     $0xffffffff,%ecx               <== NOT EXECUTED
  10d170:	8b 7d 14             	mov    0x14(%ebp),%edi                <== NOT EXECUTED
  10d173:	f2 ae                	repnz scas %es:(%edi),%al             <== NOT EXECUTED
  10d175:	f7 d1                	not    %ecx                           <== NOT EXECUTED
  10d177:	8d 41 64             	lea    0x64(%ecx),%eax                <== NOT EXECUTED
   temp_mt_entry = malloc( size );                                    
  10d17a:	83 ec 0c             	sub    $0xc,%esp                      
  10d17d:	50                   	push   %eax                           
  10d17e:	e8 f1 94 ff ff       	call   106674 <malloc>                
  10d183:	89 c3                	mov    %eax,%ebx                      
  10d185:	89 45 e0             	mov    %eax,-0x20(%ebp)               
                                                                      
   if ( !temp_mt_entry ) {                                            
  10d188:	83 c4 10             	add    $0x10,%esp                     
  10d18b:	85 c0                	test   %eax,%eax                      
  10d18d:	75 10                	jne    10d19f <mount+0x86>            <== ALWAYS TAKEN
     errno = ENOMEM;                                                  
  10d18f:	e8 94 1f 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10d194:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)                    <== NOT EXECUTED
  10d19a:	e9 85 01 00 00       	jmp    10d324 <mount+0x20b>           <== NOT EXECUTED
     return -1;                                                       
   }                                                                  
                                                                      
   temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry;                
  10d19f:	89 43 24             	mov    %eax,0x24(%ebx)                
   temp_mt_entry->options = options;                                  
  10d1a2:	89 70 28             	mov    %esi,0x28(%eax)                
   if ( device ) {                                                    
  10d1a5:	83 7d 14 00          	cmpl   $0x0,0x14(%ebp)                
  10d1a9:	74 16                	je     10d1c1 <mount+0xa8>            <== ALWAYS TAKEN
     temp_mt_entry->dev =                                             
  10d1ab:	8d 40 64             	lea    0x64(%eax),%eax                <== NOT EXECUTED
  10d1ae:	89 43 60             	mov    %eax,0x60(%ebx)                <== NOT EXECUTED
       (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t );
     strcpy( temp_mt_entry->dev, device );                            
  10d1b1:	52                   	push   %edx                           <== NOT EXECUTED
  10d1b2:	52                   	push   %edx                           <== NOT EXECUTED
  10d1b3:	ff 75 14             	pushl  0x14(%ebp)                     <== NOT EXECUTED
  10d1b6:	50                   	push   %eax                           <== NOT EXECUTED
  10d1b7:	e8 cc 30 00 00       	call   110288 <strcpy>                <== NOT EXECUTED
  10d1bc:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10d1bf:	eb 07                	jmp    10d1c8 <mount+0xaf>            <== NOT EXECUTED
   } else                                                             
     temp_mt_entry->dev = 0;                                          
  10d1c1:	c7 40 60 00 00 00 00 	movl   $0x0,0x60(%eax)                
  /*                                                                  
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( mount_point ) {                                                
  10d1c8:	83 7d 18 00          	cmpl   $0x0,0x18(%ebp)                
  10d1cc:	0f 84 a8 00 00 00    	je     10d27a <mount+0x161>           
                                                                      
    if ( rtems_filesystem_evaluate_path(                              
  10d1d2:	6a 01                	push   $0x1                           
  10d1d4:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  10d1d7:	56                   	push   %esi                           
  10d1d8:	6a 07                	push   $0x7                           
  10d1da:	ff 75 18             	pushl  0x18(%ebp)                     
  10d1dd:	e8 74 91 ff ff       	call   106356 <rtems_filesystem_evaluate_path>
  10d1e2:	83 c4 10             	add    $0x10,%esp                     
  10d1e5:	40                   	inc    %eax                           
  10d1e6:	0f 84 08 01 00 00    	je     10d2f4 <mount+0x1db>           <== NEVER TAKEN
                                                                      
    /*                                                                
     * Test for node_type_h                                           
     */                                                               
                                                                      
    if (!loc.ops->node_type_h) {                                      
  10d1ec:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10d1ef:	8b 40 10             	mov    0x10(%eax),%eax                
  10d1f2:	85 c0                	test   %eax,%eax                      
  10d1f4:	75 10                	jne    10d206 <mount+0xed>            <== ALWAYS TAKEN
      errno =  ENOTSUP;                                               
  10d1f6:	e8 2d 1f 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10d1fb:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10d201:	e9 f0 00 00 00       	jmp    10d2f6 <mount+0x1dd>           <== NOT EXECUTED
                                                                      
    /*                                                                
     *  Test to see if it is a directory                              
     */                                                               
                                                                      
    if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
  10d206:	83 ec 0c             	sub    $0xc,%esp                      
  10d209:	56                   	push   %esi                           
  10d20a:	ff d0                	call   *%eax                          
  10d20c:	83 c4 10             	add    $0x10,%esp                     
  10d20f:	48                   	dec    %eax                           
  10d210:	74 10                	je     10d222 <mount+0x109>           
      errno = ENOTDIR;                                                
  10d212:	e8 11 1f 00 00       	call   10f128 <__errno>               
  10d217:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   
  10d21d:	e9 d4 00 00 00       	jmp    10d2f6 <mount+0x1dd>           
                                                                      
  /*                                                                  
   * For each mount table entry                                       
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
  10d222:	a1 30 dd 11 00       	mov    0x11dd30,%eax                  
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
        the_node = the_node->next ) {                                 
     the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node;
     if ( the_mount_entry->mt_fs_root.node_access  == loc->node_access )
  10d227:	8b 55 e4             	mov    -0x1c(%ebp),%edx               
  10d22a:	eb 07                	jmp    10d233 <mount+0x11a>           
  10d22c:	39 50 18             	cmp    %edx,0x18(%eax)                
  10d22f:	74 0e                	je     10d23f <mount+0x126>           
   * For each mount table entry                                       
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
        the_node = the_node->next ) {                                 
  10d231:	8b 00                	mov    (%eax),%eax                    
  /*                                                                  
   * For each mount table entry                                       
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
  10d233:	3d 34 dd 11 00       	cmp    $0x11dd34,%eax                 
  10d238:	75 f2                	jne    10d22c <mount+0x113>           
  10d23a:	e9 f0 00 00 00       	jmp    10d32f <mount+0x216>           
    /*                                                                
     *  You can only mount one file system onto a single mount point. 
     */                                                               
                                                                      
    if ( Is_node_fs_root(  &loc ) ){                                  
      errno = EBUSY;                                                  
  10d23f:	e8 e4 1e 00 00       	call   10f128 <__errno>               
  10d244:	c7 00 10 00 00 00    	movl   $0x10,(%eax)                   
  10d24a:	eb 0b                	jmp    10d257 <mount+0x13e>           
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( !loc.ops->mount_h ){                                         
      errno = ENOTSUP;                                                
  10d24c:	e8 d7 1e 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10d251:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10d257:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  10d25a:	e9 97 00 00 00       	jmp    10d2f6 <mount+0x1dd>           
      goto cleanup_and_bail;                                          
    }                                                                 
                                                                      
    if ( loc.ops->mount_h( temp_mt_entry ) ) {                        
  10d25f:	83 ec 0c             	sub    $0xc,%esp                      
  10d262:	53                   	push   %ebx                           
  10d263:	ff d0                	call   *%eax                          
  10d265:	83 c4 10             	add    $0x10,%esp                     
  10d268:	85 c0                	test   %eax,%eax                      
  10d26a:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  10d26d:	74 07                	je     10d276 <mount+0x15d>           <== ALWAYS TAKEN
  10d26f:	89 c6                	mov    %eax,%esi                      <== NOT EXECUTED
  10d271:	e9 80 00 00 00       	jmp    10d2f6 <mount+0x1dd>           <== NOT EXECUTED
  10d276:	89 c6                	mov    %eax,%esi                      
  10d278:	eb 33                	jmp    10d2ad <mount+0x194>           
     *  This is a mount of the base file system --> The               
     *  mt_point_node.node_access will be set to null to indicate that this
     *  is the root of the entire file system.                        
     */                                                               
                                                                      
    temp_mt_entry->mt_fs_root.node_access = NULL;                     
  10d27a:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
    temp_mt_entry->mt_fs_root.handlers = NULL;                        
  10d281:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)                
    temp_mt_entry->mt_fs_root.ops = NULL;                             
  10d288:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)                
                                                                      
    temp_mt_entry->mt_point_node.node_access = NULL;                  
  10d28f:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)                 
    temp_mt_entry->mt_point_node.handlers = NULL;                     
  10d296:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
    temp_mt_entry->mt_point_node.ops = NULL;                          
  10d29d:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%ebx)                
    temp_mt_entry->mt_point_node.mt_entry = NULL;                     
  10d2a4:	c7 43 14 00 00 00 00 	movl   $0x0,0x14(%ebx)                
  10d2ab:	31 f6                	xor    %esi,%esi                      
  }                                                                   
                                                                      
  if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) {                      
  10d2ad:	83 ec 0c             	sub    $0xc,%esp                      
  10d2b0:	53                   	push   %ebx                           
  10d2b1:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10d2b4:	ff 52 24             	call   *0x24(%edx)                    
  10d2b7:	83 c4 10             	add    $0x10,%esp                     
  10d2ba:	85 c0                	test   %eax,%eax                      
  10d2bc:	74 15                	je     10d2d3 <mount+0x1ba>           <== ALWAYS TAKEN
	/* try to undo the mount operation */                                
	if ( loc.ops->unmount_h ) {                                          
  10d2be:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  10d2c1:	8b 40 28             	mov    0x28(%eax),%eax                <== NOT EXECUTED
  10d2c4:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10d2c6:	74 2e                	je     10d2f6 <mount+0x1dd>           <== NOT EXECUTED
		loc.ops->unmount_h( temp_mt_entry );                                
  10d2c8:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10d2cb:	53                   	push   %ebx                           <== NOT EXECUTED
  10d2cc:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10d2ce:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10d2d1:	eb 23                	jmp    10d2f6 <mount+0x1dd>           <== NOT EXECUTED
  10d2d3:	50                   	push   %eax                           
  10d2d4:	50                   	push   %eax                           
  10d2d5:	53                   	push   %ebx                           
  10d2d6:	68 30 dd 11 00       	push   $0x11dd30                      
  10d2db:	e8 0c c8 ff ff       	call   109aec <_Chain_Append>         
   */                                                                 
                                                                      
  rtems_chain_append( &rtems_filesystem_mount_table_control,          
                      &temp_mt_entry->Node );                         
                                                                      
  if ( mt_entry )                                                     
  10d2e0:	83 c4 10             	add    $0x10,%esp                     
  10d2e3:	31 c0                	xor    %eax,%eax                      
  10d2e5:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  10d2e9:	74 3c                	je     10d327 <mount+0x20e>           <== NEVER TAKEN
    *mt_entry = temp_mt_entry;                                        
  10d2eb:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  10d2ee:	89 1f                	mov    %ebx,(%edi)                    
  10d2f0:	31 c0                	xor    %eax,%eax                      
  10d2f2:	eb 33                	jmp    10d327 <mount+0x20e>           
  10d2f4:	31 f6                	xor    %esi,%esi                      
                                                                      
  return 0;                                                           
                                                                      
cleanup_and_bail:                                                     
                                                                      
  free( temp_mt_entry );                                              
  10d2f6:	83 ec 0c             	sub    $0xc,%esp                      
  10d2f9:	ff 75 e0             	pushl  -0x20(%ebp)                    
  10d2fc:	e8 77 91 ff ff       	call   106478 <free>                  
                                                                      
  if ( loc_to_free )                                                  
  10d301:	83 c4 10             	add    $0x10,%esp                     
  10d304:	85 f6                	test   %esi,%esi                      
  10d306:	74 1c                	je     10d324 <mount+0x20b>           <== NEVER TAKEN
    rtems_filesystem_freenode( loc_to_free );                         
  10d308:	8b 46 08             	mov    0x8(%esi),%eax                 
  10d30b:	85 c0                	test   %eax,%eax                      
  10d30d:	74 15                	je     10d324 <mount+0x20b>           <== NEVER TAKEN
  10d30f:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10d312:	85 c0                	test   %eax,%eax                      
  10d314:	74 0e                	je     10d324 <mount+0x20b>           <== NEVER TAKEN
  10d316:	83 ec 0c             	sub    $0xc,%esp                      
  10d319:	56                   	push   %esi                           
  10d31a:	ff d0                	call   *%eax                          
  10d31c:	83 c8 ff             	or     $0xffffffff,%eax               
  10d31f:	83 c4 10             	add    $0x10,%esp                     
  10d322:	eb 03                	jmp    10d327 <mount+0x20e>           
  10d324:	83 c8 ff             	or     $0xffffffff,%eax               
                                                                      
  return -1;                                                          
}                                                                     
  10d327:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10d32a:	5b                   	pop    %ebx                           
  10d32b:	5e                   	pop    %esi                           
  10d32c:	5f                   	pop    %edi                           
  10d32d:	c9                   	leave                                 
  10d32e:	c3                   	ret                                   
     *  may have been allocated in loc should not be sent to freenode 
     *  until the system is unmounted.  It may be needed to correctly 
     *  traverse the tree.                                            
     */                                                               
                                                                      
    temp_mt_entry->mt_point_node.node_access = loc.node_access;       
  10d32f:	89 53 08             	mov    %edx,0x8(%ebx)                 
    temp_mt_entry->mt_point_node.handlers = loc.handlers;             
  10d332:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10d335:	89 43 0c             	mov    %eax,0xc(%ebx)                 
    temp_mt_entry->mt_point_node.ops = loc.ops;                       
  10d338:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  10d33b:	89 53 10             	mov    %edx,0x10(%ebx)                
    temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;             
  10d33e:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10d341:	89 43 14             	mov    %eax,0x14(%ebx)                
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( !loc.ops->mount_h ){                                         
  10d344:	8b 42 20             	mov    0x20(%edx),%eax                
  10d347:	85 c0                	test   %eax,%eax                      
  10d349:	0f 85 10 ff ff ff    	jne    10d25f <mount+0x146>           <== ALWAYS TAKEN
  10d34f:	e9 f8 fe ff ff       	jmp    10d24c <mount+0x133>           <== NOT EXECUTED
                                                                      

0010cb00 <mq_unlink>: */ int mq_unlink( const char *name ) {
  10cb00:	55                   	push   %ebp                           
  10cb01:	89 e5                	mov    %esp,%ebp                      
  10cb03:	53                   	push   %ebx                           
  10cb04:	83 ec 1c             	sub    $0x1c,%esp                     
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10cb07:	a1 58 63 12 00       	mov    0x126358,%eax                  
  10cb0c:	40                   	inc    %eax                           
  10cb0d:	a3 58 63 12 00       	mov    %eax,0x126358                  
  register POSIX_Message_queue_Control *the_mq;                       
  Objects_Id                            the_mq_id;                    
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );       
  10cb12:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  10cb15:	50                   	push   %eax                           
  10cb16:	ff 75 08             	pushl  0x8(%ebp)                      
  10cb19:	e8 32 5a 00 00       	call   112550 <_POSIX_Message_queue_Name_to_id>
  10cb1e:	89 c3                	mov    %eax,%ebx                      
   if ( status != 0 ) {                                               
  10cb20:	83 c4 10             	add    $0x10,%esp                     
  10cb23:	85 c0                	test   %eax,%eax                      
  10cb25:	74 11                	je     10cb38 <mq_unlink+0x38>        
    _Thread_Enable_dispatch();                                        
  10cb27:	e8 08 32 00 00       	call   10fd34 <_Thread_Enable_dispatch>
    rtems_set_errno_and_return_minus_one( status );                   
  10cb2c:	e8 db 78 00 00       	call   11440c <__errno>               
  10cb31:	89 18                	mov    %ebx,(%eax)                    
  10cb33:	83 c8 ff             	or     $0xffffffff,%eax               
  10cb36:	eb 3c                	jmp    10cb74 <mq_unlink+0x74>        
   }                                                                  
                                                                      
  the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object( 
  10cb38:	8b 45 f8             	mov    -0x8(%ebp),%eax                
bool _Protected_heap_Get_information(                                 
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
);                                                                    
                                                                      
/**                                                                   
  10cb3b:	31 db                	xor    %ebx,%ebx                      
  10cb3d:	66 3b 05 d8 66 12 00 	cmp    0x1266d8,%ax                   
  10cb44:	77 0b                	ja     10cb51 <mq_unlink+0x51>        <== NEVER TAKEN
 *  This heap routine returns information about the free blocks       
 *  in the specified heap.                                            
  10cb46:	0f b7 d0             	movzwl %ax,%edx                       
  10cb49:	a1 e4 66 12 00       	mov    0x1266e4,%eax                  
  10cb4e:	8b 1c 90             	mov    (%eax,%edx,4),%ebx             
    &_POSIX_Message_queue_Information,                                
    _Objects_Get_index( the_mq_id )                                   
  );                                                                  
                                                                      
  the_mq->linked = FALSE;                                             
  10cb51:	c6 43 15 00          	movb   $0x0,0x15(%ebx)                
                                                                      
/**                                                                   
 *  This function attempts to allocate a block of @a size bytes from  
 *  @a the_heap.  If insufficient memory is free in @a the_heap to allocate
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
  10cb55:	50                   	push   %eax                           
  10cb56:	50                   	push   %eax                           
  10cb57:	53                   	push   %ebx                           
  10cb58:	68 c8 66 12 00       	push   $0x1266c8                      
  10cb5d:	e8 da 2a 00 00       	call   10f63c <_Objects_Namespace_remove>
  _POSIX_Message_queue_Namespace_remove( the_mq );                    
  _POSIX_Message_queue_Delete( the_mq );                              
  10cb62:	89 1c 24             	mov    %ebx,(%esp)                    
  10cb65:	e8 92 f9 ff ff       	call   10c4fc <_POSIX_Message_queue_Delete>
                                                                      
  _Thread_Enable_dispatch();                                          
  10cb6a:	e8 c5 31 00 00       	call   10fd34 <_Thread_Enable_dispatch>
  10cb6f:	31 c0                	xor    %eax,%eax                      
  10cb71:	83 c4 10             	add    $0x10,%esp                     
  return 0;                                                           
}                                                                     
  10cb74:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10cb77:	c9                   	leave                                 
  10cb78:	c3                   	ret                                   
                                                                      

0010d834 <nanosleep>: int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) {
  10d834:	55                   	push   %ebp                           
  10d835:	89 e5                	mov    %esp,%ebp                      
  10d837:	56                   	push   %esi                           
  10d838:	53                   	push   %ebx                           
  10d839:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10d83c:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Watchdog_Interval  ticks;                                           
                                                                      
  if ( !_Timespec_Is_valid( rqtp ) )                                  
  10d83f:	83 ec 0c             	sub    $0xc,%esp                      
  10d842:	53                   	push   %ebx                           
  10d843:	e8 a8 11 00 00       	call   10e9f0 <_Timespec_Is_valid>    
  10d848:	83 c4 10             	add    $0x10,%esp                     
  10d84b:	84 c0                	test   %al,%al                        
  10d84d:	74 0b                	je     10d85a <nanosleep+0x26>        
   *  Return EINVAL if the delay interval is negative.                
   *                                                                  
   *  NOTE:  This behavior is beyond the POSIX specification.         
   *         FSU and GNU/Linux pthreads shares this behavior.         
   */                                                                 
  if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 )                        
  10d84f:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10d852:	78 06                	js     10d85a <nanosleep+0x26>        <== NEVER TAKEN
  10d854:	83 7b 04 00          	cmpl   $0x0,0x4(%ebx)                 
  10d858:	79 10                	jns    10d86a <nanosleep+0x36>        <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10d85a:	e8 0d 1e 00 00       	call   10f66c <__errno>               
  10d85f:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10d865:	e9 c3 00 00 00       	jmp    10d92d <nanosleep+0xf9>        
                                                                      
  ticks = _Timespec_To_ticks( rqtp );                                 
  10d86a:	83 ec 0c             	sub    $0xc,%esp                      
  10d86d:	53                   	push   %ebx                           
  10d86e:	e8 a1 11 00 00       	call   10ea14 <_Timespec_To_ticks>    
  10d873:	89 c3                	mov    %eax,%ebx                      
   *  A nanosleep for zero time is implemented as a yield.            
   *  This behavior is also beyond the POSIX specification but is     
   *  consistent with the RTEMS API and yields desirable behavior.    
   */                                                                 
                                                                      
  if ( !ticks ) {                                                     
  10d875:	83 c4 10             	add    $0x10,%esp                     
  10d878:	85 c0                	test   %eax,%eax                      
  10d87a:	75 2f                	jne    10d8ab <nanosleep+0x77>        
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10d87c:	a1 98 de 11 00       	mov    0x11de98,%eax                  
  10d881:	40                   	inc    %eax                           
  10d882:	a3 98 de 11 00       	mov    %eax,0x11de98                  
    _Thread_Disable_dispatch();                                       
      _Thread_Yield_processor();                                      
  10d887:	e8 7c e4 ff ff       	call   10bd08 <_Thread_Yield_processor>
    _Thread_Enable_dispatch();                                        
  10d88c:	e8 af d9 ff ff       	call   10b240 <_Thread_Enable_dispatch>
    if ( rmtp ) {                                                     
  10d891:	85 f6                	test   %esi,%esi                      
  10d893:	0f 84 99 00 00 00    	je     10d932 <nanosleep+0xfe>        <== NEVER TAKEN
       rmtp->tv_sec = 0;                                              
  10d899:	c7 06 00 00 00 00    	movl   $0x0,(%esi)                    
       rmtp->tv_nsec = 0;                                             
  10d89f:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)                 
  10d8a6:	e9 87 00 00 00       	jmp    10d932 <nanosleep+0xfe>        
  10d8ab:	a1 98 de 11 00       	mov    0x11de98,%eax                  
  10d8b0:	40                   	inc    %eax                           
  10d8b1:	a3 98 de 11 00       	mov    %eax,0x11de98                  
                                                                      
  /*                                                                  
   *  Block for the desired amount of time                            
   */                                                                 
  _Thread_Disable_dispatch();                                         
    _Thread_Set_state(                                                
  10d8b6:	50                   	push   %eax                           
  10d8b7:	50                   	push   %eax                           
  10d8b8:	68 08 00 00 10       	push   $0x10000008                    
  10d8bd:	ff 35 58 df 11 00    	pushl  0x11df58                       
  10d8c3:	e8 68 e1 ff ff       	call   10ba30 <_Thread_Set_state>     
      _Thread_Executing,                                              
      STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL                
    );                                                                
    _Watchdog_Initialize(                                             
  10d8c8:	a1 58 df 11 00       	mov    0x11df58,%eax                  
  10d8cd:	8b 50 08             	mov    0x8(%eax),%edx                 
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10d8d0:	c7 40 50 00 00 00 00 	movl   $0x0,0x50(%eax)                
 *  @param[in] the_heap is the heap to operate upon                   
  10d8d7:	c7 40 64 c4 b0 10 00 	movl   $0x10b0c4,0x64(%eax)           
 *  @param[in] starting_address is the starting address of the memory for
  10d8de:	89 50 68             	mov    %edx,0x68(%eax)                
 *         the heap                                                   
  10d8e1:	c7 40 6c 00 00 00 00 	movl   $0x0,0x6c(%eax)                
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10d8e8:	89 58 54             	mov    %ebx,0x54(%eax)                
  void                *starting_address,                              
  size_t              *size                                           
  10d8eb:	5a                   	pop    %edx                           
  10d8ec:	59                   	pop    %ecx                           
  10d8ed:	83 c0 48             	add    $0x48,%eax                     
  10d8f0:	50                   	push   %eax                           
  10d8f1:	68 78 df 11 00       	push   $0x11df78                      
  10d8f6:	e8 4d e7 ff ff       	call   10c048 <_Watchdog_Insert>      
      _Thread_Delay_ended,                                            
      _Thread_Executing->Object.id,                                   
      NULL                                                            
    );                                                                
    _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );       
  _Thread_Enable_dispatch();                                          
  10d8fb:	e8 40 d9 ff ff       	call   10b240 <_Thread_Enable_dispatch>
                                                                      
  /* calculate time remaining */                                      
                                                                      
  if ( rmtp ) {                                                       
  10d900:	83 c4 10             	add    $0x10,%esp                     
  10d903:	85 f6                	test   %esi,%esi                      
  10d905:	74 2b                	je     10d932 <nanosleep+0xfe>        <== NEVER TAKEN
    ticks -=                                                          
  10d907:	a1 58 df 11 00       	mov    0x11df58,%eax                  
  10d90c:	03 58 5c             	add    0x5c(%eax),%ebx                
  10d90f:	2b 58 60             	sub    0x60(%eax),%ebx                
      _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
                                                                      
    _Timespec_From_ticks( ticks, rmtp );                              
  10d912:	50                   	push   %eax                           
  10d913:	50                   	push   %eax                           
  10d914:	56                   	push   %esi                           
  10d915:	53                   	push   %ebx                           
  10d916:	e8 a9 10 00 00       	call   10e9c4 <_Timespec_From_ticks>  
                                                                      
    /*                                                                
     *  If there is time remaining, then we were interrupted by a signal.
     */                                                               
                                                                      
    if ( ticks )                                                      
  10d91b:	83 c4 10             	add    $0x10,%esp                     
  10d91e:	85 db                	test   %ebx,%ebx                      
  10d920:	74 10                	je     10d932 <nanosleep+0xfe>        
      rtems_set_errno_and_return_minus_one( EINTR );                  
  10d922:	e8 45 1d 00 00       	call   10f66c <__errno>               
  10d927:	c7 00 04 00 00 00    	movl   $0x4,(%eax)                    
  10d92d:	83 c8 ff             	or     $0xffffffff,%eax               
  10d930:	eb 02                	jmp    10d934 <nanosleep+0x100>       
  10d932:	31 c0                	xor    %eax,%eax                      
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  10d934:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10d937:	5b                   	pop    %ebx                           
  10d938:	5e                   	pop    %esi                           
  10d939:	c9                   	leave                                 
  10d93a:	c3                   	ret                                   
                                                                      

001068a9 <newlib_free_buffers>: */ int newlib_free_buffers( FILE *fp ) {
  1068a9:	55                   	push   %ebp                           
  1068aa:	89 e5                	mov    %esp,%ebp                      
  1068ac:	53                   	push   %ebx                           
  1068ad:	83 ec 10             	sub    $0x10,%esp                     
  1068b0:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  switch ( fileno(fp) ) {                                             
  1068b3:	53                   	push   %ebx                           
  1068b4:	e8 5b 8b 00 00       	call   10f414 <fileno>                
  1068b9:	83 c4 10             	add    $0x10,%esp                     
  1068bc:	83 f8 02             	cmp    $0x2,%eax                      
  1068bf:	77 26                	ja     1068e7 <newlib_free_buffers+0x3e><== NEVER TAKEN
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
  1068c1:	80 7b 0c 00          	cmpb   $0x0,0xc(%ebx)                 
  1068c5:	79 2c                	jns    1068f3 <newlib_free_buffers+0x4a>
        free( fp->_bf._base );                                        
  1068c7:	83 ec 0c             	sub    $0xc,%esp                      
  1068ca:	ff 73 10             	pushl  0x10(%ebx)                     
  1068cd:	e8 a6 fb ff ff       	call   106478 <free>                  
        fp->_flags &= ~__SMBF;                                        
  1068d2:	66 81 63 0c 7f ff    	andw   $0xff7f,0xc(%ebx)              
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
  1068d8:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)                    
  1068de:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%ebx)                
  1068e5:	eb 09                	jmp    1068f0 <newlib_free_buffers+0x47>
      }                                                               
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
  1068e7:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1068ea:	53                   	push   %ebx                           <== NOT EXECUTED
  1068eb:	e8 84 89 00 00       	call   10f274 <fclose>                <== NOT EXECUTED
  1068f0:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
  return 0;                                                           
}                                                                     
  1068f3:	31 c0                	xor    %eax,%eax                      
  1068f5:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  1068f8:	c9                   	leave                                 
  1068f9:	c3                   	ret                                   
                                                                      

00106a98 <null_initialize>: rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) {
  106a98:	55                   	push   %ebp                           
  106a99:	89 e5                	mov    %esp,%ebp                      
  106a9b:	53                   	push   %ebx                           
  106a9c:	83 ec 04             	sub    $0x4,%esp                      
  106a9f:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  rtems_device_driver status;                                         
                                                                      
  if ( !initialized ) {                                               
  106aa2:	80 3d 64 0f 12 00 00 	cmpb   $0x0,0x120f64                  
  106aa9:	75 2b                	jne    106ad6 <null_initialize+0x3e>  
    initialized = 1;                                                  
  106aab:	c6 05 64 0f 12 00 01 	movb   $0x1,0x120f64                  
                                                                      
    status = rtems_io_register_name(                                  
  106ab2:	50                   	push   %eax                           
  106ab3:	6a 00                	push   $0x0                           
  106ab5:	53                   	push   %ebx                           
  106ab6:	68 01 9d 11 00       	push   $0x119d01                      
  106abb:	e8 f5 00 00 00       	call   106bb5 <rtems_io_register_name>
      "/dev/null",                                                    
      major,                                                          
      (rtems_device_minor_number) 0                                   
    );                                                                
                                                                      
    if (status != RTEMS_SUCCESSFUL)                                   
  106ac0:	83 c4 10             	add    $0x10,%esp                     
  106ac3:	85 c0                	test   %eax,%eax                      
  106ac5:	74 09                	je     106ad0 <null_initialize+0x38>  <== ALWAYS TAKEN
      rtems_fatal_error_occurred(status);                             
  106ac7:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106aca:	50                   	push   %eax                           <== NOT EXECUTED
  106acb:	e8 3c 38 00 00       	call   10a30c <rtems_fatal_error_occurred><== NOT EXECUTED
                                                                      
    NULL_major = major;                                               
  106ad0:	89 1d 78 11 12 00    	mov    %ebx,0x121178                  
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  106ad6:	31 c0                	xor    %eax,%eax                      
  106ad8:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  106adb:	c9                   	leave                                 
  106adc:	c3                   	ret                                   
                                                                      

00106a7d <null_write>: rtems_device_driver null_write( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) {
  106a7d:	55                   	push   %ebp                           
  106a7e:	89 e5                	mov    %esp,%ebp                      
  106a80:	8b 55 10             	mov    0x10(%ebp),%edx                
  rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;   
                                                                      
  if ( rw_args )                                                      
  106a83:	85 d2                	test   %edx,%edx                      
  106a85:	74 06                	je     106a8d <null_write+0x10>       <== ALWAYS TAKEN
    rw_args->bytes_moved = rw_args->count;                            
  106a87:	8b 42 0c             	mov    0xc(%edx),%eax                 <== NOT EXECUTED
  106a8a:	89 42 14             	mov    %eax,0x14(%edx)                <== NOT EXECUTED
                                                                      
  return NULL_SUCCESSFUL;                                             
}                                                                     
  106a8d:	31 c0                	xor    %eax,%eax                      
  106a8f:	c9                   	leave                                 
  106a90:	c3                   	ret                                   
                                                                      

00106bb0 <open>: int open( const char *pathname, int flags, ... ) {
  106bb0:	55                   	push   %ebp                           
  106bb1:	89 e5                	mov    %esp,%ebp                      
  106bb3:	57                   	push   %edi                           
  106bb4:	56                   	push   %esi                           
  106bb5:	53                   	push   %ebx                           
  106bb6:	83 ec 1c             	sub    $0x1c,%esp                     
  /*                                                                  
   * Set the Evaluation flags                                         
   */                                                                 
                                                                      
  eval_flags = 0;                                                     
  status = flags + 1;                                                 
  106bb9:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  106bbc:	40                   	inc    %eax                           
  if ( ( status & _FREAD ) == _FREAD )                                
  106bbd:	89 c3                	mov    %eax,%ebx                      
  106bbf:	83 e3 01             	and    $0x1,%ebx                      
  106bc2:	f7 db                	neg    %ebx                           
  106bc4:	83 e3 04             	and    $0x4,%ebx                      
    eval_flags |= RTEMS_LIBIO_PERMS_READ;                             
  if ( ( status & _FWRITE ) == _FWRITE )                              
  106bc7:	a8 02                	test   $0x2,%al                       
  106bc9:	74 03                	je     106bce <open+0x1e>             
    eval_flags |= RTEMS_LIBIO_PERMS_WRITE;                            
  106bcb:	83 cb 02             	or     $0x2,%ebx                      
                                                                      
                                                                      
  va_start(ap, flags);                                                
                                                                      
  mode = va_arg( ap, int );                                           
  106bce:	8b 45 10             	mov    0x10(%ebp),%eax                
  106bd1:	89 45 dc             	mov    %eax,-0x24(%ebp)               
   *             code does not require changes here since network file
   *             descriptors are obtained using socket(), not open(). 
   */                                                                 
                                                                      
  /* allocate a file control block */                                 
  iop = rtems_libio_allocate();                                       
  106bd4:	e8 38 64 00 00       	call   10d011 <rtems_libio_allocate>  
  106bd9:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  if ( iop == 0 ) {                                                   
  106bdc:	be 17 00 00 00       	mov    $0x17,%esi                     
  106be1:	85 c0                	test   %eax,%eax                      
  106be3:	0f 84 8e 01 00 00    	je     106d77 <open+0x1c7>            
                                                                      
  /*                                                                  
   *  See if the file exists.                                         
   */                                                                 
                                                                      
  status = rtems_filesystem_evaluate_path(                            
  106be9:	6a 01                	push   $0x1                           
  106beb:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  106bee:	57                   	push   %edi                           
  106bef:	53                   	push   %ebx                           
  106bf0:	ff 75 08             	pushl  0x8(%ebp)                      
  106bf3:	e8 5e f7 ff ff       	call   106356 <rtems_filesystem_evaluate_path>
     pathname, eval_flags, &loc, true );                              
                                                                      
  if ( status == -1 ) {                                               
  106bf8:	83 c4 10             	add    $0x10,%esp                     
  106bfb:	40                   	inc    %eax                           
  106bfc:	75 61                	jne    106c5f <open+0xaf>             
    if ( errno != ENOENT ) {                                          
  106bfe:	e8 25 85 00 00       	call   10f128 <__errno>               
  106c03:	83 38 02             	cmpl   $0x2,(%eax)                    
  106c06:	75 2c                	jne    106c34 <open+0x84>             
      rc = errno;                                                     
      goto done;                                                      
    }                                                                 
                                                                      
    /* If the file does not exist and we are not trying to create it--> error */
    if ( !(flags & O_CREAT) ) {                                       
  106c08:	be 02 00 00 00       	mov    $0x2,%esi                      
  106c0d:	f7 45 0c 00 02 00 00 	testl  $0x200,0xc(%ebp)               
  106c14:	0f 84 2c 01 00 00    	je     106d46 <open+0x196>            
      rc = ENOENT;                                                    
      goto done;                                                      
    }                                                                 
                                                                      
    /* Create the node for the new regular file */                    
    rc = mknod( pathname, S_IFREG | mode, 0LL );                      
  106c1a:	6a 00                	push   $0x0                           
  106c1c:	6a 00                	push   $0x0                           
  106c1e:	8b 45 dc             	mov    -0x24(%ebp),%eax               
  106c21:	80 cc 80             	or     $0x80,%ah                      
  106c24:	50                   	push   %eax                           
  106c25:	ff 75 08             	pushl  0x8(%ebp)                      
  106c28:	e8 df fa ff ff       	call   10670c <mknod>                 
    if ( rc ) {                                                       
  106c2d:	83 c4 10             	add    $0x10,%esp                     
  106c30:	85 c0                	test   %eax,%eax                      
  106c32:	74 0c                	je     106c40 <open+0x90>             <== ALWAYS TAKEN
      rc = errno;                                                     
  106c34:	e8 ef 84 00 00       	call   10f128 <__errno>               
  106c39:	8b 30                	mov    (%eax),%esi                    
  106c3b:	e9 02 01 00 00       	jmp    106d42 <open+0x192>            
      goto done;                                                      
    }                                                                 
                                                                      
    /* Sanity check to see if the file name exists after the mknod() */
    status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true );
  106c40:	6a 01                	push   $0x1                           
  106c42:	57                   	push   %edi                           
  106c43:	6a 00                	push   $0x0                           
  106c45:	ff 75 08             	pushl  0x8(%ebp)                      
  106c48:	e8 09 f7 ff ff       	call   106356 <rtems_filesystem_evaluate_path>
    if ( status != 0 ) {   /* The file did not exist */               
  106c4d:	83 c4 10             	add    $0x10,%esp                     
  106c50:	be 0d 00 00 00       	mov    $0xd,%esi                      
  106c55:	85 c0                	test   %eax,%eax                      
  106c57:	0f 85 e9 00 00 00    	jne    106d46 <open+0x196>            <== NEVER TAKEN
  106c5d:	eb 1b                	jmp    106c7a <open+0xca>             
      rc = EACCES;                                                    
      goto done;                                                      
    }                                                                 
                                                                      
  } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {        
  106c5f:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  106c62:	25 00 0a 00 00       	and    $0xa00,%eax                    
  106c67:	3d 00 0a 00 00       	cmp    $0xa00,%eax                    
  106c6c:	75 0c                	jne    106c7a <open+0xca>             
  106c6e:	be 11 00 00 00       	mov    $0x11,%esi                     
  106c73:	89 fb                	mov    %edi,%ebx                      
  106c75:	e9 ce 00 00 00       	jmp    106d48 <open+0x198>            
  /*                                                                  
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
  106c7a:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  106c7d:	8b 55 e0             	mov    -0x20(%ebp),%edx               
  106c80:	89 42 30             	mov    %eax,0x30(%edx)                
  iop->file_info  = loc.node_access;                                  
  106c83:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  106c86:	89 42 2c             	mov    %eax,0x2c(%edx)                
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
  106c89:	8b 5a 0c             	mov    0xc(%edx),%ebx                 
  106c8c:	83 ec 0c             	sub    $0xc,%esp                      
  106c8f:	ff 75 0c             	pushl  0xc(%ebp)                      
  106c92:	e8 0c 64 00 00       	call   10d0a3 <rtems_libio_fcntl_flags>
  106c97:	09 c3                	or     %eax,%ebx                      
  106c99:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  106c9c:	89 58 0c             	mov    %ebx,0xc(%eax)                 
  iop->pathinfo   = loc;                                              
  106c9f:	89 c7                	mov    %eax,%edi                      
  106ca1:	83 c7 10             	add    $0x10,%edi                     
  106ca4:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  106ca7:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  106cac:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  if ( !iop->handlers->open_h ) {                                     
  106cae:	89 c2                	mov    %eax,%edx                      
  106cb0:	8b 40 30             	mov    0x30(%eax),%eax                
  106cb3:	8b 00                	mov    (%eax),%eax                    
  106cb5:	83 c4 10             	add    $0x10,%esp                     
  106cb8:	85 c0                	test   %eax,%eax                      
  106cba:	0f 84 df 00 00 00    	je     106d9f <open+0x1ef>            <== NEVER TAKEN
    rc = ENOTSUP;                                                     
    goto done;                                                        
  }                                                                   
                                                                      
  rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );        
  106cc0:	ff 75 dc             	pushl  -0x24(%ebp)                    
  106cc3:	ff 75 0c             	pushl  0xc(%ebp)                      
  106cc6:	ff 75 08             	pushl  0x8(%ebp)                      
  106cc9:	52                   	push   %edx                           
  106cca:	ff d0                	call   *%eax                          
  106ccc:	89 c6                	mov    %eax,%esi                      
  if ( rc )                                                           
  106cce:	83 c4 10             	add    $0x10,%esp                     
  106cd1:	85 c0                	test   %eax,%eax                      
  106cd3:	0f 85 cb 00 00 00    	jne    106da4 <open+0x1f4>            <== NEVER TAKEN
                                                                      
  /*                                                                  
   *  Optionally truncate the file.                                   
   */                                                                 
                                                                      
  if ( (flags & O_TRUNC) == O_TRUNC ) {                               
  106cd9:	f7 45 0c 00 04 00 00 	testl  $0x400,0xc(%ebp)               
  106ce0:	0f 84 9d 00 00 00    	je     106d83 <open+0x1d3>            
    rc = ftruncate( iop - rtems_libio_iops, 0 );                      
  106ce6:	50                   	push   %eax                           
  106ce7:	50                   	push   %eax                           
  106ce8:	6a 00                	push   $0x0                           
  106cea:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  106ced:	2b 05 38 d6 11 00    	sub    0x11d638,%eax                  
  106cf3:	c1 f8 02             	sar    $0x2,%eax                      
  106cf6:	69 c0 c5 4e ec c4    	imul   $0xc4ec4ec5,%eax,%eax          
  106cfc:	50                   	push   %eax                           
  106cfd:	e8 8e 60 00 00       	call   10cd90 <ftruncate>             
  106d02:	89 c6                	mov    %eax,%esi                      
    if ( rc ) {                                                       
  106d04:	83 c4 10             	add    $0x10,%esp                     
  106d07:	85 c0                	test   %eax,%eax                      
  106d09:	74 78                	je     106d83 <open+0x1d3>            <== ALWAYS TAKEN
      if(errno) rc = errno;                                           
  106d0b:	e8 18 84 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  106d10:	83 38 00             	cmpl   $0x0,(%eax)                    <== NOT EXECUTED
  106d13:	74 07                	je     106d1c <open+0x16c>            <== NOT EXECUTED
  106d15:	e8 0e 84 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  106d1a:	8b 30                	mov    (%eax),%esi                    <== NOT EXECUTED
      close( iop - rtems_libio_iops );                                
  106d1c:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106d1f:	a1 38 d6 11 00       	mov    0x11d638,%eax                  <== NOT EXECUTED
  106d24:	29 45 e0             	sub    %eax,-0x20(%ebp)               <== NOT EXECUTED
  106d27:	c1 7d e0 02          	sarl   $0x2,-0x20(%ebp)               <== NOT EXECUTED
  106d2b:	69 45 e0 c5 4e ec c4 	imul   $0xc4ec4ec5,-0x20(%ebp),%eax   <== NOT EXECUTED
  106d32:	50                   	push   %eax                           <== NOT EXECUTED
  106d33:	e8 d4 5f 00 00       	call   10cd0c <close>                 <== NOT EXECUTED
  106d38:	c7 45 e0 00 00 00 00 	movl   $0x0,-0x20(%ebp)               <== NOT EXECUTED
  106d3f:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
   */                                                                 
                                                                      
done:                                                                 
  va_end(ap);                                                         
                                                                      
  if ( rc ) {                                                         
  106d42:	85 f6                	test   %esi,%esi                      
  106d44:	74 3d                	je     106d83 <open+0x1d3>            <== NEVER TAKEN
  106d46:	31 db                	xor    %ebx,%ebx                      
    if ( iop )                                                        
  106d48:	83 7d e0 00          	cmpl   $0x0,-0x20(%ebp)               
  106d4c:	74 0e                	je     106d5c <open+0x1ac>            <== NEVER TAKEN
      rtems_libio_free( iop );                                        
  106d4e:	83 ec 0c             	sub    $0xc,%esp                      
  106d51:	ff 75 e0             	pushl  -0x20(%ebp)                    
  106d54:	e8 63 62 00 00       	call   10cfbc <rtems_libio_free>      
  106d59:	83 c4 10             	add    $0x10,%esp                     
    if ( loc_to_free )                                                
  106d5c:	85 db                	test   %ebx,%ebx                      
  106d5e:	74 17                	je     106d77 <open+0x1c7>            
      rtems_filesystem_freenode( loc_to_free );                       
  106d60:	8b 43 08             	mov    0x8(%ebx),%eax                 
  106d63:	85 c0                	test   %eax,%eax                      
  106d65:	74 10                	je     106d77 <open+0x1c7>            <== NEVER TAKEN
  106d67:	8b 40 1c             	mov    0x1c(%eax),%eax                
  106d6a:	85 c0                	test   %eax,%eax                      
  106d6c:	74 09                	je     106d77 <open+0x1c7>            <== NEVER TAKEN
  106d6e:	83 ec 0c             	sub    $0xc,%esp                      
  106d71:	53                   	push   %ebx                           
  106d72:	ff d0                	call   *%eax                          
  106d74:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( rc );                       
  106d77:	e8 ac 83 00 00       	call   10f128 <__errno>               
  106d7c:	89 30                	mov    %esi,(%eax)                    
  106d7e:	83 c8 ff             	or     $0xffffffff,%eax               
  106d81:	eb 14                	jmp    106d97 <open+0x1e7>            
  }                                                                   
                                                                      
  return iop - rtems_libio_iops;                                      
  106d83:	8b 15 38 d6 11 00    	mov    0x11d638,%edx                  
  106d89:	29 55 e0             	sub    %edx,-0x20(%ebp)               
  106d8c:	c1 7d e0 02          	sarl   $0x2,-0x20(%ebp)               
  106d90:	69 45 e0 c5 4e ec c4 	imul   $0xc4ec4ec5,-0x20(%ebp),%eax   
}                                                                     
  106d97:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106d9a:	5b                   	pop    %ebx                           
  106d9b:	5e                   	pop    %esi                           
  106d9c:	5f                   	pop    %edi                           
  106d9d:	c9                   	leave                                 
  106d9e:	c3                   	ret                                   
    if ( loc_to_free )                                                
      rtems_filesystem_freenode( loc_to_free );                       
    rtems_set_errno_and_return_minus_one( rc );                       
  }                                                                   
                                                                      
  return iop - rtems_libio_iops;                                      
  106d9f:	be 86 00 00 00       	mov    $0x86,%esi                     <== NOT EXECUTED
  106da4:	8d 5d e4             	lea    -0x1c(%ebp),%ebx               <== NOT EXECUTED
  106da7:	eb 9f                	jmp    106d48 <open+0x198>            <== NOT EXECUTED
                                                                      

00106b50 <open_dev_console>: /* * This is a replaceable stub */ void open_dev_console(void) {
  106b50:	55                   	push   %ebp                           
  106b51:	89 e5                	mov    %esp,%ebp                      
  106b53:	83 ec 0c             	sub    $0xc,%esp                      
  int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8;                  
                                                                      
  /*                                                                  
   * Attempt to open /dev/console.                                    
   */                                                                 
  if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {         
  106b56:	6a 00                	push   $0x0                           
  106b58:	6a 00                	push   $0x0                           
  106b5a:	68 73 60 11 00       	push   $0x116073                      
  106b5f:	e8 4c 00 00 00       	call   106bb0 <open>                  
  106b64:	83 c4 10             	add    $0x10,%esp                     
  106b67:	40                   	inc    %eax                           
  106b68:	74 41                	je     106bab <open_dev_console+0x5b> 
                                                                      
  /*                                                                  
   *  But if we find /dev/console once, we better find it twice more  
   *  or something is REALLY wrong.                                   
   */                                                                 
  if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)          
  106b6a:	52                   	push   %edx                           
  106b6b:	6a 00                	push   $0x0                           
  106b6d:	6a 01                	push   $0x1                           
  106b6f:	68 73 60 11 00       	push   $0x116073                      
  106b74:	e8 37 00 00 00       	call   106bb0 <open>                  
  106b79:	83 c4 10             	add    $0x10,%esp                     
  106b7c:	40                   	inc    %eax                           
  106b7d:	75 0a                	jne    106b89 <open_dev_console+0x39> <== ALWAYS TAKEN
    rtems_fatal_error_occurred( error_code | '1' );                   
  106b7f:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106b82:	68 31 44 54 53       	push   $0x53544431                    <== NOT EXECUTED
  106b87:	eb 1d                	jmp    106ba6 <open_dev_console+0x56> <== NOT EXECUTED
                                                                      
  if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)          
  106b89:	50                   	push   %eax                           
  106b8a:	6a 00                	push   $0x0                           
  106b8c:	6a 01                	push   $0x1                           
  106b8e:	68 73 60 11 00       	push   $0x116073                      
  106b93:	e8 18 00 00 00       	call   106bb0 <open>                  
  106b98:	83 c4 10             	add    $0x10,%esp                     
  106b9b:	40                   	inc    %eax                           
  106b9c:	75 0d                	jne    106bab <open_dev_console+0x5b> <== ALWAYS TAKEN
    rtems_fatal_error_occurred( error_code | '2' );                   
  106b9e:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106ba1:	68 32 44 54 53       	push   $0x53544432                    <== NOT EXECUTED
  106ba6:	e8 e9 2b 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
}                                                                     
  106bab:	c9                   	leave                                 
  106bac:	c3                   	ret                                   
                                                                      

00108450 <opendir>: * open a directory. */ DIR * opendir( const char *name ) {
  108450:	55                   	push   %ebp                           
  108451:	89 e5                	mov    %esp,%ebp                      
  108453:	56                   	push   %esi                           
  108454:	53                   	push   %ebx                           
	register DIR *dirp;                                                  
	register int fd;                                                     
                                                                      
	if ((fd = open(name, 0)) == -1)                                      
  108455:	52                   	push   %edx                           
  108456:	52                   	push   %edx                           
  108457:	6a 00                	push   $0x0                           
  108459:	ff 75 08             	pushl  0x8(%ebp)                      
  10845c:	e8 77 00 00 00       	call   1084d8 <open>                  
  108461:	89 c6                	mov    %eax,%esi                      
  108463:	83 c4 10             	add    $0x10,%esp                     
  108466:	31 db                	xor    %ebx,%ebx                      
  108468:	83 f8 ff             	cmp    $0xffffffff,%eax               
  10846b:	74 62                	je     1084cf <opendir+0x7f>          <== NEVER TAKEN
		return NULL;                                                        
	if (fcntl(fd, F_SETFD, 1) == -1 ||                                   
  10846d:	50                   	push   %eax                           
  10846e:	6a 01                	push   $0x1                           
  108470:	6a 02                	push   $0x2                           
  108472:	56                   	push   %esi                           
  108473:	e8 8c 65 00 00       	call   10ea04 <fcntl>                 
  108478:	83 c4 10             	add    $0x10,%esp                     
  10847b:	40                   	inc    %eax                           
  10847c:	74 31                	je     1084af <opendir+0x5f>          <== NEVER TAKEN
  10847e:	83 ec 0c             	sub    $0xc,%esp                      
  108481:	6a 18                	push   $0x18                          
  108483:	e8 10 f8 ff ff       	call   107c98 <malloc>                
  108488:	89 c3                	mov    %eax,%ebx                      
  10848a:	83 c4 10             	add    $0x10,%esp                     
  10848d:	85 c0                	test   %eax,%eax                      
  10848f:	74 1e                	je     1084af <opendir+0x5f>          <== NEVER TAKEN
	 * If CLSIZE is an exact multiple of DIRBLKSIZ, use a CLSIZE         
	 * buffer that it cluster boundary aligned.                          
	 * Hopefully this can be a big win someday by allowing page trades   
	 * to user space to be done by getdirentries()                       
	 */                                                                  
	dirp->dd_buf = malloc (512);                                         
  108491:	83 ec 0c             	sub    $0xc,%esp                      
  108494:	68 00 02 00 00       	push   $0x200                         
  108499:	e8 fa f7 ff ff       	call   107c98 <malloc>                
  10849e:	89 43 0c             	mov    %eax,0xc(%ebx)                 
	dirp->dd_len = 512;                                                  
  1084a1:	c7 43 10 00 02 00 00 	movl   $0x200,0x10(%ebx)              
                                                                      
	if (dirp->dd_buf == NULL) {                                          
  1084a8:	83 c4 10             	add    $0x10,%esp                     
  1084ab:	85 c0                	test   %eax,%eax                      
  1084ad:	75 10                	jne    1084bf <opendir+0x6f>          <== ALWAYS TAKEN
		close (fd);                                                         
  1084af:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1084b2:	56                   	push   %esi                           <== NOT EXECUTED
  1084b3:	e8 80 ef ff ff       	call   107438 <close>                 <== NOT EXECUTED
  1084b8:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  1084ba:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1084bd:	eb 10                	jmp    1084cf <opendir+0x7f>          <== NOT EXECUTED
		return NULL;                                                        
	}                                                                    
	dirp->dd_fd = fd;                                                    
  1084bf:	89 33                	mov    %esi,(%ebx)                    
	dirp->dd_loc = 0;                                                    
  1084c1:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)                 
	dirp->dd_seek = 0;                                                   
  1084c8:	c7 43 14 00 00 00 00 	movl   $0x0,0x14(%ebx)                
	/*                                                                   
	 * Set up seek point for rewinddir.                                  
	 */                                                                  
	return dirp;                                                         
}                                                                     
  1084cf:	89 d8                	mov    %ebx,%eax                      
  1084d1:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1084d4:	5b                   	pop    %ebx                           
  1084d5:	5e                   	pop    %esi                           
  1084d6:	c9                   	leave                                 
  1084d7:	c3                   	ret                                   
                                                                      

001077a8 <oproc>: /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) {
  1077a8:	55                   	push   %ebp                           
  1077a9:	89 e5                	mov    %esp,%ebp                      
  1077ab:	56                   	push   %esi                           
  1077ac:	53                   	push   %ebx                           
  1077ad:	83 ec 10             	sub    $0x10,%esp                     
  1077b0:	89 d3                	mov    %edx,%ebx                      
  1077b2:	88 45 f4             	mov    %al,-0xc(%ebp)                 
	int	i;                                                               
                                                                      
	if (tty->termios.c_oflag & OPOST) {                                  
  1077b5:	8b 4a 34             	mov    0x34(%edx),%ecx                
  1077b8:	f6 c1 01             	test   $0x1,%cl                       
  1077bb:	0f 84 df 00 00 00    	je     1078a0 <oproc+0xf8>            <== NEVER TAKEN
		switch (c) {                                                        
  1077c1:	3c 09                	cmp    $0x9,%al                       
  1077c3:	74 76                	je     10783b <oproc+0x93>            
  1077c5:	77 0d                	ja     1077d4 <oproc+0x2c>            <== ALWAYS TAKEN
  1077c7:	3c 08                	cmp    $0x8,%al                       <== NOT EXECUTED
  1077c9:	0f 85 a6 00 00 00    	jne    107875 <oproc+0xcd>            <== NOT EXECUTED
  1077cf:	e9 94 00 00 00       	jmp    107868 <oproc+0xc0>            <== NOT EXECUTED
  1077d4:	3c 0a                	cmp    $0xa,%al                       
  1077d6:	74 0a                	je     1077e2 <oproc+0x3a>            
  1077d8:	3c 0d                	cmp    $0xd,%al                       
  1077da:	0f 85 95 00 00 00    	jne    107875 <oproc+0xcd>            <== ALWAYS TAKEN
  1077e0:	eb 33                	jmp    107815 <oproc+0x6d>            <== NOT EXECUTED
		case '\n':                                                          
			if (tty->termios.c_oflag & ONLRET)                                 
  1077e2:	80 e1 20             	and    $0x20,%cl                      
  1077e5:	74 07                	je     1077ee <oproc+0x46>            <== ALWAYS TAKEN
				tty->column = 0;                                                  
  1077e7:	c7 42 28 00 00 00 00 	movl   $0x0,0x28(%edx)                <== NOT EXECUTED
			if (tty->termios.c_oflag & ONLCR) {                                
  1077ee:	f6 43 34 04          	testb  $0x4,0x34(%ebx)                
  1077f2:	0f 84 a8 00 00 00    	je     1078a0 <oproc+0xf8>            <== NEVER TAKEN
				rtems_termios_puts ("\r", 1, tty);                                
  1077f8:	50                   	push   %eax                           
  1077f9:	53                   	push   %ebx                           
  1077fa:	6a 01                	push   $0x1                           
  1077fc:	68 47 72 11 00       	push   $0x117247                      
  107801:	e8 8d fe ff ff       	call   107693 <rtems_termios_puts>    
				tty->column = 0;                                                  
  107806:	c7 43 28 00 00 00 00 	movl   $0x0,0x28(%ebx)                
  10780d:	83 c4 10             	add    $0x10,%esp                     
  107810:	e9 8b 00 00 00       	jmp    1078a0 <oproc+0xf8>            
			}                                                                  
			break;                                                             
                                                                      
		case '\r':                                                          
			if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))          
  107815:	f6 c1 10             	test   $0x10,%cl                      <== NOT EXECUTED
  107818:	74 0a                	je     107824 <oproc+0x7c>            <== NOT EXECUTED
  10781a:	83 7a 28 00          	cmpl   $0x0,0x28(%edx)                <== NOT EXECUTED
  10781e:	0f 84 8c 00 00 00    	je     1078b0 <oproc+0x108>           <== NOT EXECUTED
				return;                                                           
			if (tty->termios.c_oflag & OCRNL) {                                
  107824:	f6 c1 08             	test   $0x8,%cl                       <== NOT EXECUTED
  107827:	74 09                	je     107832 <oproc+0x8a>            <== NOT EXECUTED
				c = '\n';                                                         
  107829:	c6 45 f4 0a          	movb   $0xa,-0xc(%ebp)                <== NOT EXECUTED
				if (tty->termios.c_oflag & ONLRET)                                
  10782d:	80 e1 20             	and    $0x20,%cl                      <== NOT EXECUTED
  107830:	74 6e                	je     1078a0 <oproc+0xf8>            <== NOT EXECUTED
					tty->column = 0;                                                 
				break;                                                            
			}                                                                  
			tty->column = 0;                                                   
  107832:	c7 43 28 00 00 00 00 	movl   $0x0,0x28(%ebx)                <== NOT EXECUTED
  107839:	eb 65                	jmp    1078a0 <oproc+0xf8>            <== NOT EXECUTED
			break;                                                             
                                                                      
		case '\t':                                                          
			i = 8 - (tty->column & 7);                                         
  10783b:	8b 52 28             	mov    0x28(%edx),%edx                
  10783e:	89 d0                	mov    %edx,%eax                      
  107840:	83 e0 07             	and    $0x7,%eax                      
  107843:	be 08 00 00 00       	mov    $0x8,%esi                      
  107848:	29 c6                	sub    %eax,%esi                      
			if ((tty->termios.c_oflag & TABDLY) == XTABS) {                    
  10784a:	81 e1 00 18 00 00    	and    $0x1800,%ecx                   
  107850:	81 f9 00 18 00 00    	cmp    $0x1800,%ecx                   
  107856:	8d 04 16             	lea    (%esi,%edx,1),%eax             
  107859:	75 15                	jne    107870 <oproc+0xc8>            <== NEVER TAKEN
				tty->column += i;                                                 
  10785b:	89 43 28             	mov    %eax,0x28(%ebx)                
				rtems_termios_puts ( "        ",  i, tty);                        
  10785e:	50                   	push   %eax                           
  10785f:	53                   	push   %ebx                           
  107860:	56                   	push   %esi                           
  107861:	68 49 72 11 00       	push   $0x117249                      
  107866:	eb 40                	jmp    1078a8 <oproc+0x100>           
			}                                                                  
			tty->column += i;                                                  
			break;                                                             
                                                                      
		case '\b':                                                          
			if (tty->column > 0)                                               
  107868:	8b 42 28             	mov    0x28(%edx),%eax                <== NOT EXECUTED
  10786b:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10786d:	7e 31                	jle    1078a0 <oproc+0xf8>            <== NOT EXECUTED
				tty->column--;                                                    
  10786f:	48                   	dec    %eax                           <== NOT EXECUTED
  107870:	89 43 28             	mov    %eax,0x28(%ebx)                <== NOT EXECUTED
  107873:	eb 2b                	jmp    1078a0 <oproc+0xf8>            <== NOT EXECUTED
			break;                                                             
                                                                      
		default:                                                            
			if (tty->termios.c_oflag & OLCUC)                                  
  107875:	80 e1 02             	and    $0x2,%cl                       
  107878:	74 14                	je     10788e <oproc+0xe6>            <== ALWAYS TAKEN
				c = toupper(c);                                                   
  10787a:	0f b6 d0             	movzbl %al,%edx                       <== NOT EXECUTED
  10787d:	a1 00 b7 11 00       	mov    0x11b700,%eax                  <== NOT EXECUTED
  107882:	f6 04 10 02          	testb  $0x2,(%eax,%edx,1)             <== NOT EXECUTED
  107886:	74 03                	je     10788b <oproc+0xe3>            <== NOT EXECUTED
  107888:	83 ea 20             	sub    $0x20,%edx                     <== NOT EXECUTED
  10788b:	88 55 f4             	mov    %dl,-0xc(%ebp)                 <== NOT EXECUTED
			if (!iscntrl(c))                                                   
  10788e:	0f b6 55 f4          	movzbl -0xc(%ebp),%edx                
  107892:	a1 00 b7 11 00       	mov    0x11b700,%eax                  
  107897:	f6 04 10 20          	testb  $0x20,(%eax,%edx,1)            
  10789b:	75 03                	jne    1078a0 <oproc+0xf8>            <== NEVER TAKEN
				tty->column++;                                                    
  10789d:	ff 43 28             	incl   0x28(%ebx)                     
			break;                                                             
		}                                                                   
	}                                                                    
	rtems_termios_puts (&c, 1, tty);                                     
  1078a0:	56                   	push   %esi                           
  1078a1:	53                   	push   %ebx                           
  1078a2:	6a 01                	push   $0x1                           
  1078a4:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  1078a7:	50                   	push   %eax                           
  1078a8:	e8 e6 fd ff ff       	call   107693 <rtems_termios_puts>    
  1078ad:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  1078b0:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1078b3:	5b                   	pop    %ebx                           
  1078b4:	5e                   	pop    %esi                           
  1078b5:	c9                   	leave                                 
  1078b6:	c3                   	ret                                   
                                                                      

00108204 <posix_memalign>: int posix_memalign( void **pointer, size_t alignment, size_t size ) {
  108204:	55                   	push   %ebp                           
  108205:	89 e5                	mov    %esp,%ebp                      
  108207:	53                   	push   %ebx                           
  108208:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10820b:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10820e:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
  108211:	ff 05 9c 29 12 00    	incl   0x12299c                       
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
  108217:	8d 42 ff             	lea    -0x1(%edx),%eax                
  10821a:	85 d0                	test   %edx,%eax                      
  10821c:	75 05                	jne    108223 <posix_memalign+0x1f>   <== NEVER TAKEN
  10821e:	83 fa 03             	cmp    $0x3,%edx                      
  108221:	77 08                	ja     10822b <posix_memalign+0x27>   
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
}                                                                     
  108223:	b8 16 00 00 00       	mov    $0x16,%eax                     
  108228:	5b                   	pop    %ebx                           
  108229:	c9                   	leave                                 
  10822a:	c3                   	ret                                   
                                                                      
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
  10822b:	89 4d 10             	mov    %ecx,0x10(%ebp)                
  10822e:	89 55 0c             	mov    %edx,0xc(%ebp)                 
  108231:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
}                                                                     
  108234:	5b                   	pop    %ebx                           
  108235:	c9                   	leave                                 
                                                                      
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
  108236:	e9 c1 03 00 00       	jmp    1085fc <rtems_memalign>        
                                                                      

001091cc <pthread_barrier_init>: int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) {
  1091cc:	55                   	push   %ebp                           
  1091cd:	89 e5                	mov    %esp,%ebp                      
  1091cf:	57                   	push   %edi                           
  1091d0:	56                   	push   %esi                           
  1091d1:	53                   	push   %ebx                           
  1091d2:	83 ec 1c             	sub    $0x1c,%esp                     
  1091d5:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  1091d8:	8b 75 10             	mov    0x10(%ebp),%esi                
  const pthread_barrierattr_t   *the_attr;                            
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !barrier )                                                     
  1091db:	85 ff                	test   %edi,%edi                      
  1091dd:	0f 84 94 00 00 00    	je     109277 <pthread_barrier_init+0xab>
    return EINVAL;                                                    
                                                                      
  if ( count == 0 )                                                   
  1091e3:	85 f6                	test   %esi,%esi                      
  1091e5:	0f 84 8c 00 00 00    	je     109277 <pthread_barrier_init+0xab>
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
  1091eb:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1091ee:	85 c0                	test   %eax,%eax                      
  1091f0:	75 11                	jne    109203 <pthread_barrier_init+0x37>
    the_attr = attr;                                                  
  } else {                                                            
    (void) pthread_barrierattr_init( &my_attr );                      
  1091f2:	83 ec 0c             	sub    $0xc,%esp                      
  1091f5:	8d 5d e4             	lea    -0x1c(%ebp),%ebx               
  1091f8:	53                   	push   %ebx                           
  1091f9:	e8 1a ff ff ff       	call   109118 <pthread_barrierattr_init>
  1091fe:	89 d8                	mov    %ebx,%eax                      
  109200:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  /*                                                                  
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
  109203:	83 38 00             	cmpl   $0x0,(%eax)                    
  109206:	74 6f                	je     109277 <pthread_barrier_init+0xab>
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
  109208:	83 78 04 00          	cmpl   $0x0,0x4(%eax)                 
  10920c:	75 69                	jne    109277 <pthread_barrier_init+0xab><== NEVER TAKEN
  }                                                                   
                                                                      
  /*                                                                  
   * Convert from POSIX attributes to Core Barrier attributes         
   */                                                                 
  the_attributes.discipline    = CORE_BARRIER_AUTOMATIC_RELEASE;      
  10920e:	c7 45 ec 00 00 00 00 	movl   $0x0,-0x14(%ebp)               
  the_attributes.maximum_count = count;                               
  109215:	89 75 f0             	mov    %esi,-0x10(%ebp)               
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109218:	a1 90 ec 11 00       	mov    0x11ec90,%eax                  
  10921d:	40                   	inc    %eax                           
  10921e:	a3 90 ec 11 00       	mov    %eax,0x11ec90                  
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
  109223:	83 ec 0c             	sub    $0xc,%esp                      
  109226:	68 80 f0 11 00       	push   $0x11f080                      
  10922b:	e8 d4 1f 00 00       	call   10b204 <_Objects_Allocate>     
  109230:	89 c3                	mov    %eax,%ebx                      
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _POSIX_Barrier_Allocate();                            
                                                                      
  if ( !the_barrier ) {                                               
  109232:	83 c4 10             	add    $0x10,%esp                     
  109235:	85 c0                	test   %eax,%eax                      
  109237:	75 0c                	jne    109245 <pthread_barrier_init+0x79>
    _Thread_Enable_dispatch();                                        
  109239:	e8 ca 2b 00 00       	call   10be08 <_Thread_Enable_dispatch>
  10923e:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  109243:	eb 37                	jmp    10927c <pthread_barrier_init+0xb0>
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
  109245:	50                   	push   %eax                           
  109246:	50                   	push   %eax                           
  109247:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10924a:	50                   	push   %eax                           
  10924b:	8d 43 10             	lea    0x10(%ebx),%eax                
  10924e:	50                   	push   %eax                           
  10924f:	e8 ac 17 00 00       	call   10aa00 <_CORE_barrier_Initialize>
  109254:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  109257:	0f b7 d1             	movzwl %cx,%edx                       
  10925a:	a1 9c f0 11 00       	mov    0x11f09c,%eax                  
  10925f:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  109262:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
  );                                                                  
                                                                      
  /*                                                                  
   * Exit the critical section and return the user an operational barrier
   */                                                                 
  *barrier = the_barrier->Object.id;                                  
  109269:	89 0f                	mov    %ecx,(%edi)                    
  _Thread_Enable_dispatch();                                          
  10926b:	e8 98 2b 00 00       	call   10be08 <_Thread_Enable_dispatch>
  109270:	31 c0                	xor    %eax,%eax                      
  109272:	83 c4 10             	add    $0x10,%esp                     
  109275:	eb 05                	jmp    10927c <pthread_barrier_init+0xb0>
  return 0;                                                           
  109277:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  10927c:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10927f:	5b                   	pop    %ebx                           
  109280:	5e                   	pop    %esi                           
  109281:	5f                   	pop    %edi                           
  109282:	c9                   	leave                                 
  109283:	c3                   	ret                                   
                                                                      

00108a54 <pthread_cancel>: */ int pthread_cancel( pthread_t thread ) {
  108a54:	55                   	push   %ebp                           
  108a55:	89 e5                	mov    %esp,%ebp                      
  108a57:	56                   	push   %esi                           
  108a58:	53                   	push   %ebx                           
  108a59:	83 ec 10             	sub    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Don't even think about deleting a resource from an ISR.         
   */                                                                 
                                                                      
  if ( _ISR_Is_in_progress() )                                        
  108a5c:	a1 84 f5 11 00       	mov    0x11f584,%eax                  
  108a61:	ba 47 00 00 00       	mov    $0x47,%edx                     
  108a66:	85 c0                	test   %eax,%eax                      
  108a68:	75 5d                	jne    108ac7 <pthread_cancel+0x73>   <== NEVER TAKEN
    return EPROTO;                                                    
                                                                      
  the_thread = _Thread_Get( thread, &location );                      
  108a6a:	52                   	push   %edx                           
  108a6b:	52                   	push   %edx                           
  108a6c:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  108a6f:	50                   	push   %eax                           
  108a70:	ff 75 08             	pushl  0x8(%ebp)                      
  108a73:	e8 74 2d 00 00       	call   10b7ec <_Thread_Get>           
  108a78:	89 c6                	mov    %eax,%esi                      
  switch ( location ) {                                               
  108a7a:	83 c4 10             	add    $0x10,%esp                     
  108a7d:	ba 16 00 00 00       	mov    $0x16,%edx                     
  108a82:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  108a86:	75 3f                	jne    108ac7 <pthread_cancel+0x73>   <== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
  108a88:	8b 80 f8 00 00 00    	mov    0xf8(%eax),%eax                
                                                                      
      thread_support->cancelation_requested = 1;                      
  108a8e:	c7 80 d4 00 00 00 01 	movl   $0x1,0xd4(%eax)                
  108a95:	00 00 00                                                    
                                                                      
      if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
  108a98:	31 db                	xor    %ebx,%ebx                      
  108a9a:	83 b8 cc 00 00 00 00 	cmpl   $0x0,0xcc(%eax)                
  108aa1:	75 0a                	jne    108aad <pthread_cancel+0x59>   <== NEVER TAKEN
  108aa3:	83 b8 d0 00 00 00 01 	cmpl   $0x1,0xd0(%eax)                
  108aaa:	0f 94 c3             	sete   %bl                            
          thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS)
        cancel = true;                                                
                                                                      
      _Thread_Enable_dispatch();                                      
  108aad:	e8 1a 2d 00 00       	call   10b7cc <_Thread_Enable_dispatch>
      if ( cancel )                                                   
  108ab2:	31 d2                	xor    %edx,%edx                      
  108ab4:	84 db                	test   %bl,%bl                        
  108ab6:	74 0f                	je     108ac7 <pthread_cancel+0x73>   
        _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );           
  108ab8:	50                   	push   %eax                           
  108ab9:	50                   	push   %eax                           
  108aba:	6a ff                	push   $0xffffffff                    
  108abc:	56                   	push   %esi                           
  108abd:	e8 a2 02 00 00       	call   108d64 <_POSIX_Thread_Exit>    
  108ac2:	31 d2                	xor    %edx,%edx                      
  108ac4:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
  108ac7:	89 d0                	mov    %edx,%eax                      
  108ac9:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108acc:	5b                   	pop    %ebx                           
  108acd:	5e                   	pop    %esi                           
  108ace:	c9                   	leave                                 
  108acf:	c3                   	ret                                   
                                                                      

00108ed4 <pthread_cleanup_pop>: */ void pthread_cleanup_pop( int execute ) {
  108ed4:	55                   	push   %ebp                           
  108ed5:	89 e5                	mov    %esp,%ebp                      
  108ed7:	57                   	push   %edi                           
  108ed8:	56                   	push   %esi                           
  108ed9:	53                   	push   %ebx                           
  108eda:	83 ec 1c             	sub    $0x1c,%esp                     
  108edd:	8b 45 08             	mov    0x8(%ebp),%eax                 
  108ee0:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  POSIX_Cancel_Handler_control      tmp_handler;                      
  Chain_Control                     *handler_stack;                   
  POSIX_API_Control                 *thread_support;                  
  ISR_Level                          level;                           
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
  108ee3:	a1 40 0d 12 00       	mov    0x120d40,%eax                  
  108ee8:	8b 90 f8 00 00 00    	mov    0xf8(%eax),%edx                
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  108eee:	a1 80 0c 12 00       	mov    0x120c80,%eax                  
  108ef3:	40                   	inc    %eax                           
  108ef4:	a3 80 0c 12 00       	mov    %eax,0x120c80                  
   * ensure that we do not get prempted and deleted while we are holding
   * memory that needs to be freed.                                   
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
  _ISR_Disable( level );                                              
  108ef9:	9c                   	pushf                                 
  108efa:	fa                   	cli                                   
  108efb:	5f                   	pop    %edi                           
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  108efc:	8d 82 dc 00 00 00    	lea    0xdc(%edx),%eax                
                                                                      
    if ( _Chain_Is_empty( handler_stack ) ) {                         
  108f02:	39 82 d8 00 00 00    	cmp    %eax,0xd8(%edx)                
  108f08:	75 09                	jne    108f13 <pthread_cleanup_pop+0x3f>
      _Thread_Enable_dispatch();                                      
  108f0a:	e8 29 30 00 00       	call   10bf38 <_Thread_Enable_dispatch>
      _ISR_Enable( level );                                           
  108f0f:	57                   	push   %edi                           
  108f10:	9d                   	popf                                  
  108f11:	eb 4c                	jmp    108f5f <pthread_cleanup_pop+0x8b>
      return;                                                         
    }                                                                 
                                                                      
    handler = (POSIX_Cancel_Handler_control *)                        
  108f13:	8b 40 04             	mov    0x4(%eax),%eax                 
  108f16:	89 45 d8             	mov    %eax,-0x28(%ebp)               
  108f19:	8b 10                	mov    (%eax),%edx                    
  108f1b:	8b 40 04             	mov    0x4(%eax),%eax                 
  108f1e:	89 42 04             	mov    %eax,0x4(%edx)                 
  108f21:	89 10                	mov    %edx,(%eax)                    
        _Chain_Tail( handler_stack )->previous;                       
    _Chain_Extract_unprotected( &handler->Node );                     
                                                                      
  _ISR_Enable( level );                                               
  108f23:	57                   	push   %edi                           
  108f24:	9d                   	popf                                  
                                                                      
  tmp_handler = *handler;                                             
  108f25:	8d 7d e4             	lea    -0x1c(%ebp),%edi               
  108f28:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  108f2d:	8b 75 d8             	mov    -0x28(%ebp),%esi               
  108f30:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  108f32:	8b 5d ec             	mov    -0x14(%ebp),%ebx               
  108f35:	8b 7d f0             	mov    -0x10(%ebp),%edi               
                                                                      
  _Workspace_Free( handler );                                         
  108f38:	83 ec 0c             	sub    $0xc,%esp                      
  108f3b:	ff 75 d8             	pushl  -0x28(%ebp)                    
  108f3e:	e8 0d 40 00 00       	call   10cf50 <_Workspace_Free>       
                                                                      
  _Thread_Enable_dispatch();                                          
  108f43:	e8 f0 2f 00 00       	call   10bf38 <_Thread_Enable_dispatch>
                                                                      
  if ( execute )                                                      
  108f48:	83 c4 10             	add    $0x10,%esp                     
  108f4b:	83 7d e0 00          	cmpl   $0x0,-0x20(%ebp)               
  108f4f:	74 0e                	je     108f5f <pthread_cleanup_pop+0x8b><== NEVER TAKEN
    (*tmp_handler.routine)( tmp_handler.arg );                        
  108f51:	89 7d 08             	mov    %edi,0x8(%ebp)                 
  108f54:	89 d9                	mov    %ebx,%ecx                      
}                                                                     
  108f56:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108f59:	5b                   	pop    %ebx                           
  108f5a:	5e                   	pop    %esi                           
  108f5b:	5f                   	pop    %edi                           
  108f5c:	c9                   	leave                                 
  _Workspace_Free( handler );                                         
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  if ( execute )                                                      
    (*tmp_handler.routine)( tmp_handler.arg );                        
  108f5d:	ff e1                	jmp    *%ecx                          
}                                                                     
  108f5f:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108f62:	5b                   	pop    %ebx                           
  108f63:	5e                   	pop    %esi                           
  108f64:	5f                   	pop    %edi                           
  108f65:	c9                   	leave                                 
  108f66:	c3                   	ret                                   
                                                                      

00108f68 <pthread_cleanup_push>: void pthread_cleanup_push( void (*routine)( void * ), void *arg ) {
  108f68:	55                   	push   %ebp                           
  108f69:	89 e5                	mov    %esp,%ebp                      
  108f6b:	56                   	push   %esi                           
  108f6c:	53                   	push   %ebx                           
  108f6d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  108f70:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  /*                                                                  
   *  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 )                                                     
  108f73:	85 db                	test   %ebx,%ebx                      
  108f75:	74 4b                	je     108fc2 <pthread_cleanup_push+0x5a>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  108f77:	a1 80 0c 12 00       	mov    0x120c80,%eax                  
  108f7c:	40                   	inc    %eax                           
  108f7d:	a3 80 0c 12 00       	mov    %eax,0x120c80                  
    return;                                                           
                                                                      
  _Thread_Disable_dispatch();                                         
  handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
  108f82:	83 ec 0c             	sub    $0xc,%esp                      
  108f85:	6a 10                	push   $0x10                          
  108f87:	e8 d9 3f 00 00       	call   10cf65 <_Workspace_Allocate>   
  108f8c:	89 c2                	mov    %eax,%edx                      
                                                                      
  if ( handler ) {                                                    
  108f8e:	83 c4 10             	add    $0x10,%esp                     
  108f91:	85 c0                	test   %eax,%eax                      
  108f93:	74 22                	je     108fb7 <pthread_cleanup_push+0x4f><== NEVER TAKEN
    thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
                                                                      
    handler_stack = &thread_support->Cancellation_Handlers;           
  108f95:	a1 40 0d 12 00       	mov    0x120d40,%eax                  
  108f9a:	8b 80 f8 00 00 00    	mov    0xf8(%eax),%eax                
  108fa0:	05 d8 00 00 00       	add    $0xd8,%eax                     
                                                                      
    handler->routine = routine;                                       
  108fa5:	89 5a 08             	mov    %ebx,0x8(%edx)                 
    handler->arg = arg;                                               
  108fa8:	89 72 0c             	mov    %esi,0xc(%edx)                 
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
  108fab:	51                   	push   %ecx                           
  108fac:	51                   	push   %ecx                           
  108fad:	52                   	push   %edx                           
  108fae:	50                   	push   %eax                           
  108faf:	e8 e4 1b 00 00       	call   10ab98 <_Chain_Append>         
  108fb4:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
  _Thread_Enable_dispatch();                                          
}                                                                     
  108fb7:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108fba:	5b                   	pop    %ebx                           
  108fbb:	5e                   	pop    %esi                           
  108fbc:	c9                   	leave                                 
    handler->routine = routine;                                       
    handler->arg = arg;                                               
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
  }                                                                   
  _Thread_Enable_dispatch();                                          
  108fbd:	e9 76 2f 00 00       	jmp    10bf38 <_Thread_Enable_dispatch>
}                                                                     
  108fc2:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108fc5:	5b                   	pop    %ebx                           
  108fc6:	5e                   	pop    %esi                           
  108fc7:	c9                   	leave                                 
  108fc8:	c3                   	ret                                   
                                                                      

00109a98 <pthread_cond_init>: int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) {
  109a98:	55                   	push   %ebp                           
  109a99:	89 e5                	mov    %esp,%ebp                      
  109a9b:	56                   	push   %esi                           
  109a9c:	53                   	push   %ebx                           
  109a9d:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  POSIX_Condition_variables_Control   *the_cond;                      
  const pthread_condattr_t            *the_attr;                      
                                                                      
  if ( attr ) the_attr = attr;                                        
  109aa0:	be c8 a8 11 00       	mov    $0x11a8c8,%esi                 
  109aa5:	85 c0                	test   %eax,%eax                      
  109aa7:	74 02                	je     109aab <pthread_cond_init+0x13>
  109aa9:	89 c6                	mov    %eax,%esi                      
                                                                      
  /*                                                                  
   *  Be careful about attributes when global!!!                      
   */                                                                 
                                                                      
  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )           
  109aab:	83 7e 04 01          	cmpl   $0x1,0x4(%esi)                 
  109aaf:	74 77                	je     109b28 <pthread_cond_init+0x90><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  if ( !the_attr->is_initialized )                                    
  109ab1:	83 3e 00             	cmpl   $0x0,(%esi)                    
  109ab4:	74 72                	je     109b28 <pthread_cond_init+0x90>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109ab6:	a1 60 10 12 00       	mov    0x121060,%eax                  
  109abb:	40                   	inc    %eax                           
  109abc:	a3 60 10 12 00       	mov    %eax,0x121060                  
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
  109ac1:	83 ec 0c             	sub    $0xc,%esp                      
  109ac4:	68 d4 14 12 00       	push   $0x1214d4                      
  109ac9:	e8 b6 24 00 00       	call   10bf84 <_Objects_Allocate>     
  109ace:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_cond = _POSIX_Condition_variables_Allocate();                   
                                                                      
  if ( !the_cond ) {                                                  
  109ad0:	83 c4 10             	add    $0x10,%esp                     
  109ad3:	85 c0                	test   %eax,%eax                      
  109ad5:	75 0c                	jne    109ae3 <pthread_cond_init+0x4b>
    _Thread_Enable_dispatch();                                        
  109ad7:	e8 ac 30 00 00       	call   10cb88 <_Thread_Enable_dispatch>
  109adc:	b8 0c 00 00 00       	mov    $0xc,%eax                      
  109ae1:	eb 4a                	jmp    109b2d <pthread_cond_init+0x95>
    return ENOMEM;                                                    
  }                                                                   
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
  109ae3:	8b 46 04             	mov    0x4(%esi),%eax                 
  109ae6:	89 43 10             	mov    %eax,0x10(%ebx)                
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
  109ae9:	c7 43 14 00 00 00 00 	movl   $0x0,0x14(%ebx)                
                                                                      
/* XXX some more initialization might need to go here */              
  _Thread_queue_Initialize(                                           
  109af0:	6a 74                	push   $0x74                          
  109af2:	68 00 08 00 00       	push   $0x800                         
  109af7:	6a 00                	push   $0x0                           
  109af9:	8d 43 18             	lea    0x18(%ebx),%eax                
  109afc:	50                   	push   %eax                           
  109afd:	e8 56 37 00 00       	call   10d258 <_Thread_queue_Initialize>
  109b02:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  109b05:	0f b7 d1             	movzwl %cx,%edx                       
  109b08:	a1 f0 14 12 00       	mov    0x1214f0,%eax                  
  109b0d:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  109b10:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
    &_POSIX_Condition_variables_Information,                          
    &the_cond->Object,                                                
    0                                                                 
  );                                                                  
                                                                      
  *cond = the_cond->Object.id;                                        
  109b17:	8b 45 08             	mov    0x8(%ebp),%eax                 
  109b1a:	89 08                	mov    %ecx,(%eax)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  109b1c:	e8 67 30 00 00       	call   10cb88 <_Thread_Enable_dispatch>
  109b21:	31 c0                	xor    %eax,%eax                      
  109b23:	83 c4 10             	add    $0x10,%esp                     
  109b26:	eb 05                	jmp    109b2d <pthread_cond_init+0x95>
                                                                      
  return 0;                                                           
  109b28:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  109b2d:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  109b30:	5b                   	pop    %ebx                           
  109b31:	5e                   	pop    %esi                           
  109b32:	c9                   	leave                                 
  109b33:	c3                   	ret                                   
                                                                      

00109950 <pthread_condattr_destroy>: */ int pthread_condattr_destroy( pthread_condattr_t *attr ) {
  109950:	55                   	push   %ebp                           
  109951:	89 e5                	mov    %esp,%ebp                      
  109953:	8b 45 08             	mov    0x8(%ebp),%eax                 
  if ( !attr || attr->is_initialized == FALSE )                       
  109956:	85 c0                	test   %eax,%eax                      
  109958:	74 0f                	je     109969 <pthread_condattr_destroy+0x19>
  10995a:	83 38 00             	cmpl   $0x0,(%eax)                    
  10995d:	74 0a                	je     109969 <pthread_condattr_destroy+0x19><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  attr->is_initialized = FALSE;                                       
  10995f:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    
  109965:	31 c0                	xor    %eax,%eax                      
  109967:	eb 05                	jmp    10996e <pthread_condattr_destroy+0x1e>
  return 0;                                                           
  109969:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  10996e:	c9                   	leave                                 
  10996f:	c3                   	ret                                   
                                                                      

00109a24 <pthread_create>: pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) {
  109a24:	55                   	push   %ebp                           
  109a25:	89 e5                	mov    %esp,%ebp                      
  109a27:	57                   	push   %edi                           
  109a28:	56                   	push   %esi                           
  109a29:	53                   	push   %ebx                           
  109a2a:	83 ec 2c             	sub    $0x2c,%esp                     
  109a2d:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  POSIX_API_Control                  *api;                            
  int                                 schedpolicy = SCHED_RR;         
  struct sched_param                  schedparam;                     
  Objects_Name                        name;                           
                                                                      
  if ( !start_routine )                                               
  109a30:	b8 0e 00 00 00       	mov    $0xe,%eax                      
  109a35:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  109a39:	0f 84 6e 02 00 00    	je     109cad <pthread_create+0x289>  
    return EFAULT;                                                    
                                                                      
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;      
  109a3f:	c7 45 c8 4c a9 11 00 	movl   $0x11a94c,-0x38(%ebp)          
  109a46:	85 f6                	test   %esi,%esi                      
  109a48:	74 03                	je     109a4d <pthread_create+0x29>   
  109a4a:	89 75 c8             	mov    %esi,-0x38(%ebp)               
                                                                      
  if ( !the_attr->is_initialized )                                    
  109a4d:	8b 45 c8             	mov    -0x38(%ebp),%eax               
  109a50:	83 38 00             	cmpl   $0x0,(%eax)                    
  109a53:	0f 84 4f 02 00 00    	je     109ca8 <pthread_create+0x284>  
   *  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) )
  109a59:	83 78 04 00          	cmpl   $0x0,0x4(%eax)                 
  109a5d:	74 0f                	je     109a6e <pthread_create+0x4a>   
  109a5f:	8b 40 08             	mov    0x8(%eax),%eax                 
  109a62:	3b 05 00 cd 11 00    	cmp    0x11cd00,%eax                  
  109a68:	0f 82 3a 02 00 00    	jb     109ca8 <pthread_create+0x284>  <== ALWAYS TAKEN
   *  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 ) {                                 
  109a6e:	8b 55 c8             	mov    -0x38(%ebp),%edx               
  109a71:	8b 42 10             	mov    0x10(%edx),%eax                
  109a74:	83 f8 01             	cmp    $0x1,%eax                      
  109a77:	74 0b                	je     109a84 <pthread_create+0x60>   
  109a79:	83 f8 02             	cmp    $0x2,%eax                      
  109a7c:	0f 85 26 02 00 00    	jne    109ca8 <pthread_create+0x284>  
  109a82:	eb 1c                	jmp    109aa0 <pthread_create+0x7c>   
    case PTHREAD_INHERIT_SCHED:                                       
      api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];    
  109a84:	a1 b0 11 12 00       	mov    0x1211b0,%eax                  
  109a89:	8b 80 f8 00 00 00    	mov    0xf8(%eax),%eax                
      schedpolicy = api->schedpolicy;                                 
  109a8f:	8b 50 7c             	mov    0x7c(%eax),%edx                
  109a92:	89 55 d0             	mov    %edx,-0x30(%ebp)               
      schedparam  = api->schedparam;                                  
  109a95:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  109a98:	8d b0 80 00 00 00    	lea    0x80(%eax),%esi                
  109a9e:	eb 12                	jmp    109ab2 <pthread_create+0x8e>   
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
  109aa0:	8b 45 c8             	mov    -0x38(%ebp),%eax               
  109aa3:	8b 40 14             	mov    0x14(%eax),%eax                
  109aa6:	89 45 d0             	mov    %eax,-0x30(%ebp)               
      schedparam  = the_attr->schedparam;                             
  109aa9:	8d 7d dc             	lea    -0x24(%ebp),%edi               
  109aac:	8b 75 c8             	mov    -0x38(%ebp),%esi               
  109aaf:	83 c6 18             	add    $0x18,%esi                     
  109ab2:	b9 06 00 00 00       	mov    $0x6,%ecx                      
  109ab7:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  /*                                                                  
   *  Check the contentionscope since rtems only supports PROCESS wide
   *  contention (i.e. no system wide contention).                    
   */                                                                 
                                                                      
  if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )           
  109ab9:	b8 86 00 00 00       	mov    $0x86,%eax                     
  109abe:	8b 55 c8             	mov    -0x38(%ebp),%edx               
  109ac1:	83 7a 0c 00          	cmpl   $0x0,0xc(%edx)                 
  109ac5:	0f 85 e2 01 00 00    	jne    109cad <pthread_create+0x289>  
                                                                      
  /*                                                                  
   *  Interpret the scheduling parameters.                            
   */                                                                 
                                                                      
  if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )       
  109acb:	8b 7d dc             	mov    -0x24(%ebp),%edi               
  109ace:	8d 47 ff             	lea    -0x1(%edi),%eax                
  109ad1:	3d fd 00 00 00       	cmp    $0xfd,%eax                     
  109ad6:	0f 87 cc 01 00 00    	ja     109ca8 <pthread_create+0x284>  <== NEVER TAKEN
   */                                                                 
                                                                      
  budget_callout = NULL;                                              
  budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;                
                                                                      
  switch ( schedpolicy ) {                                            
  109adc:	83 7d d0 01          	cmpl   $0x1,-0x30(%ebp)               
  109ae0:	74 24                	je     109b06 <pthread_create+0xe2>   
  109ae2:	7f 10                	jg     109af4 <pthread_create+0xd0>   
  109ae4:	be 01 00 00 00       	mov    $0x1,%esi                      
  109ae9:	83 7d d0 00          	cmpl   $0x0,-0x30(%ebp)               
  109aed:	74 19                	je     109b08 <pthread_create+0xe4>   
  109aef:	e9 b4 01 00 00       	jmp    109ca8 <pthread_create+0x284>  
  109af4:	83 7d d0 02          	cmpl   $0x2,-0x30(%ebp)               
  109af8:	74 12                	je     109b0c <pthread_create+0xe8>   <== NEVER TAKEN
  109afa:	83 7d d0 03          	cmpl   $0x3,-0x30(%ebp)               
  109afe:	0f 85 a4 01 00 00    	jne    109ca8 <pthread_create+0x284>  <== NEVER TAKEN
  109b04:	eb 0d                	jmp    109b13 <pthread_create+0xef>   
  109b06:	31 f6                	xor    %esi,%esi                      
  109b08:	31 db                	xor    %ebx,%ebx                      
  109b0a:	eb 44                	jmp    109b50 <pthread_create+0x12c>  
  109b0c:	be 02 00 00 00       	mov    $0x2,%esi                      <== NOT EXECUTED
  109b11:	eb f5                	jmp    109b08 <pthread_create+0xe4>   <== NOT EXECUTED
                                                                      
    case SCHED_SPORADIC:                                              
      budget_algorithm  = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;        
      budget_callout = _POSIX_Threads_Sporadic_budget_callout;        
                                                                      
      if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) <    
  109b13:	83 ec 0c             	sub    $0xc,%esp                      
  109b16:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  109b19:	50                   	push   %eax                           
  109b1a:	e8 6d 39 00 00       	call   10d48c <_Timespec_To_ticks>    
  109b1f:	89 c3                	mov    %eax,%ebx                      
  109b21:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  109b24:	89 04 24             	mov    %eax,(%esp)                    
  109b27:	e8 60 39 00 00       	call   10d48c <_Timespec_To_ticks>    
  109b2c:	83 c4 10             	add    $0x10,%esp                     
  109b2f:	39 c3                	cmp    %eax,%ebx                      
  109b31:	0f 82 71 01 00 00    	jb     109ca8 <pthread_create+0x284>  <== NEVER TAKEN
           _Timespec_To_ticks( &schedparam.ss_initial_budget ) )      
        return EINVAL;                                                
                                                                      
      if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) )  
  109b37:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  109b3a:	48                   	dec    %eax                           
  109b3b:	3d fd 00 00 00       	cmp    $0xfd,%eax                     
  109b40:	0f 87 62 01 00 00    	ja     109ca8 <pthread_create+0x284>  <== NEVER TAKEN
  109b46:	be 03 00 00 00       	mov    $0x3,%esi                      
  109b4b:	bb e8 9f 10 00       	mov    $0x109fe8,%ebx                 
#endif                                                                
                                                                      
  /*                                                                  
   *  Lock the allocator mutex for protection                         
   */                                                                 
  _RTEMS_Lock_allocator();                                            
  109b50:	83 ec 0c             	sub    $0xc,%esp                      
  109b53:	ff 35 a8 11 12 00    	pushl  0x1211a8                       
  109b59:	e8 5e 18 00 00       	call   10b3bc <_API_Mutex_Lock>       
 *  It is a simple wrapper for the help with the addition of the      
 *  allocation mutex being used for protection.                       
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
  109b5e:	c7 04 24 60 13 12 00 	movl   $0x121360,(%esp)               
  109b65:	e8 12 21 00 00       	call   10bc7c <_Objects_Allocate>     
  109b6a:	89 45 cc             	mov    %eax,-0x34(%ebp)               
   *  NOTE:  Global threads are not currently supported.              
   */                                                                 
                                                                      
  the_thread = _POSIX_Threads_Allocate();                             
                                                                      
  if ( !the_thread ) {                                                
  109b6d:	83 c4 10             	add    $0x10,%esp                     
  109b70:	85 c0                	test   %eax,%eax                      
  109b72:	75 05                	jne    109b79 <pthread_create+0x155>  
    _RTEMS_Unlock_allocator();                                        
  109b74:	83 ec 0c             	sub    $0xc,%esp                      
  109b77:	eb 51                	jmp    109bca <pthread_create+0x1a6>  
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
                                                                      
  name.name_p = NULL;   /* posix threads don't have a name by default */
  status = _Thread_Initialize(                                        
  109b79:	8b 45 c8             	mov    -0x38(%ebp),%eax               
  109b7c:	8b 50 08             	mov    0x8(%eax),%edx                 
  109b7f:	50                   	push   %eax                           
  109b80:	6a 00                	push   $0x0                           
  109b82:	6a 00                	push   $0x0                           
  109b84:	53                   	push   %ebx                           
  109b85:	56                   	push   %esi                           
  109b86:	6a 01                	push   $0x1                           
  109b88:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  109b8d:	29 f8                	sub    %edi,%eax                      
  109b8f:	50                   	push   %eax                           
  109b90:	6a 01                	push   $0x1                           
  109b92:	a1 00 cd 11 00       	mov    0x11cd00,%eax                  
  109b97:	d1 e0                	shl    %eax                           
  109b99:	39 d0                	cmp    %edx,%eax                      
  109b9b:	73 02                	jae    109b9f <pthread_create+0x17b>  
  109b9d:	89 d0                	mov    %edx,%eax                      
  109b9f:	50                   	push   %eax                           
  109ba0:	8b 55 c8             	mov    -0x38(%ebp),%edx               
  109ba3:	ff 72 04             	pushl  0x4(%edx)                      
  109ba6:	ff 75 cc             	pushl  -0x34(%ebp)                    
  109ba9:	68 60 13 12 00       	push   $0x121360                      
  109bae:	e8 91 2d 00 00       	call   10c944 <_Thread_Initialize>    
    budget_callout,                                                   
    0,                    /* isr level */                             
    name                  /* posix threads don't have a name */       
  );                                                                  
                                                                      
  if ( !status ) {                                                    
  109bb3:	83 c4 30             	add    $0x30,%esp                     
  109bb6:	84 c0                	test   %al,%al                        
  109bb8:	75 25                	jne    109bdf <pthread_create+0x1bb>  
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
  109bba:	50                   	push   %eax                           
  109bbb:	50                   	push   %eax                           
  109bbc:	ff 75 cc             	pushl  -0x34(%ebp)                    
  109bbf:	68 60 13 12 00       	push   $0x121360                      
  109bc4:	e8 c3 23 00 00       	call   10bf8c <_Objects_Free>         
    _POSIX_Threads_Free( the_thread );                                
    _RTEMS_Unlock_allocator();                                        
  109bc9:	58                   	pop    %eax                           
  109bca:	ff 35 a8 11 12 00    	pushl  0x1211a8                       
  109bd0:	e8 2f 18 00 00       	call   10b404 <_API_Mutex_Unlock>     
  109bd5:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  109bda:	e9 c4 00 00 00       	jmp    109ca3 <pthread_create+0x27f>  
  /*                                                                  
   *  finish initializing the per API structure                       
   */                                                                 
                                                                      
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  109bdf:	8b 45 cc             	mov    -0x34(%ebp),%eax               
  109be2:	8b 98 f8 00 00 00    	mov    0xf8(%eax),%ebx                
                                                                      
  api->Attributes  = *the_attr;                                       
  109be8:	b9 0e 00 00 00       	mov    $0xe,%ecx                      
  109bed:	89 df                	mov    %ebx,%edi                      
  109bef:	8b 75 c8             	mov    -0x38(%ebp),%esi               
  109bf2:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  api->detachstate = the_attr->detachstate;                           
  109bf4:	8b 55 c8             	mov    -0x38(%ebp),%edx               
  109bf7:	8b 42 34             	mov    0x34(%edx),%eax                
  109bfa:	89 43 38             	mov    %eax,0x38(%ebx)                
  api->schedpolicy = schedpolicy;                                     
  109bfd:	8b 45 d0             	mov    -0x30(%ebp),%eax               
  109c00:	89 43 7c             	mov    %eax,0x7c(%ebx)                
  api->schedparam  = schedparam;                                      
  109c03:	8d bb 80 00 00 00    	lea    0x80(%ebx),%edi                
  109c09:	8d 75 dc             	lea    -0x24(%ebp),%esi               
  109c0c:	b1 06                	mov    $0x6,%cl                       
  109c0e:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
   *  first run.                                                      
   *                                                                  
   *  NOTE:  Since the thread starts with all unblocked, this is necessary.
   */                                                                 
                                                                      
  the_thread->do_post_task_switch_extension = true;                   
  109c10:	8b 55 cc             	mov    -0x34(%ebp),%edx               
  109c13:	c6 42 75 01          	movb   $0x1,0x75(%edx)                
                                                                      
  /*                                                                  
   *  POSIX threads are allocated and started in one operation.       
   */                                                                 
                                                                      
  status = _Thread_Start(                                             
  109c17:	83 ec 0c             	sub    $0xc,%esp                      
  109c1a:	6a 00                	push   $0x0                           
  109c1c:	ff 75 14             	pushl  0x14(%ebp)                     
  109c1f:	ff 75 10             	pushl  0x10(%ebp)                     
  109c22:	6a 01                	push   $0x1                           
  109c24:	52                   	push   %edx                           
  109c25:	e8 8a 36 00 00       	call   10d2b4 <_Thread_Start>         
  109c2a:	89 c6                	mov    %eax,%esi                      
    start_routine,                                                    
    arg,                                                              
    0                     /* unused */                                
  );                                                                  
                                                                      
  if ( schedpolicy == SCHED_SPORADIC ) {                              
  109c2c:	83 c4 20             	add    $0x20,%esp                     
  109c2f:	83 7d d0 03          	cmpl   $0x3,-0x30(%ebp)               
  109c33:	75 2b                	jne    109c60 <pthread_create+0x23c>  
    _Watchdog_Insert_ticks(                                           
  109c35:	83 ec 0c             	sub    $0xc,%esp                      
  109c38:	8d 83 88 00 00 00    	lea    0x88(%ebx),%eax                
  109c3e:	50                   	push   %eax                           
  109c3f:	e8 48 38 00 00       	call   10d48c <_Timespec_To_ticks>    
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  109c44:	89 83 a8 00 00 00    	mov    %eax,0xa8(%ebx)                
  void                *starting_address,                              
  size_t              *size                                           
  109c4a:	59                   	pop    %ecx                           
  109c4b:	5f                   	pop    %edi                           
  109c4c:	8d 83 9c 00 00 00    	lea    0x9c(%ebx),%eax                
  109c52:	50                   	push   %eax                           
  109c53:	68 d0 11 12 00       	push   $0x1211d0                      
  109c58:	e8 37 3b 00 00       	call   10d794 <_Watchdog_Insert>      
  109c5d:	83 c4 10             	add    $0x10,%esp                     
   *                                                                  
   *  NOTE: This can only happen if someone slips in and touches the  
   *        thread while we are creating it.                          
   */                                                                 
                                                                      
  if ( !status ) {                                                    
  109c60:	89 f0                	mov    %esi,%eax                      
  109c62:	84 c0                	test   %al,%al                        
  109c64:	75 22                	jne    109c88 <pthread_create+0x264>  <== ALWAYS TAKEN
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
  109c66:	52                   	push   %edx                           <== NOT EXECUTED
  109c67:	52                   	push   %edx                           <== NOT EXECUTED
  109c68:	ff 75 cc             	pushl  -0x34(%ebp)                    <== NOT EXECUTED
  109c6b:	68 60 13 12 00       	push   $0x121360                      <== NOT EXECUTED
  109c70:	e8 17 23 00 00       	call   10bf8c <_Objects_Free>         <== NOT EXECUTED
    _POSIX_Threads_Free( the_thread );                                
    _RTEMS_Unlock_allocator();                                        
  109c75:	58                   	pop    %eax                           <== NOT EXECUTED
  109c76:	ff 35 a8 11 12 00    	pushl  0x1211a8                       <== NOT EXECUTED
  109c7c:	e8 83 17 00 00       	call   10b404 <_API_Mutex_Unlock>     <== NOT EXECUTED
  109c81:	b8 16 00 00 00       	mov    $0x16,%eax                     <== NOT EXECUTED
  109c86:	eb 1b                	jmp    109ca3 <pthread_create+0x27f>  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Return the id and indicate we successfully created the thread   
   */                                                                 
                                                                      
  *thread = the_thread->Object.id;                                    
  109c88:	8b 45 cc             	mov    -0x34(%ebp),%eax               
  109c8b:	8b 50 08             	mov    0x8(%eax),%edx                 
  109c8e:	8b 45 08             	mov    0x8(%ebp),%eax                 
  109c91:	89 10                	mov    %edx,(%eax)                    
                                                                      
  _RTEMS_Unlock_allocator();                                          
  109c93:	83 ec 0c             	sub    $0xc,%esp                      
  109c96:	ff 35 a8 11 12 00    	pushl  0x1211a8                       
  109c9c:	e8 63 17 00 00       	call   10b404 <_API_Mutex_Unlock>     
  109ca1:	31 c0                	xor    %eax,%eax                      
  109ca3:	83 c4 10             	add    $0x10,%esp                     
  109ca6:	eb 05                	jmp    109cad <pthread_create+0x289>  
  return 0;                                                           
  109ca8:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  109cad:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109cb0:	5b                   	pop    %ebx                           
  109cb1:	5e                   	pop    %esi                           
  109cb2:	5f                   	pop    %edi                           
  109cb3:	c9                   	leave                                 
  109cb4:	c3                   	ret                                   
                                                                      

0010ecb8 <pthread_exit>: } void pthread_exit( void *value_ptr ) {
  10ecb8:	55                   	push   %ebp                           
  10ecb9:	89 e5                	mov    %esp,%ebp                      
  10ecbb:	83 ec 10             	sub    $0x10,%esp                     
  _POSIX_Thread_Exit( _Thread_Executing, value_ptr );                 
  10ecbe:	ff 75 08             	pushl  0x8(%ebp)                      
  10ecc1:	ff 35 58 d8 11 00    	pushl  0x11d858                       
  10ecc7:	e8 88 ff ff ff       	call   10ec54 <_POSIX_Thread_Exit>    
  10eccc:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
}                                                                     
  10eccf:	c9                   	leave                                 <== NOT EXECUTED
  10ecd0:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010aecc <pthread_getschedparam>: int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) {
  10aecc:	55                   	push   %ebp                           
  10aecd:	89 e5                	mov    %esp,%ebp                      
  10aecf:	57                   	push   %edi                           
  10aed0:	56                   	push   %esi                           
  10aed1:	53                   	push   %ebx                           
  10aed2:	83 ec 1c             	sub    $0x1c,%esp                     
  10aed5:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Objects_Locations        location;                                  
  POSIX_API_Control       *api;                                       
  register Thread_Control *the_thread;                                
                                                                      
  if ( !policy || !param  )                                           
  10aed8:	85 f6                	test   %esi,%esi                      
  10aeda:	74 06                	je     10aee2 <pthread_getschedparam+0x16>
  10aedc:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  10aee0:	75 07                	jne    10aee9 <pthread_getschedparam+0x1d>
  10aee2:	b8 16 00 00 00       	mov    $0x16,%eax                     
  10aee7:	eb 4d                	jmp    10af36 <pthread_getschedparam+0x6a>
    return EINVAL;                                                    
                                                                      
  the_thread = _Thread_Get( thread, &location );                      
  10aee9:	50                   	push   %eax                           
  10aeea:	50                   	push   %eax                           
  10aeeb:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10aeee:	50                   	push   %eax                           
  10aeef:	ff 75 08             	pushl  0x8(%ebp)                      
  10aef2:	e8 4d 2a 00 00       	call   10d944 <_Thread_Get>           
  10aef7:	89 c3                	mov    %eax,%ebx                      
  switch ( location ) {                                               
  10aef9:	83 c4 10             	add    $0x10,%esp                     
  10aefc:	b8 03 00 00 00       	mov    $0x3,%eax                      
  10af01:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10af05:	75 2f                	jne    10af36 <pthread_getschedparam+0x6a><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
  10af07:	8b 93 f8 00 00 00    	mov    0xf8(%ebx),%edx                
      if ( policy )                                                   
        *policy = api->schedpolicy;                                   
  10af0d:	8b 42 7c             	mov    0x7c(%edx),%eax                
  10af10:	89 06                	mov    %eax,(%esi)                    
      if ( param ) {                                                  
        *param  = api->schedparam;                                    
  10af12:	8d b2 80 00 00 00    	lea    0x80(%edx),%esi                
  10af18:	b9 06 00 00 00       	mov    $0x6,%ecx                      
  10af1d:	8b 7d 10             	mov    0x10(%ebp),%edi                
  10af20:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
        param->sched_priority =                                       
  10af22:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  10af27:	2b 43 14             	sub    0x14(%ebx),%eax                
  10af2a:	8b 55 10             	mov    0x10(%ebp),%edx                
  10af2d:	89 02                	mov    %eax,(%edx)                    
          _POSIX_Priority_From_core( the_thread->current_priority );  
      }                                                               
      _Thread_Enable_dispatch();                                      
  10af2f:	e8 f0 29 00 00       	call   10d924 <_Thread_Enable_dispatch>
  10af34:	31 c0                	xor    %eax,%eax                      
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
                                                                      
}                                                                     
  10af36:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10af39:	5b                   	pop    %ebx                           
  10af3a:	5e                   	pop    %esi                           
  10af3b:	5f                   	pop    %edi                           
  10af3c:	c9                   	leave                                 
  10af3d:	c3                   	ret                                   
                                                                      

00108ec8 <pthread_key_create>: int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) {
  108ec8:	55                   	push   %ebp                           
  108ec9:	89 e5                	mov    %esp,%ebp                      
  108ecb:	57                   	push   %edi                           
  108ecc:	56                   	push   %esi                           
  108ecd:	53                   	push   %ebx                           
  108ece:	83 ec 18             	sub    $0x18,%esp                     
  108ed1:	a1 a8 00 12 00       	mov    0x1200a8,%eax                  
  108ed6:	40                   	inc    %eax                           
  108ed7:	a3 a8 00 12 00       	mov    %eax,0x1200a8                  
 *  It is a simple wrapper for the help with the addition of the      
 *  allocation mutex being used for protection.                       
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
  108edc:	68 dc 04 12 00       	push   $0x1204dc                      
  108ee1:	e8 7e 21 00 00       	call   10b064 <_Objects_Allocate>     
  108ee6:	89 45 f0             	mov    %eax,-0x10(%ebp)               
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_key = _POSIX_Keys_Allocate();                                   
                                                                      
  if ( !the_key ) {                                                   
  108ee9:	83 c4 10             	add    $0x10,%esp                     
  108eec:	85 c0                	test   %eax,%eax                      
  108eee:	75 0f                	jne    108eff <pthread_key_create+0x37>
    _Thread_Enable_dispatch();                                        
  108ef0:	e8 73 2d 00 00       	call   10bc68 <_Thread_Enable_dispatch>
  108ef5:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  108efa:	e9 c4 00 00 00       	jmp    108fc3 <pthread_key_create+0xfb>
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  the_key->destructor = destructor;                                   
  108eff:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  108f02:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  108f05:	89 42 14             	mov    %eax,0x14(%edx)                
  108f08:	bb 01 00 00 00       	mov    $0x1,%ebx                      
                                                                      
  for ( the_api = 1;                                                  
        the_api <= OBJECTS_APIS_LAST;                                 
        the_api++ ) {                                                 
                                                                      
    if ( _Objects_Information_table[ the_api ] ) {                    
  108f0d:	8b 04 9d 7c 00 12 00 	mov    0x12007c(,%ebx,4),%eax         
  108f14:	85 c0                	test   %eax,%eax                      
  108f16:	74 6e                	je     108f86 <pthread_key_create+0xbe>
            INTERNAL_ERROR_CORE,                                      
            TRUE,                                                     
            INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY    
          );                                                          
      #endif                                                          
      bytes_to_allocate = sizeof( void * ) *                          
  108f18:	8b 40 04             	mov    0x4(%eax),%eax                 
  108f1b:	0f b7 40 10          	movzwl 0x10(%eax),%eax                
  108f1f:	8d 34 85 04 00 00 00 	lea    0x4(,%eax,4),%esi              
        (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);    
      table = _Workspace_Allocate( bytes_to_allocate );               
  108f26:	83 ec 0c             	sub    $0xc,%esp                      
  108f29:	56                   	push   %esi                           
  108f2a:	e8 d2 3d 00 00       	call   10cd01 <_Workspace_Allocate>   
  108f2f:	89 c7                	mov    %eax,%edi                      
      if ( !table ) {                                                 
  108f31:	83 c4 10             	add    $0x10,%esp                     
  108f34:	85 c0                	test   %eax,%eax                      
  108f36:	75 3f                	jne    108f77 <pthread_key_create+0xaf>
        for ( --the_api;                                              
  108f38:	8d 73 ff             	lea    -0x1(%ebx),%esi                
  108f3b:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  108f3e:	8d 5c 98 14          	lea    0x14(%eax,%ebx,4),%ebx         
  108f42:	eb 11                	jmp    108f55 <pthread_key_create+0x8d>
              the_api >= 1;                                           
              the_api-- )                                             
          _Workspace_Free( the_key->Values[ the_api ] );              
  108f44:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108f47:	ff 33                	pushl  (%ebx)                         <== NOT EXECUTED
  108f49:	e8 9e 3d 00 00       	call   10ccec <_Workspace_Free>       <== NOT EXECUTED
        (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);    
      table = _Workspace_Allocate( bytes_to_allocate );               
      if ( !table ) {                                                 
        for ( --the_api;                                              
              the_api >= 1;                                           
              the_api-- )                                             
  108f4e:	4e                   	dec    %esi                           <== NOT EXECUTED
  108f4f:	83 eb 04             	sub    $0x4,%ebx                      <== NOT EXECUTED
  108f52:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
      bytes_to_allocate = sizeof( void * ) *                          
        (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);    
      table = _Workspace_Allocate( bytes_to_allocate );               
      if ( !table ) {                                                 
        for ( --the_api;                                              
              the_api >= 1;                                           
  108f55:	85 f6                	test   %esi,%esi                      
  108f57:	75 eb                	jne    108f44 <pthread_key_create+0x7c><== NEVER TAKEN
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
  108f59:	50                   	push   %eax                           
  108f5a:	50                   	push   %eax                           
  108f5b:	ff 75 f0             	pushl  -0x10(%ebp)                    
  108f5e:	68 dc 04 12 00       	push   $0x1204dc                      
  108f63:	e8 0c 24 00 00       	call   10b374 <_Objects_Free>         
              the_api-- )                                             
          _Workspace_Free( the_key->Values[ the_api ] );              
                                                                      
        _POSIX_Keys_Free( the_key );                                  
        _Thread_Enable_dispatch();                                    
  108f68:	e8 fb 2c 00 00       	call   10bc68 <_Thread_Enable_dispatch>
  108f6d:	b8 0c 00 00 00       	mov    $0xc,%eax                      
  108f72:	83 c4 10             	add    $0x10,%esp                     
  108f75:	eb 4c                	jmp    108fc3 <pthread_key_create+0xfb>
        return ENOMEM;                                                
      }                                                               
                                                                      
      the_key->Values[ the_api ] = table;                             
  108f77:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  108f7a:	89 44 9a 18          	mov    %eax,0x18(%edx,%ebx,4)         
      memset( table, '\0', bytes_to_allocate );                       
  108f7e:	89 f1                	mov    %esi,%ecx                      
  108f80:	31 c0                	xor    %eax,%eax                      
  108f82:	f3 aa                	rep stos %al,%es:(%edi)               
  108f84:	eb 0b                	jmp    108f91 <pthread_key_create+0xc9>
    } else {                                                          
      the_key->Values[ the_api ] = NULL;                              
  108f86:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  108f89:	c7 44 9a 18 00 00 00 	movl   $0x0,0x18(%edx,%ebx,4)         
  108f90:	00                                                          
   *  for.  [NOTE: Currently RTEMS Classic API tasks are always enabled.]
   */                                                                 
                                                                      
  for ( the_api = 1;                                                  
        the_api <= OBJECTS_APIS_LAST;                                 
        the_api++ ) {                                                 
  108f91:	43                   	inc    %ebx                           
   *  APIs are optional.  Thus there may be no ITRON tasks to have keys
   *  for.  [NOTE: Currently RTEMS Classic API tasks are always enabled.]
   */                                                                 
                                                                      
  for ( the_api = 1;                                                  
        the_api <= OBJECTS_APIS_LAST;                                 
  108f92:	83 fb 05             	cmp    $0x5,%ebx                      
  108f95:	0f 85 72 ff ff ff    	jne    108f0d <pthread_key_create+0x45>
    }                                                                 
                                                                      
                                                                      
  }                                                                   
                                                                      
  the_key->is_active = TRUE;                                          
  108f9b:	8b 5d f0             	mov    -0x10(%ebp),%ebx               
  108f9e:	c6 43 10 01          	movb   $0x1,0x10(%ebx)                
  108fa2:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  108fa5:	0f b7 d1             	movzwl %cx,%edx                       
  108fa8:	a1 f8 04 12 00       	mov    0x1204f8,%eax                  
  108fad:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  108fb0:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
                                                                      
  _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); 
                                                                      
  *key = the_key->Object.id;                                          
  108fb7:	8b 45 08             	mov    0x8(%ebp),%eax                 
  108fba:	89 08                	mov    %ecx,(%eax)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  108fbc:	e8 a7 2c 00 00       	call   10bc68 <_Thread_Enable_dispatch>
  108fc1:	31 c0                	xor    %eax,%eax                      
                                                                      
  return 0;                                                           
}                                                                     
  108fc3:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108fc6:	5b                   	pop    %ebx                           
  108fc7:	5e                   	pop    %esi                           
  108fc8:	5f                   	pop    %edi                           
  108fc9:	c9                   	leave                                 
  108fca:	c3                   	ret                                   
                                                                      

00108fcc <pthread_key_delete>: */ int pthread_key_delete( pthread_key_t key ) {
  108fcc:	55                   	push   %ebp                           
  108fcd:	89 e5                	mov    %esp,%ebp                      
  108fcf:	53                   	push   %ebx                           
  108fd0:	83 ec 18             	sub    $0x18,%esp                     
static inline uint32_t _Protected_heap_Initialize(                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size,                                                 
  uint32_t      page_size                                             
)                                                                     
  108fd3:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  108fd6:	50                   	push   %eax                           
  108fd7:	ff 75 08             	pushl  0x8(%ebp)                      
  108fda:	68 dc 04 12 00       	push   $0x1204dc                      
  108fdf:	e8 c4 24 00 00       	call   10b4a8 <_Objects_Get>          
  108fe4:	89 c3                	mov    %eax,%ebx                      
  register POSIX_Keys_Control *the_key;                               
  Objects_Locations            location;                              
  uint32_t                     the_api;                               
                                                                      
  the_key = _POSIX_Keys_Get( key, &location );                        
  switch ( location ) {                                               
  108fe6:	83 c4 10             	add    $0x10,%esp                     
  108fe9:	b8 16 00 00 00       	mov    $0x16,%eax                     
  108fee:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  108ff2:	75 77                	jne    10906b <pthread_key_delete+0x9f><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Close( &_POSIX_Keys_Information, &the_key->Object );   
  108ff4:	52                   	push   %edx                           
  108ff5:	52                   	push   %edx                           
  108ff6:	53                   	push   %ebx                           
  108ff7:	68 dc 04 12 00       	push   $0x1204dc                      
  108ffc:	e8 d7 20 00 00       	call   10b0d8 <_Objects_Close>        
                                                                      
      the_key->is_active = FALSE;                                     
  109001:	c6 43 10 00          	movb   $0x0,0x10(%ebx)                
                                                                      
      for ( the_api = 1;                                              
            the_api <= OBJECTS_APIS_LAST;                             
            the_api++ )                                               
        if ( the_key->Values[ the_api ] )                             
  109005:	8b 43 1c             	mov    0x1c(%ebx),%eax                
  109008:	83 c4 10             	add    $0x10,%esp                     
  10900b:	85 c0                	test   %eax,%eax                      
  10900d:	74 0c                	je     10901b <pthread_key_delete+0x4f><== NEVER TAKEN
          _Workspace_Free( the_key->Values[ the_api ] );              
  10900f:	83 ec 0c             	sub    $0xc,%esp                      
  109012:	50                   	push   %eax                           
  109013:	e8 d4 3c 00 00       	call   10ccec <_Workspace_Free>       
  109018:	83 c4 10             	add    $0x10,%esp                     
      the_key->is_active = FALSE;                                     
                                                                      
      for ( the_api = 1;                                              
            the_api <= OBJECTS_APIS_LAST;                             
            the_api++ )                                               
        if ( the_key->Values[ the_api ] )                             
  10901b:	8b 43 20             	mov    0x20(%ebx),%eax                
  10901e:	85 c0                	test   %eax,%eax                      
  109020:	74 0c                	je     10902e <pthread_key_delete+0x62><== NEVER TAKEN
          _Workspace_Free( the_key->Values[ the_api ] );              
  109022:	83 ec 0c             	sub    $0xc,%esp                      
  109025:	50                   	push   %eax                           
  109026:	e8 c1 3c 00 00       	call   10ccec <_Workspace_Free>       
  10902b:	83 c4 10             	add    $0x10,%esp                     
      the_key->is_active = FALSE;                                     
                                                                      
      for ( the_api = 1;                                              
            the_api <= OBJECTS_APIS_LAST;                             
            the_api++ )                                               
        if ( the_key->Values[ the_api ] )                             
  10902e:	8b 43 24             	mov    0x24(%ebx),%eax                
  109031:	85 c0                	test   %eax,%eax                      
  109033:	74 0c                	je     109041 <pthread_key_delete+0x75><== NEVER TAKEN
          _Workspace_Free( the_key->Values[ the_api ] );              
  109035:	83 ec 0c             	sub    $0xc,%esp                      
  109038:	50                   	push   %eax                           
  109039:	e8 ae 3c 00 00       	call   10ccec <_Workspace_Free>       
  10903e:	83 c4 10             	add    $0x10,%esp                     
      the_key->is_active = FALSE;                                     
                                                                      
      for ( the_api = 1;                                              
            the_api <= OBJECTS_APIS_LAST;                             
            the_api++ )                                               
        if ( the_key->Values[ the_api ] )                             
  109041:	8b 43 28             	mov    0x28(%ebx),%eax                
  109044:	85 c0                	test   %eax,%eax                      
  109046:	74 0c                	je     109054 <pthread_key_delete+0x88><== ALWAYS TAKEN
          _Workspace_Free( the_key->Values[ the_api ] );              
  109048:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10904b:	50                   	push   %eax                           <== NOT EXECUTED
  10904c:	e8 9b 3c 00 00       	call   10ccec <_Workspace_Free>       <== NOT EXECUTED
  109051:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
  109054:	50                   	push   %eax                           
  109055:	50                   	push   %eax                           
  109056:	53                   	push   %ebx                           
  109057:	68 dc 04 12 00       	push   $0x1204dc                      
  10905c:	e8 13 23 00 00       	call   10b374 <_Objects_Free>         
       *  NOTE:  The destructor is not called and it is the responsibility
       *         of the application to free the memory.               
       */                                                             
                                                                      
      _POSIX_Keys_Free( the_key );                                    
      _Thread_Enable_dispatch();                                      
  109061:	e8 02 2c 00 00       	call   10bc68 <_Thread_Enable_dispatch>
  109066:	31 c0                	xor    %eax,%eax                      
  109068:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
  10906b:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10906e:	c9                   	leave                                 
  10906f:	c3                   	ret                                   
                                                                      

0011877c <pthread_kill>: int pthread_kill( pthread_t thread, int sig ) {
  11877c:	55                   	push   %ebp                           
  11877d:	89 e5                	mov    %esp,%ebp                      
  11877f:	57                   	push   %edi                           
  118780:	56                   	push   %esi                           
  118781:	53                   	push   %ebx                           
  118782:	83 ec 1c             	sub    $0x1c,%esp                     
  118785:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  POSIX_API_Control  *api;                                            
  Thread_Control     *the_thread;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !sig )                                                         
  118788:	85 f6                	test   %esi,%esi                      
  11878a:	74 08                	je     118794 <pthread_kill+0x18>     <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
  11878c:	8d 7e ff             	lea    -0x1(%esi),%edi                
  11878f:	83 ff 1f             	cmp    $0x1f,%edi                     
  118792:	76 0d                	jbe    1187a1 <pthread_kill+0x25>     
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  118794:	e8 83 7e ff ff       	call   11061c <__errno>               
  118799:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  11879f:	eb 77                	jmp    118818 <pthread_kill+0x9c>     
                                                                      
  the_thread = _Thread_Get( thread, &location );                      
  1187a1:	52                   	push   %edx                           
  1187a2:	52                   	push   %edx                           
  1187a3:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  1187a6:	50                   	push   %eax                           
  1187a7:	ff 75 08             	pushl  0x8(%ebp)                      
  1187aa:	e8 a9 3a ff ff       	call   10c258 <_Thread_Get>           
  1187af:	89 c3                	mov    %eax,%ebx                      
  switch ( location ) {                                               
  1187b1:	83 c4 10             	add    $0x10,%esp                     
  1187b4:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  1187b8:	75 53                	jne    11880d <pthread_kill+0x91>     <== NEVER TAKEN
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  If sig == 0 then just validate arguments                    
       */                                                             
                                                                      
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
  1187ba:	8b 90 f8 00 00 00    	mov    0xf8(%eax),%edx                
                                                                      
      if ( sig ) {                                                    
                                                                      
        if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {  
  1187c0:	6b c6 0c             	imul   $0xc,%esi,%eax                 
  1187c3:	83 b8 88 98 12 00 01 	cmpl   $0x1,0x129888(%eax)            
  1187ca:	74 38                	je     118804 <pthread_kill+0x88>     <== NEVER TAKEN
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
  1187cc:	b8 01 00 00 00       	mov    $0x1,%eax                      
  1187d1:	89 f9                	mov    %edi,%ecx                      
  1187d3:	d3 e0                	shl    %cl,%eax                       
  1187d5:	09 82 c8 00 00 00    	or     %eax,0xc8(%edx)                
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
  1187db:	50                   	push   %eax                           
  1187dc:	6a 00                	push   $0x0                           
  1187de:	56                   	push   %esi                           
  1187df:	53                   	push   %ebx                           
  1187e0:	e8 a7 fe ff ff       	call   11868c <_POSIX_signals_Unblock_thread>
                                                                      
        the_thread->do_post_task_switch_extension = true;             
  1187e5:	c6 43 75 01          	movb   $0x1,0x75(%ebx)                
                                                                      
        if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
  1187e9:	a1 30 93 12 00       	mov    0x129330,%eax                  
  1187ee:	83 c4 10             	add    $0x10,%esp                     
  1187f1:	85 c0                	test   %eax,%eax                      
  1187f3:	74 0f                	je     118804 <pthread_kill+0x88>     
  1187f5:	3b 1d 54 93 12 00    	cmp    0x129354,%ebx                  
  1187fb:	75 07                	jne    118804 <pthread_kill+0x88>     <== ALWAYS TAKEN
          _ISR_Signals_to_thread_executing = TRUE;                    
  1187fd:	c6 05 e8 93 12 00 01 	movb   $0x1,0x1293e8                  <== NOT EXECUTED
      }                                                               
      _Thread_Enable_dispatch();                                      
  118804:	e8 03 3a ff ff       	call   10c20c <_Thread_Enable_dispatch>
  118809:	31 c0                	xor    %eax,%eax                      
  11880b:	eb 0e                	jmp    11881b <pthread_kill+0x9f>     
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( ESRCH );                      
  11880d:	e8 0a 7e ff ff       	call   11061c <__errno>               <== NOT EXECUTED
  118812:	c7 00 03 00 00 00    	movl   $0x3,(%eax)                    <== NOT EXECUTED
  118818:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  11881b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  11881e:	5b                   	pop    %ebx                           
  11881f:	5e                   	pop    %esi                           
  118820:	5f                   	pop    %edi                           
  118821:	c9                   	leave                                 
  118822:	c3                   	ret                                   
                                                                      

0010a898 <pthread_mutex_init>: int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) {
  10a898:	55                   	push   %ebp                           
  10a899:	89 e5                	mov    %esp,%ebp                      
  10a89b:	57                   	push   %edi                           
  10a89c:	56                   	push   %esi                           
  10a89d:	53                   	push   %ebx                           
  10a89e:	83 ec 0c             	sub    $0xc,%esp                      
  10a8a1:	8b 45 0c             	mov    0xc(%ebp),%eax                 
#if 0                                                                 
  register POSIX_Mutex_Control *mutex_in_use;                         
  Objects_Locations             location;                             
#endif                                                                
                                                                      
  if ( attr ) the_attr = attr;                                        
  10a8a4:	be 60 c3 11 00       	mov    $0x11c360,%esi                 
  10a8a9:	85 c0                	test   %eax,%eax                      
  10a8ab:	74 02                	je     10a8af <pthread_mutex_init+0x17>
  10a8ad:	89 c6                	mov    %eax,%esi                      
  else        the_attr = &_POSIX_Mutex_Default_attributes;            
                                                                      
  /* Check for NULL mutex */                                          
                                                                      
  if ( !mutex )                                                       
  10a8af:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  10a8b3:	0f 84 df 00 00 00    	je     10a998 <pthread_mutex_init+0x100>
        break;                                                        
    }                                                                 
  }                                                                   
#endif                                                                
                                                                      
  if ( !the_attr->is_initialized )                                    
  10a8b9:	83 3e 00             	cmpl   $0x0,(%esi)                    
  10a8bc:	0f 84 d6 00 00 00    	je     10a998 <pthread_mutex_init+0x100>
                                                                      
  /*                                                                  
   *  XXX: Be careful about attributes when global!!!                 
   */                                                                 
                                                                      
  assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE );      
  10a8c2:	83 7e 04 00          	cmpl   $0x0,0x4(%esi)                 
  10a8c6:	74 16                	je     10a8de <pthread_mutex_init+0x46><== ALWAYS TAKEN
  10a8c8:	68 74 c3 11 00       	push   $0x11c374                      <== NOT EXECUTED
  10a8cd:	68 f4 c3 11 00       	push   $0x11c3f4                      <== NOT EXECUTED
  10a8d2:	6a 68                	push   $0x68                          <== NOT EXECUTED
  10a8d4:	68 a8 c3 11 00       	push   $0x11c3a8                      <== NOT EXECUTED
  10a8d9:	e8 6a d5 ff ff       	call   107e48 <__assert_func>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Determine the discipline of the mutex                           
   */                                                                 
                                                                      
  switch ( the_attr->protocol ) {                                     
  10a8de:	8b 46 0c             	mov    0xc(%esi),%eax                 
  10a8e1:	83 f8 01             	cmp    $0x1,%eax                      
  10a8e4:	74 10                	je     10a8f6 <pthread_mutex_init+0x5e>
  10a8e6:	83 f8 02             	cmp    $0x2,%eax                      
  10a8e9:	74 12                	je     10a8fd <pthread_mutex_init+0x65>
  10a8eb:	31 ff                	xor    %edi,%edi                      
  10a8ed:	85 c0                	test   %eax,%eax                      
  10a8ef:	74 11                	je     10a902 <pthread_mutex_init+0x6a>
  10a8f1:	e9 a2 00 00 00       	jmp    10a998 <pthread_mutex_init+0x100>
  10a8f6:	bf 02 00 00 00       	mov    $0x2,%edi                      
  10a8fb:	eb 05                	jmp    10a902 <pthread_mutex_init+0x6a>
  10a8fd:	bf 03 00 00 00       	mov    $0x3,%edi                      
      break;                                                          
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
                                                                      
  if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )          
  10a902:	8b 46 08             	mov    0x8(%esi),%eax                 
  10a905:	48                   	dec    %eax                           
  10a906:	3d fd 00 00 00       	cmp    $0xfd,%eax                     
  10a90b:	0f 87 87 00 00 00    	ja     10a998 <pthread_mutex_init+0x100>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10a911:	a1 68 2b 12 00       	mov    0x122b68,%eax                  
  10a916:	40                   	inc    %eax                           
  10a917:	a3 68 2b 12 00       	mov    %eax,0x122b68                  
 *  It is a simple wrapper for the help with the addition of the      
 *  allocation mutex being used for protection.                       
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
  10a91c:	83 ec 0c             	sub    $0xc,%esp                      
  10a91f:	68 18 2f 12 00       	push   $0x122f18                      
  10a924:	e8 f7 23 00 00       	call   10cd20 <_Objects_Allocate>     
  10a929:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_mutex = _POSIX_Mutex_Allocate();                                
                                                                      
  if ( !the_mutex ) {                                                 
  10a92b:	83 c4 10             	add    $0x10,%esp                     
  10a92e:	85 c0                	test   %eax,%eax                      
  10a930:	75 0c                	jne    10a93e <pthread_mutex_init+0xa6>
    _Thread_Enable_dispatch();                                        
  10a932:	e8 ed 2f 00 00       	call   10d924 <_Thread_Enable_dispatch>
  10a937:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  10a93c:	eb 5f                	jmp    10a99d <pthread_mutex_init+0x105>
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  the_mutex->process_shared = the_attr->process_shared;               
  10a93e:	8b 46 04             	mov    0x4(%esi),%eax                 
  10a941:	89 43 10             	mov    %eax,0x10(%ebx)                
                                                                      
  the_mutex_attr = &the_mutex->Mutex.Attributes;                      
                                                                      
  if ( the_attr->recursive )                                          
    the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
  10a944:	31 c0                	xor    %eax,%eax                      
  10a946:	83 7e 10 00          	cmpl   $0x0,0x10(%esi)                
  10a94a:	0f 94 c0             	sete   %al                            
  10a94d:	89 43 54             	mov    %eax,0x54(%ebx)                
  else                                                                
    the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
  the_mutex_attr->only_owner_release = TRUE;                          
  10a950:	c6 43 58 01          	movb   $0x1,0x58(%ebx)                
  the_mutex_attr->priority_ceiling =                                  
  10a954:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  10a959:	2b 46 08             	sub    0x8(%esi),%eax                 
  10a95c:	89 43 60             	mov    %eax,0x60(%ebx)                
    _POSIX_Priority_To_core( the_attr->prio_ceiling );                
  the_mutex_attr->discipline = the_discipline;                        
  10a95f:	89 7b 5c             	mov    %edi,0x5c(%ebx)                
                                                                      
  /*                                                                  
   *  Must be initialized to unlocked.                                
   */                                                                 
                                                                      
  _CORE_mutex_Initialize(                                             
  10a962:	50                   	push   %eax                           
  10a963:	6a 01                	push   $0x1                           
  10a965:	8d 43 54             	lea    0x54(%ebx),%eax                
  10a968:	50                   	push   %eax                           
  10a969:	8d 43 14             	lea    0x14(%ebx),%eax                
  10a96c:	50                   	push   %eax                           
  10a96d:	e8 12 1d 00 00       	call   10c684 <_CORE_mutex_Initialize>
  10a972:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  10a975:	0f b7 d1             	movzwl %cx,%edx                       
  10a978:	a1 34 2f 12 00       	mov    0x122f34,%eax                  
  10a97d:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  10a980:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
    CORE_MUTEX_UNLOCKED                                               
  );                                                                  
                                                                      
  _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
                                                                      
  *mutex = the_mutex->Object.id;                                      
  10a987:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10a98a:	89 08                	mov    %ecx,(%eax)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  10a98c:	e8 93 2f 00 00       	call   10d924 <_Thread_Enable_dispatch>
  10a991:	31 c0                	xor    %eax,%eax                      
  10a993:	83 c4 10             	add    $0x10,%esp                     
  10a996:	eb 05                	jmp    10a99d <pthread_mutex_init+0x105>
  return 0;                                                           
  10a998:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  10a99d:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a9a0:	5b                   	pop    %ebx                           
  10a9a1:	5e                   	pop    %esi                           
  10a9a2:	5f                   	pop    %edi                           
  10a9a3:	c9                   	leave                                 
  10a9a4:	c3                   	ret                                   
                                                                      

0010aa18 <pthread_mutex_setprioceiling>: int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) {
  10aa18:	55                   	push   %ebp                           
  10aa19:	89 e5                	mov    %esp,%ebp                      
  10aa1b:	57                   	push   %edi                           
  10aa1c:	56                   	push   %esi                           
  10aa1d:	53                   	push   %ebx                           
  10aa1e:	83 ec 1c             	sub    $0x1c,%esp                     
  10aa21:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10aa24:	8b 7d 10             	mov    0x10(%ebp),%edi                
  register POSIX_Mutex_Control *the_mutex;                            
  Objects_Locations             location;                             
  Priority_Control              the_priority;                         
  int                           status;                               
                                                                      
  if ( !old_ceiling )                                                 
  10aa27:	85 ff                	test   %edi,%edi                      
  10aa29:	74 5f                	je     10aa8a <pthread_mutex_setprioceiling+0x72>
    return EINVAL;                                                    
                                                                      
  if ( !_POSIX_Priority_Is_valid( prioceiling ) )                     
  10aa2b:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10aa2e:	48                   	dec    %eax                           
  10aa2f:	3d fd 00 00 00       	cmp    $0xfd,%eax                     
  10aa34:	77 54                	ja     10aa8a <pthread_mutex_setprioceiling+0x72>
                                                                      
  /*                                                                  
   *  Must acquire the mutex before we can change it's ceiling        
   */                                                                 
                                                                      
  status = pthread_mutex_lock( mutex );                               
  10aa36:	83 ec 0c             	sub    $0xc,%esp                      
  10aa39:	56                   	push   %esi                           
  10aa3a:	e8 69 ff ff ff       	call   10a9a8 <pthread_mutex_lock>    
  10aa3f:	89 c3                	mov    %eax,%ebx                      
  if ( status )                                                       
  10aa41:	83 c4 10             	add    $0x10,%esp                     
  10aa44:	85 c0                	test   %eax,%eax                      
  10aa46:	75 47                	jne    10aa8f <pthread_mutex_setprioceiling+0x77>
    return status;                                                    
                                                                      
  the_mutex = _POSIX_Mutex_Get( mutex, &location );                   
  10aa48:	52                   	push   %edx                           
  10aa49:	52                   	push   %edx                           
  10aa4a:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10aa4d:	50                   	push   %eax                           
  10aa4e:	56                   	push   %esi                           
  10aa4f:	e8 b9 fd ff ff       	call   10a80d <_POSIX_Mutex_Get>      
  10aa54:	89 c1                	mov    %eax,%ecx                      
  switch ( location ) {                                               
  10aa56:	83 c4 10             	add    $0x10,%esp                     
  10aa59:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10aa5d:	75 2b                	jne    10aa8a <pthread_mutex_setprioceiling+0x72><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      *old_ceiling = _POSIX_Priority_From_core(                       
  10aa5f:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  10aa64:	89 c2                	mov    %eax,%edx                      
  10aa66:	2b 51 60             	sub    0x60(%ecx),%edx                
  10aa69:	89 17                	mov    %edx,(%edi)                    
        the_mutex->Mutex.Attributes.priority_ceiling                  
      );                                                              
      the_mutex->Mutex.Attributes.priority_ceiling = the_priority;    
  10aa6b:	2b 45 0c             	sub    0xc(%ebp),%eax                 
  10aa6e:	89 41 60             	mov    %eax,0x60(%ecx)                
      _CORE_mutex_Surrender(                                          
  10aa71:	50                   	push   %eax                           
  10aa72:	6a 00                	push   $0x0                           
  10aa74:	ff 71 08             	pushl  0x8(%ecx)                      
  10aa77:	8d 41 14             	lea    0x14(%ecx),%eax                
  10aa7a:	50                   	push   %eax                           
  10aa7b:	e8 80 1d 00 00       	call   10c800 <_CORE_mutex_Surrender> 
        &the_mutex->Mutex,                                            
        the_mutex->Object.id,                                         
        NULL                                                          
      );                                                              
      _Thread_Enable_dispatch();                                      
  10aa80:	e8 9f 2e 00 00       	call   10d924 <_Thread_Enable_dispatch>
  10aa85:	83 c4 10             	add    $0x10,%esp                     
  10aa88:	eb 05                	jmp    10aa8f <pthread_mutex_setprioceiling+0x77>
      return 0;                                                       
  10aa8a:	bb 16 00 00 00       	mov    $0x16,%ebx                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
  10aa8f:	89 d8                	mov    %ebx,%eax                      
  10aa91:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10aa94:	5b                   	pop    %ebx                           
  10aa95:	5e                   	pop    %esi                           
  10aa96:	5f                   	pop    %edi                           
  10aa97:	c9                   	leave                                 
  10aa98:	c3                   	ret                                   
                                                                      

0010aa9c <pthread_mutex_timedlock>: int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) {
  10aa9c:	55                   	push   %ebp                           
  10aa9d:	89 e5                	mov    %esp,%ebp                      
  10aa9f:	83 ec 20             	sub    $0x20,%esp                     
   *  So we check the abstime provided, and hold on to whether it     
   *  is valid or not.  If it isn't correct and in the future,        
   *  then we do a polling operation and convert the UNSATISFIED      
   *  status into the appropriate error.                              
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  10aaa2:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  10aaa5:	50                   	push   %eax                           
  10aaa6:	ff 75 0c             	pushl  0xc(%ebp)                      
  10aaa9:	e8 96 00 00 00       	call   10ab44 <_POSIX_Absolute_timeout_to_ticks>
  switch ( status ) {                                                 
  10aaae:	83 c4 10             	add    $0x10,%esp                     
  10aab1:	31 d2                	xor    %edx,%edx                      
  10aab3:	83 f8 02             	cmp    $0x2,%eax                      
  10aab6:	76 07                	jbe    10aabf <pthread_mutex_timedlock+0x23><== NEVER TAKEN
  10aab8:	83 f8 03             	cmp    $0x3,%eax                      
  10aabb:	75 02                	jne    10aabf <pthread_mutex_timedlock+0x23><== NEVER TAKEN
  10aabd:	b2 01                	mov    $0x1,%dl                       
    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:                         
      do_wait = TRUE;                                                 
      break;                                                          
  }                                                                   
                                                                      
  lock_status = _POSIX_Mutex_Lock_support(                            
  10aabf:	50                   	push   %eax                           
  10aac0:	ff 75 fc             	pushl  -0x4(%ebp)                     
  10aac3:	0f b6 c2             	movzbl %dl,%eax                       
  10aac6:	50                   	push   %eax                           
  10aac7:	ff 75 08             	pushl  0x8(%ebp)                      
  10aaca:	e8 ed fe ff ff       	call   10a9bc <_POSIX_Mutex_Lock_support>
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  return lock_status;                                                 
}                                                                     
  10aacf:	c9                   	leave                                 
  10aad0:	c3                   	ret                                   
                                                                      

0010a72c <pthread_mutexattr_setpshared>: int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) {
  10a72c:	55                   	push   %ebp                           
  10a72d:	89 e5                	mov    %esp,%ebp                      
  10a72f:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10a732:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  if ( !attr || !attr->is_initialized )                               
  10a735:	85 c0                	test   %eax,%eax                      
  10a737:	74 11                	je     10a74a <pthread_mutexattr_setpshared+0x1e>
  10a739:	83 38 00             	cmpl   $0x0,(%eax)                    
  10a73c:	74 0c                	je     10a74a <pthread_mutexattr_setpshared+0x1e>
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
  10a73e:	83 fa 01             	cmp    $0x1,%edx                      
  10a741:	77 07                	ja     10a74a <pthread_mutexattr_setpshared+0x1e><== NEVER TAKEN
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
  10a743:	89 50 04             	mov    %edx,0x4(%eax)                 
  10a746:	31 c0                	xor    %eax,%eax                      
  10a748:	eb 05                	jmp    10a74f <pthread_mutexattr_setpshared+0x23>
      return 0;                                                       
  10a74a:	b8 16 00 00 00       	mov    $0x16,%eax                     
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
  10a74f:	c9                   	leave                                 
  10a750:	c3                   	ret                                   
                                                                      

0010a0b0 <pthread_once>: int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) {
  10a0b0:	55                   	push   %ebp                           
  10a0b1:	89 e5                	mov    %esp,%ebp                      
  10a0b3:	56                   	push   %esi                           
  10a0b4:	53                   	push   %ebx                           
  10a0b5:	83 ec 10             	sub    $0x10,%esp                     
  10a0b8:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a0bb:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  if ( !once_control || !init_routine )                               
  10a0be:	85 db                	test   %ebx,%ebx                      
  10a0c0:	74 04                	je     10a0c6 <pthread_once+0x16>     
  10a0c2:	85 f6                	test   %esi,%esi                      
  10a0c4:	75 07                	jne    10a0cd <pthread_once+0x1d>     
  10a0c6:	b8 16 00 00 00       	mov    $0x16,%eax                     
  10a0cb:	eb 4b                	jmp    10a118 <pthread_once+0x68>     
    return EINVAL;                                                    
                                                                      
  if ( !once_control->init_executed ) {                               
  10a0cd:	31 c0                	xor    %eax,%eax                      
  10a0cf:	83 7b 04 00          	cmpl   $0x0,0x4(%ebx)                 
  10a0d3:	75 43                	jne    10a118 <pthread_once+0x68>     
    rtems_mode saveMode;                                              
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
  10a0d5:	52                   	push   %edx                           
  10a0d6:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10a0d9:	50                   	push   %eax                           
  10a0da:	68 00 01 00 00       	push   $0x100                         
  10a0df:	68 00 01 00 00       	push   $0x100                         
  10a0e4:	e8 8f 0c 00 00       	call   10ad78 <rtems_task_mode>       
    if ( !once_control->init_executed ) {                             
  10a0e9:	83 c4 10             	add    $0x10,%esp                     
  10a0ec:	83 7b 04 00          	cmpl   $0x0,0x4(%ebx)                 
  10a0f0:	75 0f                	jne    10a101 <pthread_once+0x51>     <== NEVER TAKEN
      once_control->is_initialized = TRUE;                            
  10a0f2:	c7 03 01 00 00 00    	movl   $0x1,(%ebx)                    
      once_control->init_executed = TRUE;                             
  10a0f8:	c7 43 04 01 00 00 00 	movl   $0x1,0x4(%ebx)                 
      (*init_routine)();                                              
  10a0ff:	ff d6                	call   *%esi                          
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
  10a101:	50                   	push   %eax                           
  10a102:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10a105:	50                   	push   %eax                           
  10a106:	68 00 01 00 00       	push   $0x100                         
  10a10b:	ff 75 f4             	pushl  -0xc(%ebp)                     
  10a10e:	e8 65 0c 00 00       	call   10ad78 <rtems_task_mode>       
  10a113:	31 c0                	xor    %eax,%eax                      
  10a115:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
  return 0;                                                           
}                                                                     
  10a118:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a11b:	5b                   	pop    %ebx                           
  10a11c:	5e                   	pop    %esi                           
  10a11d:	c9                   	leave                                 
  10a11e:	c3                   	ret                                   
                                                                      

001097cc <pthread_rwlock_init>: int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) {
  1097cc:	55                   	push   %ebp                           
  1097cd:	89 e5                	mov    %esp,%ebp                      
  1097cf:	56                   	push   %esi                           
  1097d0:	53                   	push   %ebx                           
  1097d1:	83 ec 10             	sub    $0x10,%esp                     
  1097d4:	8b 75 08             	mov    0x8(%ebp),%esi                 
  const pthread_rwlockattr_t  *the_attr;                              
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !rwlock )                                                      
  1097d7:	85 f6                	test   %esi,%esi                      
  1097d9:	0f 84 82 00 00 00    	je     109861 <pthread_rwlock_init+0x95>
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
  1097df:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1097e2:	85 c0                	test   %eax,%eax                      
  1097e4:	75 11                	jne    1097f7 <pthread_rwlock_init+0x2b><== ALWAYS TAKEN
    the_attr = attr;                                                  
  } else {                                                            
    (void) pthread_rwlockattr_init( &default_attr );                  
  1097e6:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1097e9:	8d 5d ec             	lea    -0x14(%ebp),%ebx               <== NOT EXECUTED
  1097ec:	53                   	push   %ebx                           <== NOT EXECUTED
  1097ed:	e8 9a 09 00 00       	call   10a18c <pthread_rwlockattr_init><== NOT EXECUTED
  1097f2:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  1097f4:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
  1097f7:	83 38 00             	cmpl   $0x0,(%eax)                    
  1097fa:	74 65                	je     109861 <pthread_rwlock_init+0x95><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
  1097fc:	83 78 04 00          	cmpl   $0x0,0x4(%eax)                 
  109800:	75 5f                	jne    109861 <pthread_rwlock_init+0x95><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109802:	a1 d0 fb 11 00       	mov    0x11fbd0,%eax                  
  109807:	40                   	inc    %eax                           
  109808:	a3 d0 fb 11 00       	mov    %eax,0x11fbd0                  
 */                                                                   
/**@{*/                                                               
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
  10980d:	83 ec 0c             	sub    $0xc,%esp                      
  109810:	68 00 fe 11 00       	push   $0x11fe00                      
  109815:	e8 2e 25 00 00       	call   10bd48 <_Objects_Allocate>     
  10981a:	89 c3                	mov    %eax,%ebx                      
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_rwlock = _POSIX_RWLock_Allocate();                              
                                                                      
  if ( !the_rwlock ) {                                                
  10981c:	83 c4 10             	add    $0x10,%esp                     
  10981f:	85 c0                	test   %eax,%eax                      
  109821:	75 0c                	jne    10982f <pthread_rwlock_init+0x63>
    _Thread_Enable_dispatch();                                        
  109823:	e8 24 31 00 00       	call   10c94c <_Thread_Enable_dispatch>
  109828:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  10982d:	eb 37                	jmp    109866 <pthread_rwlock_init+0x9a>
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );    
  10982f:	50                   	push   %eax                           
  109830:	50                   	push   %eax                           
  109831:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  109834:	50                   	push   %eax                           
  109835:	8d 43 10             	lea    0x10(%ebx),%eax                
  109838:	50                   	push   %eax                           
  109839:	e8 ae 1e 00 00       	call   10b6ec <_CORE_RWLock_Initialize>
  10983e:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  109841:	0f b7 d1             	movzwl %cx,%edx                       
  109844:	a1 1c fe 11 00       	mov    0x11fe1c,%eax                  
  109849:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  10984c:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
    &_POSIX_RWLock_Information,                                       
    &the_rwlock->Object,                                              
    0                                                                 
  );                                                                  
                                                                      
  *rwlock = the_rwlock->Object.id;                                    
  109853:	89 0e                	mov    %ecx,(%esi)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  109855:	e8 f2 30 00 00       	call   10c94c <_Thread_Enable_dispatch>
  10985a:	31 c0                	xor    %eax,%eax                      
  10985c:	83 c4 10             	add    $0x10,%esp                     
  10985f:	eb 05                	jmp    109866 <pthread_rwlock_init+0x9a>
  return 0;                                                           
  109861:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  109866:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  109869:	5b                   	pop    %ebx                           
  10986a:	5e                   	pop    %esi                           
  10986b:	c9                   	leave                                 
  10986c:	c3                   	ret                                   
                                                                      

001098d4 <pthread_rwlock_timedrdlock>: int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
  1098d4:	55                   	push   %ebp                           
  1098d5:	89 e5                	mov    %esp,%ebp                      
  1098d7:	57                   	push   %edi                           
  1098d8:	56                   	push   %esi                           
  1098d9:	53                   	push   %ebx                           
  1098da:	83 ec 1c             	sub    $0x1c,%esp                     
  1098dd:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  Objects_Locations                            location;              
  Watchdog_Interval                            ticks;                 
  bool                                         do_wait;               
  POSIX_Absolute_timeout_conversion_results_t  status;                
                                                                      
  if ( !rwlock )                                                      
  1098e0:	85 ff                	test   %edi,%edi                      
  1098e2:	0f 84 8e 00 00 00    	je     109976 <pthread_rwlock_timedrdlock+0xa2>
   *  So we check the abstime provided, and hold on to whether it     
   *  is valid or not.  If it isn't correct and in the future,        
   *  then we do a polling operation and convert the UNSATISFIED      
   *  status into the appropriate error.                              
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  1098e8:	52                   	push   %edx                           
  1098e9:	52                   	push   %edx                           
  1098ea:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  1098ed:	50                   	push   %eax                           
  1098ee:	ff 75 0c             	pushl  0xc(%ebp)                      
  1098f1:	e8 22 5a 00 00       	call   10f318 <_POSIX_Absolute_timeout_to_ticks>
  1098f6:	89 c6                	mov    %eax,%esi                      
  switch (status) {                                                   
  1098f8:	83 c4 10             	add    $0x10,%esp                     
  1098fb:	31 db                	xor    %ebx,%ebx                      
  1098fd:	83 f8 02             	cmp    $0x2,%eax                      
  109900:	76 07                	jbe    109909 <pthread_rwlock_timedrdlock+0x35>
  109902:	83 f8 03             	cmp    $0x3,%eax                      
  109905:	75 02                	jne    109909 <pthread_rwlock_timedrdlock+0x35><== NEVER TAKEN
  109907:	b3 01                	mov    $0x1,%bl                       
  109909:	50                   	push   %eax                           
  10990a:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10990d:	50                   	push   %eax                           
  10990e:	ff 37                	pushl  (%edi)                         
  109910:	68 00 fe 11 00       	push   $0x11fe00                      
  109915:	e8 72 28 00 00       	call   10c18c <_Objects_Get>          
  10991a:	89 c2                	mov    %eax,%edx                      
      do_wait = TRUE;                                                 
      break;                                                          
  }                                                                   
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
  10991c:	83 c4 10             	add    $0x10,%esp                     
  10991f:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  109923:	75 51                	jne    109976 <pthread_rwlock_timedrdlock+0xa2>
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_reading(                                
  109925:	83 ec 0c             	sub    $0xc,%esp                      
  109928:	6a 00                	push   $0x0                           
  10992a:	ff 75 ec             	pushl  -0x14(%ebp)                    
  10992d:	0f b6 c3             	movzbl %bl,%eax                       
  109930:	50                   	push   %eax                           
  109931:	ff 37                	pushl  (%edi)                         
  109933:	8d 42 10             	lea    0x10(%edx),%eax                
  109936:	50                   	push   %eax                           
  109937:	e8 e4 1d 00 00       	call   10b720 <_CORE_RWLock_Obtain_for_reading>
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
  10993c:	83 c4 20             	add    $0x20,%esp                     
  10993f:	e8 08 30 00 00       	call   10c94c <_Thread_Enable_dispatch>
      if ( !do_wait &&                                                
  109944:	84 db                	test   %bl,%bl                        
  109946:	75 19                	jne    109961 <pthread_rwlock_timedrdlock+0x8d><== ALWAYS TAKEN
  109948:	a1 90 fc 11 00       	mov    0x11fc90,%eax                  <== NOT EXECUTED
  10994d:	83 78 34 02          	cmpl   $0x2,0x34(%eax)                <== NOT EXECUTED
  109951:	75 0e                	jne    109961 <pthread_rwlock_timedrdlock+0x8d><== NOT EXECUTED
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
	switch (status) {                                                    
  109953:	85 f6                	test   %esi,%esi                      <== NOT EXECUTED
  109955:	74 1f                	je     109976 <pthread_rwlock_timedrdlock+0xa2><== NOT EXECUTED
  109957:	b8 74 00 00 00       	mov    $0x74,%eax                     <== NOT EXECUTED
  10995c:	83 fe 02             	cmp    $0x2,%esi                      <== NOT EXECUTED
  10995f:	76 1a                	jbe    10997b <pthread_rwlock_timedrdlock+0xa7><== NOT EXECUTED
	  case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:                          
	    break;                                                           
	}                                                                    
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
  109961:	83 ec 0c             	sub    $0xc,%esp                      
  109964:	a1 90 fc 11 00       	mov    0x11fc90,%eax                  
  109969:	ff 70 34             	pushl  0x34(%eax)                     
  10996c:	e8 c3 00 00 00       	call   109a34 <_POSIX_RWLock_Translate_core_RWLock_return_code>
  109971:	83 c4 10             	add    $0x10,%esp                     
  109974:	eb 05                	jmp    10997b <pthread_rwlock_timedrdlock+0xa7>
  109976:	b8 16 00 00 00       	mov    $0x16,%eax                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
  10997b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10997e:	5b                   	pop    %ebx                           
  10997f:	5e                   	pop    %esi                           
  109980:	5f                   	pop    %edi                           
  109981:	c9                   	leave                                 
  109982:	c3                   	ret                                   
                                                                      

00109984 <pthread_rwlock_timedwrlock>: int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
  109984:	55                   	push   %ebp                           
  109985:	89 e5                	mov    %esp,%ebp                      
  109987:	57                   	push   %edi                           
  109988:	56                   	push   %esi                           
  109989:	53                   	push   %ebx                           
  10998a:	83 ec 1c             	sub    $0x1c,%esp                     
  10998d:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  Objects_Locations                            location;              
  Watchdog_Interval                            ticks;                 
  bool                                         do_wait;               
  POSIX_Absolute_timeout_conversion_results_t  status;                
                                                                      
  if ( !rwlock )                                                      
  109990:	85 ff                	test   %edi,%edi                      
  109992:	0f 84 8e 00 00 00    	je     109a26 <pthread_rwlock_timedwrlock+0xa2>
   *  So we check the abstime provided, and hold on to whether it     
   *  is valid or not.  If it isn't correct and in the future,        
   *  then we do a polling operation and convert the UNSATISFIED      
   *  status into the appropriate error.                              
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  109998:	52                   	push   %edx                           
  109999:	52                   	push   %edx                           
  10999a:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10999d:	50                   	push   %eax                           
  10999e:	ff 75 0c             	pushl  0xc(%ebp)                      
  1099a1:	e8 72 59 00 00       	call   10f318 <_POSIX_Absolute_timeout_to_ticks>
  1099a6:	89 c6                	mov    %eax,%esi                      
  switch (status) {                                                   
  1099a8:	83 c4 10             	add    $0x10,%esp                     
  1099ab:	31 db                	xor    %ebx,%ebx                      
  1099ad:	83 f8 02             	cmp    $0x2,%eax                      
  1099b0:	76 07                	jbe    1099b9 <pthread_rwlock_timedwrlock+0x35>
  1099b2:	83 f8 03             	cmp    $0x3,%eax                      
  1099b5:	75 02                	jne    1099b9 <pthread_rwlock_timedwrlock+0x35><== NEVER TAKEN
  1099b7:	b3 01                	mov    $0x1,%bl                       
  1099b9:	50                   	push   %eax                           
  1099ba:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  1099bd:	50                   	push   %eax                           
  1099be:	ff 37                	pushl  (%edi)                         
  1099c0:	68 00 fe 11 00       	push   $0x11fe00                      
  1099c5:	e8 c2 27 00 00       	call   10c18c <_Objects_Get>          
  1099ca:	89 c2                	mov    %eax,%edx                      
      do_wait = TRUE;                                                 
      break;                                                          
  }                                                                   
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
  1099cc:	83 c4 10             	add    $0x10,%esp                     
  1099cf:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  1099d3:	75 51                	jne    109a26 <pthread_rwlock_timedwrlock+0xa2>
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_writing(                                
  1099d5:	83 ec 0c             	sub    $0xc,%esp                      
  1099d8:	6a 00                	push   $0x0                           
  1099da:	ff 75 ec             	pushl  -0x14(%ebp)                    
  1099dd:	0f b6 c3             	movzbl %bl,%eax                       
  1099e0:	50                   	push   %eax                           
  1099e1:	ff 37                	pushl  (%edi)                         
  1099e3:	8d 42 10             	lea    0x10(%edx),%eax                
  1099e6:	50                   	push   %eax                           
  1099e7:	e8 e8 1d 00 00       	call   10b7d4 <_CORE_RWLock_Obtain_for_writing>
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
  1099ec:	83 c4 20             	add    $0x20,%esp                     
  1099ef:	e8 58 2f 00 00       	call   10c94c <_Thread_Enable_dispatch>
      if ( !do_wait &&                                                
  1099f4:	84 db                	test   %bl,%bl                        
  1099f6:	75 19                	jne    109a11 <pthread_rwlock_timedwrlock+0x8d><== ALWAYS TAKEN
  1099f8:	a1 90 fc 11 00       	mov    0x11fc90,%eax                  <== NOT EXECUTED
  1099fd:	83 78 34 02          	cmpl   $0x2,0x34(%eax)                <== NOT EXECUTED
  109a01:	75 0e                	jne    109a11 <pthread_rwlock_timedwrlock+0x8d><== NOT EXECUTED
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
	switch (status) {                                                    
  109a03:	85 f6                	test   %esi,%esi                      <== NOT EXECUTED
  109a05:	74 1f                	je     109a26 <pthread_rwlock_timedwrlock+0xa2><== NOT EXECUTED
  109a07:	b8 74 00 00 00       	mov    $0x74,%eax                     <== NOT EXECUTED
  109a0c:	83 fe 02             	cmp    $0x2,%esi                      <== NOT EXECUTED
  109a0f:	76 1a                	jbe    109a2b <pthread_rwlock_timedwrlock+0xa7><== NOT EXECUTED
	  case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:                          
	    break;                                                           
	}                                                                    
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
  109a11:	83 ec 0c             	sub    $0xc,%esp                      
  109a14:	a1 90 fc 11 00       	mov    0x11fc90,%eax                  
  109a19:	ff 70 34             	pushl  0x34(%eax)                     
  109a1c:	e8 13 00 00 00       	call   109a34 <_POSIX_RWLock_Translate_core_RWLock_return_code>
  109a21:	83 c4 10             	add    $0x10,%esp                     
  109a24:	eb 05                	jmp    109a2b <pthread_rwlock_timedwrlock+0xa7>
  109a26:	b8 16 00 00 00       	mov    $0x16,%eax                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
  109a2b:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109a2e:	5b                   	pop    %ebx                           
  109a2f:	5e                   	pop    %esi                           
  109a30:	5f                   	pop    %edi                           
  109a31:	c9                   	leave                                 
  109a32:	c3                   	ret                                   
                                                                      

0010a1ac <pthread_rwlockattr_setpshared>: int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) {
  10a1ac:	55                   	push   %ebp                           
  10a1ad:	89 e5                	mov    %esp,%ebp                      
  10a1af:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10a1b2:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  if ( !attr )                                                        
  10a1b5:	85 c0                	test   %eax,%eax                      
  10a1b7:	74 11                	je     10a1ca <pthread_rwlockattr_setpshared+0x1e>
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
  10a1b9:	83 38 00             	cmpl   $0x0,(%eax)                    
  10a1bc:	74 0c                	je     10a1ca <pthread_rwlockattr_setpshared+0x1e>
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
  10a1be:	83 fa 01             	cmp    $0x1,%edx                      
  10a1c1:	77 07                	ja     10a1ca <pthread_rwlockattr_setpshared+0x1e><== NEVER TAKEN
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
  10a1c3:	89 50 04             	mov    %edx,0x4(%eax)                 
  10a1c6:	31 c0                	xor    %eax,%eax                      
  10a1c8:	eb 05                	jmp    10a1cf <pthread_rwlockattr_setpshared+0x23>
      return 0;                                                       
  10a1ca:	b8 16 00 00 00       	mov    $0x16,%eax                     
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
  10a1cf:	c9                   	leave                                 
  10a1d0:	c3                   	ret                                   
                                                                      

00109164 <pthread_setcancelstate>: int pthread_setcancelstate( int state, int *oldstate ) {
  109164:	55                   	push   %ebp                           
  109165:	89 e5                	mov    %esp,%ebp                      
  109167:	53                   	push   %ebx                           
  109168:	83 ec 04             	sub    $0x4,%esp                      
  10916b:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10916e:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
   *  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() )                                        
  109171:	a1 84 f5 11 00       	mov    0x11f584,%eax                  
  109176:	ba 47 00 00 00       	mov    $0x47,%edx                     
  10917b:	85 c0                	test   %eax,%eax                      
  10917d:	75 6e                	jne    1091ed <pthread_setcancelstate+0x89><== NEVER TAKEN
    return EPROTO;                                                    
                                                                      
  if ( !oldstate )                                                    
  10917f:	85 db                	test   %ebx,%ebx                      
  109181:	74 65                	je     1091e8 <pthread_setcancelstate+0x84><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
  109183:	83 f9 01             	cmp    $0x1,%ecx                      
  109186:	77 60                	ja     1091e8 <pthread_setcancelstate+0x84><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
  109188:	a1 a8 f5 11 00       	mov    0x11f5a8,%eax                  
  10918d:	8b 90 f8 00 00 00    	mov    0xf8(%eax),%edx                
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109193:	a1 e8 f4 11 00       	mov    0x11f4e8,%eax                  
  109198:	40                   	inc    %eax                           
  109199:	a3 e8 f4 11 00       	mov    %eax,0x11f4e8                  
                                                                      
  _Thread_Disable_dispatch();                                         
    *oldstate = thread_support->cancelability_state;                  
  10919e:	8b 82 cc 00 00 00    	mov    0xcc(%edx),%eax                
  1091a4:	89 03                	mov    %eax,(%ebx)                    
    thread_support->cancelability_state = state;                      
  1091a6:	89 8a cc 00 00 00    	mov    %ecx,0xcc(%edx)                
                                                                      
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
  1091ac:	85 c9                	test   %ecx,%ecx                      
  1091ae:	75 15                	jne    1091c5 <pthread_setcancelstate+0x61><== NEVER TAKEN
  1091b0:	83 ba d0 00 00 00 01 	cmpl   $0x1,0xd0(%edx)                
  1091b7:	75 0c                	jne    1091c5 <pthread_setcancelstate+0x61><== ALWAYS TAKEN
  1091b9:	83 ba d4 00 00 00 00 	cmpl   $0x0,0xd4(%edx)                <== NOT EXECUTED
  1091c0:	0f 95 c3             	setne  %bl                            <== NOT EXECUTED
  1091c3:	eb 02                	jmp    1091c7 <pthread_setcancelstate+0x63><== NOT EXECUTED
  1091c5:	31 db                	xor    %ebx,%ebx                      
         thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
                                                                      
 _Thread_Enable_dispatch();                                           
  1091c7:	e8 00 26 00 00       	call   10b7cc <_Thread_Enable_dispatch>
 if ( cancel )                                                        
  1091cc:	31 d2                	xor    %edx,%edx                      
  1091ce:	84 db                	test   %bl,%bl                        
  1091d0:	74 1b                	je     1091ed <pthread_setcancelstate+0x89><== ALWAYS TAKEN
   _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );         
  1091d2:	50                   	push   %eax                           <== NOT EXECUTED
  1091d3:	50                   	push   %eax                           <== NOT EXECUTED
  1091d4:	6a ff                	push   $0xffffffff                    <== NOT EXECUTED
  1091d6:	ff 35 a8 f5 11 00    	pushl  0x11f5a8                       <== NOT EXECUTED
  1091dc:	e8 83 fb ff ff       	call   108d64 <_POSIX_Thread_Exit>    <== NOT EXECUTED
  1091e1:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  1091e3:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1091e6:	eb 05                	jmp    1091ed <pthread_setcancelstate+0x89><== NOT EXECUTED
  1091e8:	ba 16 00 00 00       	mov    $0x16,%edx                     <== NOT EXECUTED
  return 0;                                                           
}                                                                     
  1091ed:	89 d0                	mov    %edx,%eax                      
  1091ef:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  1091f2:	c9                   	leave                                 
  1091f3:	c3                   	ret                                   
                                                                      

001091f4 <pthread_setcanceltype>: int pthread_setcanceltype( int type, int *oldtype ) {
  1091f4:	55                   	push   %ebp                           
  1091f5:	89 e5                	mov    %esp,%ebp                      
  1091f7:	53                   	push   %ebx                           
  1091f8:	83 ec 04             	sub    $0x4,%esp                      
  1091fb:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  1091fe:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
   *  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() )                                        
  109201:	a1 84 f5 11 00       	mov    0x11f584,%eax                  
  109206:	ba 47 00 00 00       	mov    $0x47,%edx                     
  10920b:	85 c0                	test   %eax,%eax                      
  10920d:	75 6d                	jne    10927c <pthread_setcanceltype+0x88><== NEVER TAKEN
    return EPROTO;                                                    
                                                                      
  if ( !oldtype )                                                     
  10920f:	85 db                	test   %ebx,%ebx                      
  109211:	74 64                	je     109277 <pthread_setcanceltype+0x83><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
  109213:	83 f9 01             	cmp    $0x1,%ecx                      
  109216:	77 5f                	ja     109277 <pthread_setcanceltype+0x83><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
  109218:	a1 a8 f5 11 00       	mov    0x11f5a8,%eax                  
  10921d:	8b 90 f8 00 00 00    	mov    0xf8(%eax),%edx                
  109223:	a1 e8 f4 11 00       	mov    0x11f4e8,%eax                  
  109228:	40                   	inc    %eax                           
  109229:	a3 e8 f4 11 00       	mov    %eax,0x11f4e8                  
                                                                      
  _Thread_Disable_dispatch();                                         
    *oldtype = thread_support->cancelability_type;                    
  10922e:	8b 82 d0 00 00 00    	mov    0xd0(%edx),%eax                
  109234:	89 03                	mov    %eax,(%ebx)                    
    thread_support->cancelability_type = type;                        
  109236:	89 8a d0 00 00 00    	mov    %ecx,0xd0(%edx)                
                                                                      
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
  10923c:	83 ba cc 00 00 00 00 	cmpl   $0x0,0xcc(%edx)                
  109243:	75 0f                	jne    109254 <pthread_setcanceltype+0x60><== NEVER TAKEN
  109245:	49                   	dec    %ecx                           
  109246:	75 0c                	jne    109254 <pthread_setcanceltype+0x60>
  109248:	83 ba d4 00 00 00 00 	cmpl   $0x0,0xd4(%edx)                
  10924f:	0f 95 c3             	setne  %bl                            
  109252:	eb 02                	jmp    109256 <pthread_setcanceltype+0x62>
  109254:	31 db                	xor    %ebx,%ebx                      
         thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
  _Thread_Enable_dispatch();                                          
  109256:	e8 71 25 00 00       	call   10b7cc <_Thread_Enable_dispatch>
  if ( cancel )                                                       
  10925b:	31 d2                	xor    %edx,%edx                      
  10925d:	84 db                	test   %bl,%bl                        
  10925f:	74 1b                	je     10927c <pthread_setcanceltype+0x88><== ALWAYS TAKEN
    _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );        
  109261:	50                   	push   %eax                           <== NOT EXECUTED
  109262:	50                   	push   %eax                           <== NOT EXECUTED
  109263:	6a ff                	push   $0xffffffff                    <== NOT EXECUTED
  109265:	ff 35 a8 f5 11 00    	pushl  0x11f5a8                       <== NOT EXECUTED
  10926b:	e8 f4 fa ff ff       	call   108d64 <_POSIX_Thread_Exit>    <== NOT EXECUTED
  109270:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  109272:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  109275:	eb 05                	jmp    10927c <pthread_setcanceltype+0x88><== NOT EXECUTED
  109277:	ba 16 00 00 00       	mov    $0x16,%edx                     <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
  10927c:	89 d0                	mov    %edx,%eax                      
  10927e:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109281:	c9                   	leave                                 
  109282:	c3                   	ret                                   
                                                                      

0010b2b4 <pthread_setschedparam>: int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) {
  10b2b4:	55                   	push   %ebp                           
  10b2b5:	89 e5                	mov    %esp,%ebp                      
  10b2b7:	57                   	push   %edi                           
  10b2b8:	56                   	push   %esi                           
  10b2b9:	53                   	push   %ebx                           
  10b2ba:	83 ec 2c             	sub    $0x2c,%esp                     
                                                                      
  /*                                                                  
   *  Check all the parameters                                        
   */                                                                 
                                                                      
  if ( !param )                                                       
  10b2bd:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  10b2c1:	0f 84 7e 01 00 00    	je     10b445 <pthread_setschedparam+0x191>
    return EINVAL;                                                    
                                                                      
  if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )           
  10b2c7:	8b 55 10             	mov    0x10(%ebp),%edx                
  10b2ca:	8b 02                	mov    (%edx),%eax                    
  10b2cc:	48                   	dec    %eax                           
  10b2cd:	3d fd 00 00 00       	cmp    $0xfd,%eax                     
  10b2d2:	0f 87 6d 01 00 00    	ja     10b445 <pthread_setschedparam+0x191><== NEVER TAKEN
    return EINVAL;                                                    
                                                                      
  budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;                
  budget_callout = NULL;                                              
                                                                      
  switch ( policy ) {                                                 
  10b2d8:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)                 
  10b2dc:	74 1f                	je     10b2fd <pthread_setschedparam+0x49>
  10b2de:	7f 0b                	jg     10b2eb <pthread_setschedparam+0x37>
  10b2e0:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  10b2e4:	74 20                	je     10b306 <pthread_setschedparam+0x52>
  10b2e6:	e9 5a 01 00 00       	jmp    10b445 <pthread_setschedparam+0x191>
  10b2eb:	83 7d 0c 02          	cmpl   $0x2,0xc(%ebp)                 
  10b2ef:	74 25                	je     10b316 <pthread_setschedparam+0x62>
  10b2f1:	83 7d 0c 03          	cmpl   $0x3,0xc(%ebp)                 
  10b2f5:	0f 85 4a 01 00 00    	jne    10b445 <pthread_setschedparam+0x191><== NEVER TAKEN
  10b2fb:	eb 22                	jmp    10b31f <pthread_setschedparam+0x6b>
  10b2fd:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               
  10b304:	eb 07                	jmp    10b30d <pthread_setschedparam+0x59>
  10b306:	c7 45 dc 01 00 00 00 	movl   $0x1,-0x24(%ebp)               
  10b30d:	c7 45 e0 00 00 00 00 	movl   $0x0,-0x20(%ebp)               
  10b314:	eb 53                	jmp    10b369 <pthread_setschedparam+0xb5>
  10b316:	c7 45 dc 02 00 00 00 	movl   $0x2,-0x24(%ebp)               
  10b31d:	eb ee                	jmp    10b30d <pthread_setschedparam+0x59>
                                                                      
    case SCHED_SPORADIC:                                              
      budget_algorithm  = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;        
      budget_callout = _POSIX_Threads_Sporadic_budget_callout;        
                                                                      
      if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) <        
  10b31f:	83 ec 0c             	sub    $0xc,%esp                      
  10b322:	8b 45 10             	mov    0x10(%ebp),%eax                
  10b325:	83 c0 08             	add    $0x8,%eax                      
  10b328:	50                   	push   %eax                           
  10b329:	e8 d2 31 00 00       	call   10e500 <_Timespec_To_ticks>    
  10b32e:	89 c3                	mov    %eax,%ebx                      
  10b330:	8b 45 10             	mov    0x10(%ebp),%eax                
  10b333:	83 c0 10             	add    $0x10,%eax                     
  10b336:	89 04 24             	mov    %eax,(%esp)                    
  10b339:	e8 c2 31 00 00       	call   10e500 <_Timespec_To_ticks>    
  10b33e:	83 c4 10             	add    $0x10,%esp                     
  10b341:	39 c3                	cmp    %eax,%ebx                      
  10b343:	0f 82 fc 00 00 00    	jb     10b445 <pthread_setschedparam+0x191><== NEVER TAKEN
           _Timespec_To_ticks( ¶m->ss_initial_budget ) )          
        return EINVAL;                                                
                                                                      
      if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) )      
  10b349:	8b 75 10             	mov    0x10(%ebp),%esi                
  10b34c:	8b 46 04             	mov    0x4(%esi),%eax                 
  10b34f:	48                   	dec    %eax                           
  10b350:	3d fd 00 00 00       	cmp    $0xfd,%eax                     
  10b355:	0f 87 ea 00 00 00    	ja     10b445 <pthread_setschedparam+0x191>
  10b35b:	c7 45 dc 03 00 00 00 	movl   $0x3,-0x24(%ebp)               
  10b362:	c7 45 e0 dc b1 10 00 	movl   $0x10b1dc,-0x20(%ebp)          
static inline uint32_t _Protected_heap_Initialize(                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size,                                                 
  uint32_t      page_size                                             
)                                                                     
  10b369:	53                   	push   %ebx                           
  10b36a:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10b36d:	50                   	push   %eax                           
  10b36e:	ff 75 08             	pushl  0x8(%ebp)                      
  10b371:	68 d8 2d 12 00       	push   $0x122dd8                      
  10b376:	e8 e9 1d 00 00       	call   10d164 <_Objects_Get>          
  10b37b:	89 45 d4             	mov    %eax,-0x2c(%ebp)               
  /*                                                                  
   *  Actually change the scheduling policy and parameters            
   */                                                                 
                                                                      
  the_thread = _POSIX_Threads_Get( thread, &location );               
  switch ( location ) {                                               
  10b37e:	83 c4 10             	add    $0x10,%esp                     
  10b381:	b8 03 00 00 00       	mov    $0x3,%eax                      
  10b386:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10b38a:	0f 85 ba 00 00 00    	jne    10b44a <pthread_setschedparam+0x196>
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
  10b390:	8b 45 d4             	mov    -0x2c(%ebp),%eax               
  10b393:	8b 98 f8 00 00 00    	mov    0xf8(%eax),%ebx                
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
  10b399:	83 7b 7c 03          	cmpl   $0x3,0x7c(%ebx)                
  10b39d:	75 12                	jne    10b3b1 <pthread_setschedparam+0xfd>
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
  10b39f:	83 ec 0c             	sub    $0xc,%esp                      
  10b3a2:	8d 83 9c 00 00 00    	lea    0x9c(%ebx),%eax                
  10b3a8:	50                   	push   %eax                           
  10b3a9:	e8 72 35 00 00       	call   10e920 <_Watchdog_Remove>      
  10b3ae:	83 c4 10             	add    $0x10,%esp                     
                                                                      
      api->schedpolicy = policy;                                      
  10b3b1:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  10b3b4:	89 53 7c             	mov    %edx,0x7c(%ebx)                
      api->schedparam  = *param;                                      
  10b3b7:	8d bb 80 00 00 00    	lea    0x80(%ebx),%edi                
  10b3bd:	b9 06 00 00 00       	mov    $0x6,%ecx                      
  10b3c2:	8b 75 10             	mov    0x10(%ebp),%esi                
  10b3c5:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
      the_thread->budget_algorithm = budget_algorithm;                
  10b3c7:	8b 55 dc             	mov    -0x24(%ebp),%edx               
  10b3ca:	8b 45 d4             	mov    -0x2c(%ebp),%eax               
  10b3cd:	89 50 7c             	mov    %edx,0x7c(%eax)                
      the_thread->budget_callout   = budget_callout;                  
  10b3d0:	8b 75 e0             	mov    -0x20(%ebp),%esi               
  10b3d3:	89 b0 80 00 00 00    	mov    %esi,0x80(%eax)                
                                                                      
      switch ( api->schedpolicy ) {                                   
  10b3d9:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  10b3dd:	78 5d                	js     10b43c <pthread_setschedparam+0x188><== NEVER TAKEN
  10b3df:	83 7d 0c 02          	cmpl   $0x2,0xc(%ebp)                 
  10b3e3:	7e 08                	jle    10b3ed <pthread_setschedparam+0x139>
  10b3e5:	83 7d 0c 03          	cmpl   $0x3,0xc(%ebp)                 
  10b3e9:	75 51                	jne    10b43c <pthread_setschedparam+0x188><== NEVER TAKEN
  10b3eb:	eb 25                	jmp    10b412 <pthread_setschedparam+0x15e>
        case SCHED_OTHER:                                             
        case SCHED_FIFO:                                              
        case SCHED_RR:                                                
          the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;  
  10b3ed:	a1 34 2b 12 00       	mov    0x122b34,%eax                  
  10b3f2:	8b 55 d4             	mov    -0x2c(%ebp),%edx               
  10b3f5:	89 42 78             	mov    %eax,0x78(%edx)                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
  10b3f8:	b8 ff 00 00 00       	mov    $0xff,%eax                     
  10b3fd:	2b 83 80 00 00 00    	sub    0x80(%ebx),%eax                
                                                                      
          the_thread->real_priority =                                 
  10b403:	89 42 18             	mov    %eax,0x18(%edx)                
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
  10b406:	51                   	push   %ecx                           
  10b407:	6a 01                	push   $0x1                           
  10b409:	50                   	push   %eax                           
  10b40a:	52                   	push   %edx                           
  10b40b:	e8 74 20 00 00       	call   10d484 <_Thread_Change_priority>
  10b410:	eb 27                	jmp    10b439 <pthread_setschedparam+0x185>
             TRUE                                                     
          );                                                          
          break;                                                      
                                                                      
        case SCHED_SPORADIC:                                          
          api->ss_high_priority = api->schedparam.sched_priority;     
  10b412:	8b 83 80 00 00 00    	mov    0x80(%ebx),%eax                
  10b418:	89 83 98 00 00 00    	mov    %eax,0x98(%ebx)                
          _Watchdog_Remove( &api->Sporadic_timer );                   
  10b41e:	83 ec 0c             	sub    $0xc,%esp                      
  10b421:	8d 83 9c 00 00 00    	lea    0x9c(%ebx),%eax                
  10b427:	50                   	push   %eax                           
  10b428:	e8 f3 34 00 00       	call   10e920 <_Watchdog_Remove>      
          _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );        
  10b42d:	58                   	pop    %eax                           
  10b42e:	5a                   	pop    %edx                           
  10b42f:	ff 75 d4             	pushl  -0x2c(%ebp)                    
  10b432:	6a 00                	push   $0x0                           
  10b434:	e8 e1 fd ff ff       	call   10b21a <_POSIX_Threads_Sporadic_budget_TSR>
  10b439:	83 c4 10             	add    $0x10,%esp                     
          break;                                                      
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
  10b43c:	e8 e3 24 00 00       	call   10d924 <_Thread_Enable_dispatch>
  10b441:	31 c0                	xor    %eax,%eax                      
  10b443:	eb 05                	jmp    10b44a <pthread_setschedparam+0x196>
      return 0;                                                       
  10b445:	b8 16 00 00 00       	mov    $0x16,%eax                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
}                                                                     
  10b44a:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b44d:	5b                   	pop    %ebx                           
  10b44e:	5e                   	pop    %esi                           
  10b44f:	5f                   	pop    %edi                           
  10b450:	c9                   	leave                                 
  10b451:	c3                   	ret                                   
                                                                      

0010e898 <pthread_sigmask>: int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) {
  10e898:	55                   	push   %ebp                           
  10e899:	89 e5                	mov    %esp,%ebp                      
  10e89b:	57                   	push   %edi                           
  10e89c:	56                   	push   %esi                           
  10e89d:	53                   	push   %ebx                           
  10e89e:	83 ec 0c             	sub    $0xc,%esp                      
  10e8a1:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10e8a4:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10e8a7:	8b 55 10             	mov    0x10(%ebp),%edx                
  POSIX_API_Control  *api;                                            
                                                                      
  if ( !set && !oset )                                                
  10e8aa:	85 db                	test   %ebx,%ebx                      
  10e8ac:	0f 94 45 f3          	sete   -0xd(%ebp)                     
  10e8b0:	75 04                	jne    10e8b6 <pthread_sigmask+0x1e>  
  10e8b2:	85 d2                	test   %edx,%edx                      
  10e8b4:	74 4e                	je     10e904 <pthread_sigmask+0x6c>  <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];        
  10e8b6:	8b 3d b8 01 12 00    	mov    0x1201b8,%edi                  
  10e8bc:	8b 8f f8 00 00 00    	mov    0xf8(%edi),%ecx                
                                                                      
  if ( oset )                                                         
  10e8c2:	85 d2                	test   %edx,%edx                      
  10e8c4:	74 08                	je     10e8ce <pthread_sigmask+0x36>  
    *oset = api->signals_blocked;                                     
  10e8c6:	8b 81 c4 00 00 00    	mov    0xc4(%ecx),%eax                
  10e8cc:	89 02                	mov    %eax,(%edx)                    
                                                                      
  if ( !set )                                                         
  10e8ce:	80 7d f3 00          	cmpb   $0x0,-0xd(%ebp)                
  10e8d2:	75 61                	jne    10e935 <pthread_sigmask+0x9d>  <== NEVER TAKEN
    return 0;                                                         
                                                                      
  switch ( how ) {                                                    
  10e8d4:	83 fe 01             	cmp    $0x1,%esi                      
  10e8d7:	74 0b                	je     10e8e4 <pthread_sigmask+0x4c>  
  10e8d9:	83 fe 02             	cmp    $0x2,%esi                      
  10e8dc:	74 10                	je     10e8ee <pthread_sigmask+0x56>  
  10e8de:	85 f6                	test   %esi,%esi                      
  10e8e0:	74 18                	je     10e8fa <pthread_sigmask+0x62>  
  10e8e2:	eb 20                	jmp    10e904 <pthread_sigmask+0x6c>  
    case SIG_BLOCK:                                                   
      api->signals_blocked |= *set;                                   
  10e8e4:	8b 03                	mov    (%ebx),%eax                    
  10e8e6:	09 81 c4 00 00 00    	or     %eax,0xc4(%ecx)                
  10e8ec:	eb 26                	jmp    10e914 <pthread_sigmask+0x7c>  
      break;                                                          
    case SIG_UNBLOCK:                                                 
      api->signals_blocked &= ~*set;                                  
  10e8ee:	8b 03                	mov    (%ebx),%eax                    
  10e8f0:	f7 d0                	not    %eax                           
  10e8f2:	21 81 c4 00 00 00    	and    %eax,0xc4(%ecx)                
  10e8f8:	eb 1a                	jmp    10e914 <pthread_sigmask+0x7c>  
      break;                                                          
    case SIG_SETMASK:                                                 
      api->signals_blocked = *set;                                    
  10e8fa:	8b 03                	mov    (%ebx),%eax                    
  10e8fc:	89 81 c4 00 00 00    	mov    %eax,0xc4(%ecx)                
  10e902:	eb 10                	jmp    10e914 <pthread_sigmask+0x7c>  
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  10e904:	e8 07 16 00 00       	call   10ff10 <__errno>               
  10e909:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10e90f:	83 c8 ff             	or     $0xffffffff,%eax               
  10e912:	eb 23                	jmp    10e937 <pthread_sigmask+0x9f>  
                                                                      
  /* XXX are there critical section problems here? */                 
                                                                      
  /* XXX evaluate the new set */                                      
                                                                      
  if ( ~api->signals_blocked &                                        
  10e914:	8b 15 68 08 12 00    	mov    0x120868,%edx                  
  10e91a:	0b 91 c8 00 00 00    	or     0xc8(%ecx),%edx                
  10e920:	8b 81 c4 00 00 00    	mov    0xc4(%ecx),%eax                
  10e926:	f7 d0                	not    %eax                           
  10e928:	85 c2                	test   %eax,%edx                      
  10e92a:	74 09                	je     10e935 <pthread_sigmask+0x9d>  
       (api->signals_pending | _POSIX_signals_Pending) ) {            
    _Thread_Executing->do_post_task_switch_extension = true;          
  10e92c:	c6 47 75 01          	movb   $0x1,0x75(%edi)                
    _Thread_Dispatch();                                               
  10e930:	e8 6b d2 ff ff       	call   10bba0 <_Thread_Dispatch>      
  10e935:	31 c0                	xor    %eax,%eax                      
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
  10e937:	83 c4 0c             	add    $0xc,%esp                      
  10e93a:	5b                   	pop    %ebx                           
  10e93b:	5e                   	pop    %esi                           
  10e93c:	5f                   	pop    %edi                           
  10e93d:	c9                   	leave                                 
  10e93e:	c3                   	ret                                   
                                                                      

001092ac <pthread_testcancel>: * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) {
  1092ac:	55                   	push   %ebp                           
  1092ad:	89 e5                	mov    %esp,%ebp                      
  1092af:	53                   	push   %ebx                           
  1092b0:	83 ec 04             	sub    $0x4,%esp                      
   *  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() )                                        
  1092b3:	a1 84 f5 11 00       	mov    0x11f584,%eax                  
  1092b8:	85 c0                	test   %eax,%eax                      
  1092ba:	75 46                	jne    109302 <pthread_testcancel+0x56><== NEVER TAKEN
    return;                                                           
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
  1092bc:	a1 a8 f5 11 00       	mov    0x11f5a8,%eax                  
  1092c1:	8b 90 f8 00 00 00    	mov    0xf8(%eax),%edx                
  1092c7:	a1 e8 f4 11 00       	mov    0x11f4e8,%eax                  
  1092cc:	40                   	inc    %eax                           
  1092cd:	a3 e8 f4 11 00       	mov    %eax,0x11f4e8                  
                                                                      
  _Thread_Disable_dispatch();                                         
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
  1092d2:	31 db                	xor    %ebx,%ebx                      
  1092d4:	83 ba cc 00 00 00 00 	cmpl   $0x0,0xcc(%edx)                
  1092db:	75 0a                	jne    1092e7 <pthread_testcancel+0x3b><== NEVER TAKEN
  1092dd:	83 ba d4 00 00 00 00 	cmpl   $0x0,0xd4(%edx)                
  1092e4:	0f 95 c3             	setne  %bl                            
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
  _Thread_Enable_dispatch();                                          
  1092e7:	e8 e0 24 00 00       	call   10b7cc <_Thread_Enable_dispatch>
                                                                      
  if ( cancel )                                                       
  1092ec:	84 db                	test   %bl,%bl                        
  1092ee:	74 12                	je     109302 <pthread_testcancel+0x56>
    _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );        
  1092f0:	50                   	push   %eax                           
  1092f1:	50                   	push   %eax                           
  1092f2:	6a ff                	push   $0xffffffff                    
  1092f4:	ff 35 a8 f5 11 00    	pushl  0x11f5a8                       
  1092fa:	e8 65 fa ff ff       	call   108d64 <_POSIX_Thread_Exit>    
  1092ff:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
}                                                                     
  109302:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109305:	c9                   	leave                                 
  109306:	c3                   	ret                                   
                                                                      

0011575c <read>: ssize_t read( int fd, void *buffer, size_t count ) {
  11575c:	55                   	push   %ebp                           
  11575d:	89 e5                	mov    %esp,%ebp                      
  11575f:	56                   	push   %esi                           
  115760:	53                   	push   %ebx                           
  115761:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115764:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  115767:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  ssize_t      rc;                                                    
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  11576a:	3b 05 d8 92 11 00    	cmp    0x1192d8,%eax                  
  115770:	73 2d                	jae    11579f <read+0x43>             <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  115772:	6b d8 34             	imul   $0x34,%eax,%ebx                
  115775:	03 1d 38 d6 11 00    	add    0x11d638,%ebx                  
  rtems_libio_check_is_open( iop );                                   
  11577b:	8b 53 0c             	mov    0xc(%ebx),%edx                 
  11577e:	f6 c6 01             	test   $0x1,%dh                       
  115781:	74 1c                	je     11579f <read+0x43>             <== NEVER TAKEN
  rtems_libio_check_buffer( buffer );                                 
  115783:	85 f6                	test   %esi,%esi                      
  115785:	75 0d                	jne    115794 <read+0x38>             <== ALWAYS TAKEN
  115787:	e8 9c 99 ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  11578c:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  115792:	eb 2d                	jmp    1157c1 <read+0x65>             <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
  115794:	31 c0                	xor    %eax,%eax                      
  115796:	85 c9                	test   %ecx,%ecx                      
  115798:	74 3c                	je     1157d6 <read+0x7a>             <== NEVER TAKEN
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
  11579a:	80 e2 02             	and    $0x2,%dl                       
  11579d:	75 0d                	jne    1157ac <read+0x50>             <== ALWAYS TAKEN
  11579f:	e8 84 99 ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  1157a4:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  1157aa:	eb 15                	jmp    1157c1 <read+0x65>             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the read().                                         
   */                                                                 
                                                                      
  if ( !iop->handlers->read_h )                                       
  1157ac:	8b 43 30             	mov    0x30(%ebx),%eax                
  1157af:	8b 40 08             	mov    0x8(%eax),%eax                 
  1157b2:	85 c0                	test   %eax,%eax                      
  1157b4:	75 10                	jne    1157c6 <read+0x6a>             <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  1157b6:	e8 6d 99 ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  1157bb:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1157c1:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  1157c4:	eb 10                	jmp    1157d6 <read+0x7a>             <== NOT EXECUTED
                                                                      
  rc = (*iop->handlers->read_h)( iop, buffer, count );                
  1157c6:	52                   	push   %edx                           
  1157c7:	51                   	push   %ecx                           
  1157c8:	56                   	push   %esi                           
  1157c9:	53                   	push   %ebx                           
  1157ca:	ff d0                	call   *%eax                          
                                                                      
  if ( rc > 0 )                                                       
  1157cc:	83 c4 10             	add    $0x10,%esp                     
  1157cf:	85 c0                	test   %eax,%eax                      
  1157d1:	7e 03                	jle    1157d6 <read+0x7a>             
    iop->offset += rc;                                                
  1157d3:	01 43 08             	add    %eax,0x8(%ebx)                 
                                                                      
  return rc;                                                          
}                                                                     
  1157d6:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1157d9:	5b                   	pop    %ebx                           
  1157da:	5e                   	pop    %esi                           
  1157db:	c9                   	leave                                 
  1157dc:	c3                   	ret                                   
                                                                      

00108c94 <readdir>: /* * get next entry in a directory. */ struct dirent * readdir( DIR *dirp ) {
  108c94:	55                   	push   %ebp                           
  108c95:	89 e5                	mov    %esp,%ebp                      
  108c97:	56                   	push   %esi                           
  108c98:	53                   	push   %ebx                           
  108c99:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  register struct dirent *dp;                                         
                                                                      
  if ( !dirp )                                                        
  108c9c:	85 db                	test   %ebx,%ebx                      
  108c9e:	74 5b                	je     108cfb <readdir+0x67>          <== NEVER TAKEN
    return NULL;                                                      
                                                                      
  for (;;) {                                                          
    if (dirp->dd_loc == 0) {                                          
  108ca0:	83 7b 04 00          	cmpl   $0x0,0x4(%ebx)                 
  108ca4:	75 18                	jne    108cbe <readdir+0x2a>          
      dirp->dd_size = getdents (dirp->dd_fd,                          
  108ca6:	50                   	push   %eax                           
  108ca7:	ff 73 10             	pushl  0x10(%ebx)                     
  108caa:	ff 73 0c             	pushl  0xc(%ebx)                      
  108cad:	ff 33                	pushl  (%ebx)                         
  108caf:	e8 18 63 00 00       	call   10efcc <getdents>              
  108cb4:	89 43 08             	mov    %eax,0x8(%ebx)                 
				dirp->dd_buf,                                                     
				dirp->dd_len);                                                    
                                                                      
      if (dirp->dd_size <= 0)                                         
  108cb7:	83 c4 10             	add    $0x10,%esp                     
  108cba:	85 c0                	test   %eax,%eax                      
  108cbc:	7e 3d                	jle    108cfb <readdir+0x67>          
	return NULL;                                                         
    }                                                                 
    if (dirp->dd_loc >= dirp->dd_size) {                              
  108cbe:	8b 4b 04             	mov    0x4(%ebx),%ecx                 
  108cc1:	3b 4b 08             	cmp    0x8(%ebx),%ecx                 
  108cc4:	7c 09                	jl     108ccf <readdir+0x3b>          
      dirp->dd_loc = 0;                                               
  108cc6:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)                 
  108ccd:	eb d1                	jmp    108ca0 <readdir+0xc>           
      continue;                                                       
    }                                                                 
    dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc);              
  108ccf:	89 ca                	mov    %ecx,%edx                      
  108cd1:	03 53 0c             	add    0xc(%ebx),%edx                 
    if ((intptr_t)dp & 03)	/* bogus pointer check */                  
  108cd4:	f6 c2 03             	test   $0x3,%dl                       
  108cd7:	75 22                	jne    108cfb <readdir+0x67>          <== NEVER TAKEN
      return NULL;                                                    
    if (dp->d_reclen <= 0 ||                                          
  108cd9:	8b 42 08             	mov    0x8(%edx),%eax                 
  108cdc:	66 85 c0             	test   %ax,%ax                        
  108cdf:	74 1a                	je     108cfb <readdir+0x67>          <== NEVER TAKEN
  108ce1:	0f b7 f0             	movzwl %ax,%esi                       
  108ce4:	8b 43 10             	mov    0x10(%ebx),%eax                
  108ce7:	40                   	inc    %eax                           
  108ce8:	29 c8                	sub    %ecx,%eax                      
  108cea:	39 c6                	cmp    %eax,%esi                      
  108cec:	7f 0d                	jg     108cfb <readdir+0x67>          <== NEVER TAKEN
	dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc)                      
      return NULL;                                                    
    dirp->dd_loc += dp->d_reclen;                                     
  108cee:	8d 04 0e             	lea    (%esi,%ecx,1),%eax             
  108cf1:	89 43 04             	mov    %eax,0x4(%ebx)                 
    if (dp->d_ino == 0)                                               
  108cf4:	83 3a 00             	cmpl   $0x0,(%edx)                    
  108cf7:	74 a7                	je     108ca0 <readdir+0xc>           <== NEVER TAKEN
  108cf9:	eb 02                	jmp    108cfd <readdir+0x69>          
  108cfb:	31 d2                	xor    %edx,%edx                      
      continue;                                                       
    return (dp);                                                      
  }                                                                   
}                                                                     
  108cfd:	89 d0                	mov    %edx,%eax                      
  108cff:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108d02:	5b                   	pop    %ebx                           
  108d03:	5e                   	pop    %esi                           
  108d04:	c9                   	leave                                 
  108d05:	c3                   	ret                                   
                                                                      

00109440 <readlink>: ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) {
  109440:	55                   	push   %ebp                           
  109441:	89 e5                	mov    %esp,%ebp                      
  109443:	57                   	push   %edi                           
  109444:	56                   	push   %esi                           
  109445:	53                   	push   %ebx                           
  109446:	83 ec 1c             	sub    $0x1c,%esp                     
  109449:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if (!buf)                                                           
  10944c:	85 ff                	test   %edi,%edi                      
  10944e:	75 0d                	jne    10945d <readlink+0x1d>         <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EFAULT );                   
  109450:	e8 1b 92 00 00       	call   112670 <__errno>               <== NOT EXECUTED
  109455:	c7 00 0e 00 00 00    	movl   $0xe,(%eax)                    <== NOT EXECUTED
  10945b:	eb 43                	jmp    1094a0 <readlink+0x60>         <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false );
  10945d:	6a 00                	push   $0x0                           
  10945f:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  109462:	56                   	push   %esi                           
  109463:	6a 00                	push   $0x0                           
  109465:	ff 75 08             	pushl  0x8(%ebp)                      
  109468:	e8 3d ed ff ff       	call   1081aa <rtems_filesystem_evaluate_path>
  if ( result != 0 )                                                  
  10946d:	83 c4 10             	add    $0x10,%esp                     
  109470:	83 cb ff             	or     $0xffffffff,%ebx               
  109473:	85 c0                	test   %eax,%eax                      
  109475:	0f 85 87 00 00 00    	jne    109502 <readlink+0xc2>         <== NEVER TAKEN
     return -1;                                                       
                                                                      
  if ( !loc.ops->node_type_h ){                                       
  10947b:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10947e:	8b 50 10             	mov    0x10(%eax),%edx                
  109481:	85 d2                	test   %edx,%edx                      
  109483:	75 20                	jne    1094a5 <readlink+0x65>         <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  109485:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  109488:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10948a:	74 09                	je     109495 <readlink+0x55>         <== NOT EXECUTED
  10948c:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10948f:	56                   	push   %esi                           <== NOT EXECUTED
  109490:	ff d0                	call   *%eax                          <== NOT EXECUTED
  109492:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  109495:	e8 d6 91 00 00       	call   112670 <__errno>               <== NOT EXECUTED
  10949a:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1094a0:	83 cb ff             	or     $0xffffffff,%ebx               
  1094a3:	eb 5d                	jmp    109502 <readlink+0xc2>         
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
  1094a5:	83 ec 0c             	sub    $0xc,%esp                      
  1094a8:	56                   	push   %esi                           
  1094a9:	ff d2                	call   *%edx                          
  1094ab:	83 c4 10             	add    $0x10,%esp                     
  1094ae:	83 f8 04             	cmp    $0x4,%eax                      
  1094b1:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  1094b4:	74 21                	je     1094d7 <readlink+0x97>         
    rtems_filesystem_freenode( &loc );                                
  1094b6:	85 c0                	test   %eax,%eax                      
  1094b8:	74 10                	je     1094ca <readlink+0x8a>         <== NEVER TAKEN
  1094ba:	8b 40 1c             	mov    0x1c(%eax),%eax                
  1094bd:	85 c0                	test   %eax,%eax                      
  1094bf:	74 09                	je     1094ca <readlink+0x8a>         <== NEVER TAKEN
  1094c1:	83 ec 0c             	sub    $0xc,%esp                      
  1094c4:	56                   	push   %esi                           
  1094c5:	ff d0                	call   *%eax                          
  1094c7:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  1094ca:	e8 a1 91 00 00       	call   112670 <__errno>               
  1094cf:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  1094d5:	eb c9                	jmp    1094a0 <readlink+0x60>         
  }                                                                   
                                                                      
  if ( !loc.ops->readlink_h ){                                        
  1094d7:	8b 50 3c             	mov    0x3c(%eax),%edx                
  1094da:	85 d2                	test   %edx,%edx                      
  1094dc:	74 a7                	je     109485 <readlink+0x45>         <== NEVER TAKEN
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result =  (*loc.ops->readlink_h)( &loc, buf, bufsize );             
  1094de:	50                   	push   %eax                           
  1094df:	ff 75 10             	pushl  0x10(%ebp)                     
  1094e2:	57                   	push   %edi                           
  1094e3:	56                   	push   %esi                           
  1094e4:	ff d2                	call   *%edx                          
  1094e6:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  1094e8:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  1094eb:	83 c4 10             	add    $0x10,%esp                     
  1094ee:	85 c0                	test   %eax,%eax                      
  1094f0:	74 10                	je     109502 <readlink+0xc2>         <== NEVER TAKEN
  1094f2:	8b 40 1c             	mov    0x1c(%eax),%eax                
  1094f5:	85 c0                	test   %eax,%eax                      
  1094f7:	74 09                	je     109502 <readlink+0xc2>         <== NEVER TAKEN
  1094f9:	83 ec 0c             	sub    $0xc,%esp                      
  1094fc:	56                   	push   %esi                           
  1094fd:	ff d0                	call   *%eax                          
  1094ff:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  109502:	89 d8                	mov    %ebx,%eax                      
  109504:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109507:	5b                   	pop    %ebx                           
  109508:	5e                   	pop    %esi                           
  109509:	5f                   	pop    %edi                           
  10950a:	c9                   	leave                                 
  10950b:	c3                   	ret                                   
                                                                      

0011585c <realloc>: { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1);
  11585c:	55                   	push   %ebp                           
  11585d:	89 e5                	mov    %esp,%ebp                      
  11585f:	57                   	push   %edi                           
  115860:	56                   	push   %esi                           
  115861:	53                   	push   %ebx                           
  115862:	83 ec 1c             	sub    $0x1c,%esp                     
  115865:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  115868:	ff 05 b8 d6 11 00    	incl   0x11d6b8                       
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
  11586e:	83 3d 38 d9 11 00 03 	cmpl   $0x3,0x11d938                  
  115875:	75 1a                	jne    115891 <realloc+0x35>          <== NEVER TAKEN
    if (_Thread_Dispatch_disable_level > 0)                           
  115877:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  11587c:	85 c0                	test   %eax,%eax                      
  11587e:	0f 85 b7 00 00 00    	jne    11593b <realloc+0xdf>          <== NEVER TAKEN
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
  115884:	a1 34 d8 11 00       	mov    0x11d834,%eax                  
  115889:	85 c0                	test   %eax,%eax                      
  11588b:	0f 85 aa 00 00 00    	jne    11593b <realloc+0xdf>          <== NEVER TAKEN
  }                                                                   
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
  115891:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  115895:	75 0e                	jne    1158a5 <realloc+0x49>          <== ALWAYS TAKEN
    return malloc( size );                                            
  115897:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  11589a:	53                   	push   %ebx                           <== NOT EXECUTED
  11589b:	e8 d4 0d ff ff       	call   106674 <malloc>                <== NOT EXECUTED
  1158a0:	e9 8e 00 00 00       	jmp    115933 <realloc+0xd7>          <== NOT EXECUTED
                                                                      
  if ( !size ) {                                                      
  1158a5:	85 db                	test   %ebx,%ebx                      
  1158a7:	75 14                	jne    1158bd <realloc+0x61>          <== ALWAYS TAKEN
    free( ptr );                                                      
  1158a9:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1158ac:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  1158af:	e8 c4 0b ff ff       	call   106478 <free>                  <== NOT EXECUTED
  1158b4:	c7 45 08 00 00 00 00 	movl   $0x0,0x8(%ebp)                 <== NOT EXECUTED
  1158bb:	eb 79                	jmp    115936 <realloc+0xda>          <== NOT EXECUTED
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
  1158bd:	52                   	push   %edx                           
  1158be:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  1158c1:	50                   	push   %eax                           
  1158c2:	ff 75 08             	pushl  0x8(%ebp)                      
  1158c5:	68 50 d6 11 00       	push   $0x11d650                      
  1158ca:	e8 05 01 00 00       	call   1159d4 <_Protected_heap_Get_block_size>
  1158cf:	83 c4 10             	add    $0x10,%esp                     
  1158d2:	84 c0                	test   %al,%al                        
  1158d4:	75 0d                	jne    1158e3 <realloc+0x87>          
    errno = EINVAL;                                                   
  1158d6:	e8 4d 98 ff ff       	call   10f128 <__errno>               
  1158db:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  1158e1:	eb 58                	jmp    11593b <realloc+0xdf>          
  #if defined(RTEMS_MALLOC_BOUNDARY_HELPERS)                          
    if (rtems_malloc_boundary_helpers)                                
      resize += (*rtems_malloc_boundary_helpers->overhead)();         
  #endif                                                              
                                                                      
  if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) {
  1158e3:	50                   	push   %eax                           
  1158e4:	53                   	push   %ebx                           
  1158e5:	ff 75 08             	pushl  0x8(%ebp)                      
  1158e8:	68 50 d6 11 00       	push   $0x11d650                      
  1158ed:	e8 1a 01 00 00       	call   115a0c <_Protected_heap_Resize_block>
  1158f2:	83 c4 10             	add    $0x10,%esp                     
  1158f5:	84 c0                	test   %al,%al                        
  1158f7:	75 49                	jne    115942 <realloc+0xe6>          
   *  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 );                                          
  1158f9:	83 ec 0c             	sub    $0xc,%esp                      
  1158fc:	53                   	push   %ebx                           
  1158fd:	e8 72 0d ff ff       	call   106674 <malloc>                
  115902:	89 45 d8             	mov    %eax,-0x28(%ebp)               
                                                                      
  MSBUMP(malloc_calls, -1);   /* subtract off the malloc */           
  115905:	ff 0d ac d6 11 00    	decl   0x11d6ac                       
                                                                      
  if ( !new_area ) {                                                  
  11590b:	83 c4 10             	add    $0x10,%esp                     
  11590e:	85 c0                	test   %eax,%eax                      
  115910:	74 29                	je     11593b <realloc+0xdf>          <== NEVER TAKEN
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
  115912:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  115915:	89 d9                	mov    %ebx,%ecx                      
  115917:	39 c3                	cmp    %eax,%ebx                      
  115919:	76 02                	jbe    11591d <realloc+0xc1>          <== NEVER TAKEN
  11591b:	89 c1                	mov    %eax,%ecx                      
  11591d:	8b 7d d8             	mov    -0x28(%ebp),%edi               
  115920:	8b 75 08             	mov    0x8(%ebp),%esi                 
  115923:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)       
  free( ptr );                                                        
  115925:	83 ec 0c             	sub    $0xc,%esp                      
  115928:	ff 75 08             	pushl  0x8(%ebp)                      
  11592b:	e8 48 0b ff ff       	call   106478 <free>                  
  115930:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  115933:	89 45 08             	mov    %eax,0x8(%ebp)                 
  115936:	83 c4 10             	add    $0x10,%esp                     
  115939:	eb 07                	jmp    115942 <realloc+0xe6>          
                                                                      
  return new_area;                                                    
  11593b:	c7 45 08 00 00 00 00 	movl   $0x0,0x8(%ebp)                 
                                                                      
}                                                                     
  115942:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115945:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  115948:	5b                   	pop    %ebx                           
  115949:	5e                   	pop    %esi                           
  11594a:	5f                   	pop    %edi                           
  11594b:	c9                   	leave                                 
  11594c:	c3                   	ret                                   
                                                                      

00108d08 <rewinddir>: #include <unistd.h> void rewinddir( DIR *dirp ) {
  108d08:	55                   	push   %ebp                           
  108d09:	89 e5                	mov    %esp,%ebp                      
  108d0b:	53                   	push   %ebx                           
  108d0c:	83 ec 04             	sub    $0x4,%esp                      
  108d0f:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  off_t status;                                                       
                                                                      
  if ( !dirp )                                                        
  108d12:	85 db                	test   %ebx,%ebx                      
  108d14:	74 19                	je     108d2f <rewinddir+0x27>        
    return;                                                           
                                                                      
  status = lseek( dirp->dd_fd, 0, SEEK_SET );                         
  108d16:	50                   	push   %eax                           
  108d17:	6a 00                	push   $0x0                           
  108d19:	6a 00                	push   $0x0                           
  108d1b:	ff 33                	pushl  (%ebx)                         
  108d1d:	e8 ba f0 ff ff       	call   107ddc <lseek>                 
                                                                      
  if( status == -1 )                                                  
  108d22:	83 c4 10             	add    $0x10,%esp                     
  108d25:	40                   	inc    %eax                           
  108d26:	74 07                	je     108d2f <rewinddir+0x27>        <== NEVER TAKEN
    return;                                                           
                                                                      
  dirp->dd_loc = 0;                                                   
  108d28:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)                 
}                                                                     
  108d2f:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  108d32:	c9                   	leave                                 
  108d33:	c3                   	ret                                   
                                                                      

0010960c <rmdir>: #include <rtems/seterr.h> int rmdir( const char *pathname ) {
  10960c:	55                   	push   %ebp                           
  10960d:	89 e5                	mov    %esp,%ebp                      
  10960f:	56                   	push   %esi                           
  109610:	53                   	push   %ebx                           
  109611:	83 ec 10             	sub    $0x10,%esp                     
                                                                      
  /*                                                                  
   *  Get the node where we wish to go.                               
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false );
  109614:	6a 00                	push   $0x0                           
  109616:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  109619:	56                   	push   %esi                           
  10961a:	6a 00                	push   $0x0                           
  10961c:	ff 75 08             	pushl  0x8(%ebp)                      
  10961f:	e8 5a ec ff ff       	call   10827e <rtems_filesystem_evaluate_path>
  if ( result != 0 )                                                  
  109624:	83 c4 10             	add    $0x10,%esp                     
  109627:	85 c0                	test   %eax,%eax                      
  109629:	0f 85 be 00 00 00    	jne    1096ed <rmdir+0xe1>            
     return -1;                                                       
                                                                      
  result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc );
  10962f:	50                   	push   %eax                           
  109630:	50                   	push   %eax                           
  109631:	56                   	push   %esi                           
  109632:	6a 02                	push   $0x2                           
  109634:	e8 cf eb ff ff       	call   108208 <rtems_filesystem_evaluate_parent>
  if (result != 0) {                                                  
  109639:	83 c4 10             	add    $0x10,%esp                     
  10963c:	85 c0                	test   %eax,%eax                      
  10963e:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  109641:	74 21                	je     109664 <rmdir+0x58>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  109643:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  109645:	0f 84 a2 00 00 00    	je     1096ed <rmdir+0xe1>            <== NOT EXECUTED
  10964b:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  10964e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  109650:	0f 84 97 00 00 00    	je     1096ed <rmdir+0xe1>            <== NOT EXECUTED
  109656:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  109659:	56                   	push   %esi                           <== NOT EXECUTED
  10965a:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10965c:	83 cb ff             	or     $0xffffffff,%ebx               <== NOT EXECUTED
  10965f:	e9 84 00 00 00       	jmp    1096e8 <rmdir+0xdc>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify you can remove this node as a directory.                  
   */                                                                 
                                                                      
  if ( !loc.ops->node_type_h ){                                       
  109664:	8b 50 10             	mov    0x10(%eax),%edx                
  109667:	85 d2                	test   %edx,%edx                      
  109669:	74 41                	je     1096ac <rmdir+0xa0>            <== NEVER TAKEN
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){
  10966b:	83 ec 0c             	sub    $0xc,%esp                      
  10966e:	56                   	push   %esi                           
  10966f:	ff d2                	call   *%edx                          
  109671:	83 c4 10             	add    $0x10,%esp                     
  109674:	48                   	dec    %eax                           
  109675:	74 24                	je     10969b <rmdir+0x8f>            
    rtems_filesystem_freenode( &loc );                                
  109677:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10967a:	85 c0                	test   %eax,%eax                      
  10967c:	74 10                	je     10968e <rmdir+0x82>            <== NEVER TAKEN
  10967e:	8b 40 1c             	mov    0x1c(%eax),%eax                
  109681:	85 c0                	test   %eax,%eax                      
  109683:	74 09                	je     10968e <rmdir+0x82>            <== NEVER TAKEN
  109685:	83 ec 0c             	sub    $0xc,%esp                      
  109688:	56                   	push   %esi                           
  109689:	ff d0                	call   *%eax                          
  10968b:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  10968e:	e8 65 8c 00 00       	call   1122f8 <__errno>               
  109693:	c7 00 14 00 00 00    	movl   $0x14,(%eax)                   
  109699:	eb 52                	jmp    1096ed <rmdir+0xe1>            
                                                                      
  /*                                                                  
   * Use the filesystems rmnod to remove the node.                    
   */                                                                 
                                                                      
  if ( !loc.handlers->rmnod_h ){                                      
  10969b:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10969e:	8b 40 34             	mov    0x34(%eax),%eax                
  1096a1:	85 c0                	test   %eax,%eax                      
  1096a3:	75 24                	jne    1096c9 <rmdir+0xbd>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  1096a5:	8b 45 f0             	mov    -0x10(%ebp),%eax               <== NOT EXECUTED
  1096a8:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1096aa:	74 10                	je     1096bc <rmdir+0xb0>            <== NOT EXECUTED
  1096ac:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  1096af:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1096b1:	74 09                	je     1096bc <rmdir+0xb0>            <== NOT EXECUTED
  1096b3:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1096b6:	56                   	push   %esi                           <== NOT EXECUTED
  1096b7:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1096b9:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  1096bc:	e8 37 8c 00 00       	call   1122f8 <__errno>               <== NOT EXECUTED
  1096c1:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1096c7:	eb 24                	jmp    1096ed <rmdir+0xe1>            <== NOT EXECUTED
  }                                                                   
                                                                      
  result =  (*loc.handlers->rmnod_h)( &loc );                         
  1096c9:	83 ec 0c             	sub    $0xc,%esp                      
  1096cc:	56                   	push   %esi                           
  1096cd:	ff d0                	call   *%eax                          
  1096cf:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  1096d1:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  1096d4:	83 c4 10             	add    $0x10,%esp                     
  1096d7:	85 c0                	test   %eax,%eax                      
  1096d9:	74 15                	je     1096f0 <rmdir+0xe4>            <== NEVER TAKEN
  1096db:	8b 40 1c             	mov    0x1c(%eax),%eax                
  1096de:	85 c0                	test   %eax,%eax                      
  1096e0:	74 0e                	je     1096f0 <rmdir+0xe4>            <== NEVER TAKEN
  1096e2:	83 ec 0c             	sub    $0xc,%esp                      
  1096e5:	56                   	push   %esi                           
  1096e6:	ff d0                	call   *%eax                          
  1096e8:	83 c4 10             	add    $0x10,%esp                     
  1096eb:	eb 03                	jmp    1096f0 <rmdir+0xe4>            
  1096ed:	83 cb ff             	or     $0xffffffff,%ebx               
                                                                      
  return result;                                                      
}                                                                     
  1096f0:	89 d8                	mov    %ebx,%eax                      
  1096f2:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1096f5:	5b                   	pop    %ebx                           
  1096f6:	5e                   	pop    %esi                           
  1096f7:	c9                   	leave                                 
  1096f8:	c3                   	ret                                   
                                                                      

0010ffd8 <rtems_assoc_name_bad>: const char * rtems_assoc_name_bad( uint32_t bad_value ) {
  10ffd8:	55                   	push   %ebp                           <== NOT EXECUTED
  10ffd9:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
    sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else                                                                 
    static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";      
#endif                                                                
    return bad_buffer;                                                
}                                                                     
  10ffdb:	b8 80 f4 11 00       	mov    $0x11f480,%eax                 <== NOT EXECUTED
  10ffe0:	c9                   	leave                                 <== NOT EXECUTED
  10ffe1:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010e288 <rtems_assoc_name_by_local>: const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
  10e288:	55                   	push   %ebp                           <== NOT EXECUTED
  10e289:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10e28b:	53                   	push   %ebx                           <== NOT EXECUTED
  10e28c:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10e28f:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  10e292:	53                   	push   %ebx                           <== NOT EXECUTED
  10e293:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  10e296:	e8 1d 00 00 00       	call   10e2b8 <rtems_assoc_ptr_by_local><== NOT EXECUTED
  if (nap)                                                            
  10e29b:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10e29e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10e2a0:	74 07                	je     10e2a9 <rtems_assoc_name_by_local+0x21><== NOT EXECUTED
    return nap->name;                                                 
  10e2a2:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
                                                                      
  return rtems_assoc_name_bad(local_value);                           
}                                                                     
  10e2a4:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10e2a7:	c9                   	leave                                 <== NOT EXECUTED
  10e2a8:	c3                   	ret                                   <== NOT EXECUTED
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
  10e2a9:	89 5d 08             	mov    %ebx,0x8(%ebp)                 <== NOT EXECUTED
}                                                                     
  10e2ac:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10e2af:	c9                   	leave                                 <== NOT EXECUTED
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
  10e2b0:	e9 23 1d 00 00       	jmp    10ffd8 <rtems_assoc_name_bad>  <== NOT EXECUTED
                                                                      

0010f0a4 <rtems_assoc_ptr_by_local>: const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
  10f0a4:	55                   	push   %ebp                           
  10f0a5:	89 e5                	mov    %esp,%ebp                      
  10f0a7:	56                   	push   %esi                           
  10f0a8:	53                   	push   %ebx                           
  10f0a9:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10f0ac:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
  10f0af:	8b 03                	mov    (%ebx),%eax                    
  10f0b1:	85 c0                	test   %eax,%eax                      
  10f0b3:	74 1b                	je     10f0d0 <rtems_assoc_ptr_by_local+0x2c><== NEVER TAKEN
  10f0b5:	52                   	push   %edx                           
  10f0b6:	52                   	push   %edx                           
  10f0b7:	68 09 7b 11 00       	push   $0x117b09                      
  10f0bc:	50                   	push   %eax                           
  10f0bd:	e8 62 11 00 00       	call   110224 <strcmp>                
  10f0c2:	83 c4 10             	add    $0x10,%esp                     
  10f0c5:	85 c0                	test   %eax,%eax                      
  10f0c7:	75 07                	jne    10f0d0 <rtems_assoc_ptr_by_local+0x2c><== ALWAYS TAKEN
    default_ap = ap++;                                                
  10f0c9:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  10f0cb:	83 c3 0c             	add    $0xc,%ebx                      <== NOT EXECUTED
  10f0ce:	eb 0c                	jmp    10f0dc <rtems_assoc_ptr_by_local+0x38><== NOT EXECUTED
  10f0d0:	31 c0                	xor    %eax,%eax                      
  10f0d2:	eb 08                	jmp    10f0dc <rtems_assoc_ptr_by_local+0x38>
                                                                      
  for ( ; ap->name; ap++)                                             
    if (ap->local_value == local_value)                               
  10f0d4:	39 73 04             	cmp    %esi,0x4(%ebx)                 
  10f0d7:	74 0a                	je     10f0e3 <rtems_assoc_ptr_by_local+0x3f>
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
  10f0d9:	83 c3 0c             	add    $0xc,%ebx                      
  10f0dc:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10f0df:	75 f3                	jne    10f0d4 <rtems_assoc_ptr_by_local+0x30>
  10f0e1:	89 c3                	mov    %eax,%ebx                      
    if (ap->local_value == local_value)                               
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
  10f0e3:	89 d8                	mov    %ebx,%eax                      
  10f0e5:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10f0e8:	5b                   	pop    %ebx                           
  10f0e9:	5e                   	pop    %esi                           
  10f0ea:	c9                   	leave                                 
  10f0eb:	c3                   	ret                                   
                                                                      

0010e970 <rtems_assoc_ptr_by_remote>: const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) {
  10e970:	55                   	push   %ebp                           
  10e971:	89 e5                	mov    %esp,%ebp                      
  10e973:	56                   	push   %esi                           
  10e974:	53                   	push   %ebx                           
  10e975:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10e978:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
  10e97b:	8b 03                	mov    (%ebx),%eax                    
  10e97d:	85 c0                	test   %eax,%eax                      
  10e97f:	74 1b                	je     10e99c <rtems_assoc_ptr_by_remote+0x2c><== NEVER TAKEN
  10e981:	52                   	push   %edx                           
  10e982:	52                   	push   %edx                           
  10e983:	68 09 7b 11 00       	push   $0x117b09                      
  10e988:	50                   	push   %eax                           
  10e989:	e8 96 18 00 00       	call   110224 <strcmp>                
  10e98e:	83 c4 10             	add    $0x10,%esp                     
  10e991:	85 c0                	test   %eax,%eax                      
  10e993:	75 07                	jne    10e99c <rtems_assoc_ptr_by_remote+0x2c><== ALWAYS TAKEN
    default_ap = ap++;                                                
  10e995:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  10e997:	83 c3 0c             	add    $0xc,%ebx                      <== NOT EXECUTED
  10e99a:	eb 0c                	jmp    10e9a8 <rtems_assoc_ptr_by_remote+0x38><== NOT EXECUTED
  10e99c:	31 c0                	xor    %eax,%eax                      
  10e99e:	eb 08                	jmp    10e9a8 <rtems_assoc_ptr_by_remote+0x38>
                                                                      
  for ( ; ap->name; ap++)                                             
    if (ap->remote_value == remote_value)                             
  10e9a0:	39 73 08             	cmp    %esi,0x8(%ebx)                 
  10e9a3:	74 0a                	je     10e9af <rtems_assoc_ptr_by_remote+0x3f>
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
  10e9a5:	83 c3 0c             	add    $0xc,%ebx                      
  10e9a8:	83 3b 00             	cmpl   $0x0,(%ebx)                    
  10e9ab:	75 f3                	jne    10e9a0 <rtems_assoc_ptr_by_remote+0x30>
  10e9ad:	89 c3                	mov    %eax,%ebx                      
    if (ap->remote_value == remote_value)                             
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
  10e9af:	89 d8                	mov    %ebx,%eax                      
  10e9b1:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10e9b4:	5b                   	pop    %ebx                           
  10e9b5:	5e                   	pop    %esi                           
  10e9b6:	c9                   	leave                                 
  10e9b7:	c3                   	ret                                   
                                                                      

0010e9b8 <rtems_assoc_remote_by_local>: uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
  10e9b8:	55                   	push   %ebp                           <== NOT EXECUTED
  10e9b9:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10e9bb:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  10e9be:	ff 75 0c             	pushl  0xc(%ebp)                      <== NOT EXECUTED
  10e9c1:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  10e9c4:	e8 db 06 00 00       	call   10f0a4 <rtems_assoc_ptr_by_local><== NOT EXECUTED
  10e9c9:	89 c2                	mov    %eax,%edx                      <== NOT EXECUTED
  if (nap)                                                            
  10e9cb:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10e9ce:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  10e9d0:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  10e9d2:	74 03                	je     10e9d7 <rtems_assoc_remote_by_local+0x1f><== NOT EXECUTED
    return nap->remote_value;                                         
  10e9d4:	8b 42 08             	mov    0x8(%edx),%eax                 <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
  10e9d7:	c9                   	leave                                 <== NOT EXECUTED
  10e9d8:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00109568 <rtems_barrier_create>: rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) {
  109568:	55                   	push   %ebp                           
  109569:	89 e5                	mov    %esp,%ebp                      
  10956b:	57                   	push   %edi                           
  10956c:	56                   	push   %esi                           
  10956d:	53                   	push   %ebx                           
  10956e:	83 ec 1c             	sub    $0x1c,%esp                     
  109571:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  109574:	8b 55 10             	mov    0x10(%ebp),%edx                
  109577:	8b 7d 14             	mov    0x14(%ebp),%edi                
  Barrier_Control         *the_barrier;                               
  CORE_barrier_Attributes  the_attributes;                            
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  10957a:	b8 03 00 00 00       	mov    $0x3,%eax                      
  10957f:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  109583:	0f 84 90 00 00 00    	je     109619 <rtems_barrier_create+0xb1><== NEVER TAKEN
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
  109589:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10958e:	85 ff                	test   %edi,%edi                      
  109590:	0f 84 83 00 00 00    	je     109619 <rtems_barrier_create+0xb1><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Initialize core barrier attributes */                            
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
  109596:	f7 c6 10 00 00 00    	test   $0x10,%esi                     
  10959c:	74 12                	je     1095b0 <rtems_barrier_create+0x48>
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
    if ( maximum_waiters == 0 )                                       
  10959e:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  1095a3:	85 d2                	test   %edx,%edx                      
  1095a5:	74 72                	je     109619 <rtems_barrier_create+0xb1>
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Initialize core barrier attributes */                            
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
  1095a7:	c7 45 ec 00 00 00 00 	movl   $0x0,-0x14(%ebp)               
  1095ae:	eb 07                	jmp    1095b7 <rtems_barrier_create+0x4f>
    if ( maximum_waiters == 0 )                                       
      return RTEMS_INVALID_NUMBER;                                    
  } else                                                              
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;          
  1095b0:	c7 45 ec 01 00 00 00 	movl   $0x1,-0x14(%ebp)               
  the_attributes.maximum_count = maximum_waiters;                     
  1095b7:	89 55 f0             	mov    %edx,-0x10(%ebp)               
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  1095ba:	a1 cc 12 12 00       	mov    0x1212cc,%eax                  
  1095bf:	40                   	inc    %eax                           
  1095c0:	a3 cc 12 12 00       	mov    %eax,0x1212cc                  
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
  1095c5:	83 ec 0c             	sub    $0xc,%esp                      
  1095c8:	68 d4 11 12 00       	push   $0x1211d4                      
  1095cd:	e8 62 1b 00 00       	call   10b134 <_Objects_Allocate>     
  1095d2:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _Barrier_Allocate();                                  
                                                                      
  if ( !the_barrier ) {                                               
  1095d4:	83 c4 10             	add    $0x10,%esp                     
  1095d7:	85 c0                	test   %eax,%eax                      
  1095d9:	75 0c                	jne    1095e7 <rtems_barrier_create+0x7f>
    _Thread_Enable_dispatch();                                        
  1095db:	e8 58 27 00 00       	call   10bd38 <_Thread_Enable_dispatch>
  1095e0:	b8 05 00 00 00       	mov    $0x5,%eax                      
  1095e5:	eb 32                	jmp    109619 <rtems_barrier_create+0xb1>
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_barrier->attribute_set = attribute_set;                         
  1095e7:	89 70 10             	mov    %esi,0x10(%eax)                
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
  1095ea:	50                   	push   %eax                           
  1095eb:	50                   	push   %eax                           
  1095ec:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  1095ef:	50                   	push   %eax                           
  1095f0:	8d 43 14             	lea    0x14(%ebx),%eax                
  1095f3:	50                   	push   %eax                           
  1095f4:	e8 07 13 00 00       	call   10a900 <_CORE_barrier_Initialize>
  1095f9:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  1095fc:	0f b7 d1             	movzwl %cx,%edx                       
  1095ff:	a1 f0 11 12 00       	mov    0x1211f0,%eax                  
  109604:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  109607:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10960a:	89 43 0c             	mov    %eax,0xc(%ebx)                 
    &_Barrier_Information,                                            
    &the_barrier->Object,                                             
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_barrier->Object.id;                                       
  10960d:	89 0f                	mov    %ecx,(%edi)                    
                                                                      
  _Thread_Enable_dispatch();                                          
  10960f:	e8 24 27 00 00       	call   10bd38 <_Thread_Enable_dispatch>
  109614:	31 c0                	xor    %eax,%eax                      
  109616:	83 c4 10             	add    $0x10,%esp                     
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  109619:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10961c:	5b                   	pop    %ebx                           
  10961d:	5e                   	pop    %esi                           
  10961e:	5f                   	pop    %edi                           
  10961f:	c9                   	leave                                 
  109620:	c3                   	ret                                   
                                                                      

001096a8 <rtems_barrier_release>: rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) {
  1096a8:	55                   	push   %ebp                           
  1096a9:	89 e5                	mov    %esp,%ebp                      
  1096ab:	56                   	push   %esi                           
  1096ac:	53                   	push   %ebx                           
  1096ad:	83 ec 10             	sub    $0x10,%esp                     
  1096b0:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  1096b3:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !released )                                                    
  1096b6:	b8 09 00 00 00       	mov    $0x9,%eax                      
  1096bb:	85 f6                	test   %esi,%esi                      
  1096bd:	74 39                	je     1096f8 <rtems_barrier_release+0x50><== NEVER TAKEN
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory 
 *         to add to the heap                                         
  1096bf:	52                   	push   %edx                           
  1096c0:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  1096c3:	50                   	push   %eax                           
  1096c4:	53                   	push   %ebx                           
  1096c5:	68 d4 11 12 00       	push   $0x1211d4                      
  1096ca:	e8 a9 1e 00 00       	call   10b578 <_Objects_Get>          
  1096cf:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
  1096d1:	83 c4 10             	add    $0x10,%esp                     
  1096d4:	b8 04 00 00 00       	mov    $0x4,%eax                      
  1096d9:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  1096dd:	75 19                	jne    1096f8 <rtems_barrier_release+0x50>
                                                                      
    case OBJECTS_LOCAL:                                               
      *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
  1096df:	50                   	push   %eax                           
  1096e0:	6a 00                	push   $0x0                           
  1096e2:	53                   	push   %ebx                           
  1096e3:	8d 42 14             	lea    0x14(%edx),%eax                
  1096e6:	50                   	push   %eax                           
  1096e7:	e8 48 12 00 00       	call   10a934 <_CORE_barrier_Release> 
  1096ec:	89 06                	mov    %eax,(%esi)                    
      _Thread_Enable_dispatch();                                      
  1096ee:	e8 45 26 00 00       	call   10bd38 <_Thread_Enable_dispatch>
  1096f3:	31 c0                	xor    %eax,%eax                      
  1096f5:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  1096f8:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1096fb:	5b                   	pop    %ebx                           
  1096fc:	5e                   	pop    %esi                           
  1096fd:	c9                   	leave                                 
  1096fe:	c3                   	ret                                   
                                                                      

00108984 <rtems_clock_get>: rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) {
  108984:	55                   	push   %ebp                           
  108985:	89 e5                	mov    %esp,%ebp                      
  108987:	53                   	push   %ebx                           
  108988:	83 ec 04             	sub    $0x4,%esp                      
  10898b:	8b 55 08             	mov    0x8(%ebp),%edx                 
  10898e:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  if ( !time_buffer )                                                 
  108991:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108996:	85 db                	test   %ebx,%ebx                      
  108998:	74 44                	je     1089de <rtems_clock_get+0x5a>  <== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  switch ( option ) {                                                 
  10899a:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  10899f:	83 fa 04             	cmp    $0x4,%edx                      
  1089a2:	77 3a                	ja     1089de <rtems_clock_get+0x5a>  
  1089a4:	ff 24 95 58 72 11 00 	jmp    *0x117258(,%edx,4)             
    case RTEMS_CLOCK_GET_TOD:                                         
      return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 
  1089ab:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
  1089ae:	58                   	pop    %eax                           
  1089af:	5b                   	pop    %ebx                           
  1089b0:	c9                   	leave                                 
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  switch ( option ) {                                                 
    case RTEMS_CLOCK_GET_TOD:                                         
      return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 
  1089b1:	e9 76 00 00 00       	jmp    108a2c <rtems_clock_get_tod>   
                                                                      
    case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:                         
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
  1089b6:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
  1089b9:	5b                   	pop    %ebx                           
  1089ba:	5b                   	pop    %ebx                           
  1089bb:	c9                   	leave                                 
  switch ( option ) {                                                 
    case RTEMS_CLOCK_GET_TOD:                                         
      return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 
                                                                      
    case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:                         
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
  1089bc:	e9 23 00 00 00       	jmp    1089e4 <rtems_clock_get_seconds_since_epoch>
                                                                      
    case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {                          
      rtems_interval *interval = (rtems_interval *)time_buffer;       
                                                                      
      *interval = rtems_clock_get_ticks_since_boot();                 
  1089c1:	e8 5a 00 00 00       	call   108a20 <rtems_clock_get_ticks_since_boot>
  1089c6:	eb 05                	jmp    1089cd <rtems_clock_get+0x49>  
      return RTEMS_SUCCESSFUL;                                        
    }                                                                 
    case RTEMS_CLOCK_GET_TICKS_PER_SECOND: {                          
      rtems_interval *interval = (rtems_interval *)time_buffer;       
                                                                      
      *interval = rtems_clock_get_ticks_per_second();                 
  1089c8:	e8 3f 00 00 00       	call   108a0c <rtems_clock_get_ticks_per_second>
  1089cd:	89 03                	mov    %eax,(%ebx)                    
  1089cf:	31 c0                	xor    %eax,%eax                      
  1089d1:	eb 0b                	jmp    1089de <rtems_clock_get+0x5a>  
      return RTEMS_SUCCESSFUL;                                        
    }                                                                 
    case RTEMS_CLOCK_GET_TIME_VALUE:                                  
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
  1089d3:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
  1089d6:	59                   	pop    %ecx                           
  1089d7:	5b                   	pop    %ebx                           
  1089d8:	c9                   	leave                                 
                                                                      
      *interval = rtems_clock_get_ticks_per_second();                 
      return RTEMS_SUCCESSFUL;                                        
    }                                                                 
    case RTEMS_CLOCK_GET_TIME_VALUE:                                  
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
  1089d9:	e9 ea 00 00 00       	jmp    108ac8 <rtems_clock_get_tod_timeval>
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
  1089de:	5a                   	pop    %edx                           
  1089df:	5b                   	pop    %ebx                           
  1089e0:	c9                   	leave                                 
  1089e1:	c3                   	ret                                   
                                                                      

001089e4 <rtems_clock_get_seconds_since_epoch>: #include <rtems/score/watchdog.h> rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) {
  1089e4:	55                   	push   %ebp                           
  1089e5:	89 e5                	mov    %esp,%ebp                      
  1089e7:	8b 55 08             	mov    0x8(%ebp),%edx                 
  if ( !the_interval )                                                
  1089ea:	b8 09 00 00 00       	mov    $0x9,%eax                      
  1089ef:	85 d2                	test   %edx,%edx                      
  1089f1:	74 17                	je     108a0a <rtems_clock_get_seconds_since_epoch+0x26><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
  1089f3:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  1089f8:	80 3d ac d7 11 00 00 	cmpb   $0x0,0x11d7ac                  
  1089ff:	74 09                	je     108a0a <rtems_clock_get_seconds_since_epoch+0x26>
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  *the_interval = _TOD_Seconds_since_epoch;                           
  108a01:	a1 28 d8 11 00       	mov    0x11d828,%eax                  
  108a06:	89 02                	mov    %eax,(%edx)                    
  108a08:	31 c0                	xor    %eax,%eax                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  108a0a:	c9                   	leave                                 
  108a0b:	c3                   	ret                                   
                                                                      

00108a2c <rtems_clock_get_tod>: #include <rtems/score/watchdog.h> rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) {
  108a2c:	55                   	push   %ebp                           
  108a2d:	89 e5                	mov    %esp,%ebp                      
  108a2f:	56                   	push   %esi                           
  108a30:	53                   	push   %ebx                           
  108a31:	83 ec 50             	sub    $0x50,%esp                     
  108a34:	8b 75 08             	mov    0x8(%ebp),%esi                 
  rtems_time_of_day *tmbuf = time_buffer;                             
  struct tm time;                                                     
  struct timeval now;                                                 
                                                                      
  if ( !time_buffer )                                                 
  108a37:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108a3c:	85 f6                	test   %esi,%esi                      
  108a3e:	74 7f                	je     108abf <rtems_clock_get_tod+0x93><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
  108a40:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  108a45:	80 3d ac d7 11 00 00 	cmpb   $0x0,0x11d7ac                  
  108a4c:	74 71                	je     108abf <rtems_clock_get_tod+0x93>
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
  108a4e:	9c                   	pushf                                 
  108a4f:	fa                   	cli                                   
  108a50:	5b                   	pop    %ebx                           
 *  This routine grows @a the_heap memory area using the size bytes which
  108a51:	83 ec 0c             	sub    $0xc,%esp                      
  108a54:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  108a57:	50                   	push   %eax                           
  108a58:	e8 df 14 00 00       	call   109f3c <_TOD_Get>              
 *  begin at @a starting_address.                                     
  108a5d:	53                   	push   %ebx                           
  108a5e:	9d                   	popf                                  
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  108a5f:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  108a62:	89 45 f0             	mov    %eax,-0x10(%ebp)               
 *  @param[in] starting_address is the starting address of the memory 
  108a65:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  108a68:	b9 e8 03 00 00       	mov    $0x3e8,%ecx                    
  108a6d:	31 d2                	xor    %edx,%edx                      
  108a6f:	f7 f1                	div    %ecx                           
  108a71:	89 45 f4             	mov    %eax,-0xc(%ebp)                
                                                                      
  /* Obtain the current time */                                       
  _TOD_Get_timeval( &now );                                           
                                                                      
  /* Split it into a closer format */                                 
  gmtime_r( &now.tv_sec, &time );                                     
  108a74:	58                   	pop    %eax                           
  108a75:	5a                   	pop    %edx                           
  108a76:	8d 45 c4             	lea    -0x3c(%ebp),%eax               
  108a79:	50                   	push   %eax                           
  108a7a:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  108a7d:	50                   	push   %eax                           
  108a7e:	e8 ed 6d 00 00       	call   10f870 <gmtime_r>              
                                                                      
  /* Now adjust it to the RTEMS format */                             
  tmbuf->year   = time.tm_year + 1900;                                
  108a83:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  108a86:	05 6c 07 00 00       	add    $0x76c,%eax                    
  108a8b:	89 06                	mov    %eax,(%esi)                    
  tmbuf->month  = time.tm_mon + 1;                                    
  108a8d:	8b 45 d4             	mov    -0x2c(%ebp),%eax               
  108a90:	40                   	inc    %eax                           
  108a91:	89 46 04             	mov    %eax,0x4(%esi)                 
  tmbuf->day    = time.tm_mday;                                       
  108a94:	8b 45 d0             	mov    -0x30(%ebp),%eax               
  108a97:	89 46 08             	mov    %eax,0x8(%esi)                 
  tmbuf->hour   = time.tm_hour;                                       
  108a9a:	8b 45 cc             	mov    -0x34(%ebp),%eax               
  108a9d:	89 46 0c             	mov    %eax,0xc(%esi)                 
  tmbuf->minute = time.tm_min;                                        
  108aa0:	8b 45 c8             	mov    -0x38(%ebp),%eax               
  108aa3:	89 46 10             	mov    %eax,0x10(%esi)                
  tmbuf->second = time.tm_sec;                                        
  108aa6:	8b 45 c4             	mov    -0x3c(%ebp),%eax               
  108aa9:	89 46 14             	mov    %eax,0x14(%esi)                
  tmbuf->ticks  = now.tv_usec / _TOD_Microseconds_per_tick;           
  108aac:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  108aaf:	31 d2                	xor    %edx,%edx                      
  108ab1:	f7 35 34 d9 11 00    	divl   0x11d934                       
  108ab7:	89 46 18             	mov    %eax,0x18(%esi)                
  108aba:	31 c0                	xor    %eax,%eax                      
  108abc:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  108abf:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108ac2:	5b                   	pop    %ebx                           
  108ac3:	5e                   	pop    %esi                           
  108ac4:	c9                   	leave                                 
  108ac5:	c3                   	ret                                   
                                                                      

00108ac8 <rtems_clock_get_tod_timeval>: #include <rtems/score/watchdog.h> rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) {
  108ac8:	55                   	push   %ebp                           
  108ac9:	89 e5                	mov    %esp,%ebp                      
  108acb:	56                   	push   %esi                           
  108acc:	53                   	push   %ebx                           
  108acd:	83 ec 20             	sub    $0x20,%esp                     
  108ad0:	8b 75 08             	mov    0x8(%ebp),%esi                 
  if ( !time )                                                        
  108ad3:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108ad8:	85 f6                	test   %esi,%esi                      
  108ada:	74 38                	je     108b14 <rtems_clock_get_tod_timeval+0x4c><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
  108adc:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  108ae1:	80 3d ac d7 11 00 00 	cmpb   $0x0,0x11d7ac                  
  108ae8:	74 2a                	je     108b14 <rtems_clock_get_tod_timeval+0x4c>
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
  108aea:	9c                   	pushf                                 
  108aeb:	fa                   	cli                                   
  108aec:	5b                   	pop    %ebx                           
 *  This routine grows @a the_heap memory area using the size bytes which
  108aed:	83 ec 0c             	sub    $0xc,%esp                      
  108af0:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  108af3:	50                   	push   %eax                           
  108af4:	e8 43 14 00 00       	call   109f3c <_TOD_Get>              
 *  begin at @a starting_address.                                     
  108af9:	53                   	push   %ebx                           
  108afa:	9d                   	popf                                  
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  108afb:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  108afe:	89 06                	mov    %eax,(%esi)                    
 *  @param[in] starting_address is the starting address of the memory 
  108b00:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  108b03:	b9 e8 03 00 00       	mov    $0x3e8,%ecx                    
  108b08:	31 d2                	xor    %edx,%edx                      
  108b0a:	f7 f1                	div    %ecx                           
  108b0c:	89 46 04             	mov    %eax,0x4(%esi)                 
  108b0f:	31 c0                	xor    %eax,%eax                      
  108b11:	83 c4 10             	add    $0x10,%esp                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  _TOD_Get_timeval( time );                                           
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  108b14:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108b17:	5b                   	pop    %ebx                           
  108b18:	5e                   	pop    %esi                           
  108b19:	c9                   	leave                                 
  108b1a:	c3                   	ret                                   
                                                                      

00108cf4 <rtems_clock_get_uptime>: * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) {
  108cf4:	55                   	push   %ebp                           
  108cf5:	89 e5                	mov    %esp,%ebp                      
  108cf7:	83 ec 08             	sub    $0x8,%esp                      
  108cfa:	8b 55 08             	mov    0x8(%ebp),%edx                 
  if ( !uptime )                                                      
  108cfd:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108d02:	85 d2                	test   %edx,%edx                      
  108d04:	74 0e                	je     108d14 <rtems_clock_get_uptime+0x20><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _TOD_Get_uptime( uptime );                                          
  108d06:	83 ec 0c             	sub    $0xc,%esp                      
  108d09:	52                   	push   %edx                           
  108d0a:	e8 85 15 00 00       	call   10a294 <_TOD_Get_uptime>       
  108d0f:	31 c0                	xor    %eax,%eax                      
  108d11:	83 c4 10             	add    $0x10,%esp                     
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  108d14:	c9                   	leave                                 
  108d15:	c3                   	ret                                   
                                                                      

00109950 <rtems_clock_set>: */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) {
  109950:	55                   	push   %ebp                           
  109951:	89 e5                	mov    %esp,%ebp                      
  109953:	53                   	push   %ebx                           
  109954:	83 ec 14             	sub    $0x14,%esp                     
  109957:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  struct timespec  newtime;                                           
                                                                      
  if ( !time_buffer )                                                 
  10995a:	ba 09 00 00 00       	mov    $0x9,%edx                      
  10995f:	85 db                	test   %ebx,%ebx                      
  109961:	74 54                	je     1099b7 <rtems_clock_set+0x67>  <== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( _TOD_Validate( time_buffer ) ) {                               
  109963:	83 ec 0c             	sub    $0xc,%esp                      
  109966:	53                   	push   %ebx                           
  109967:	e8 f8 00 00 00       	call   109a64 <_TOD_Validate>         
  10996c:	83 c4 10             	add    $0x10,%esp                     
  10996f:	ba 14 00 00 00       	mov    $0x14,%edx                     
  109974:	84 c0                	test   %al,%al                        
  109976:	74 3f                	je     1099b7 <rtems_clock_set+0x67>  
    newtime.tv_sec = _TOD_To_seconds( time_buffer );                  
  109978:	83 ec 0c             	sub    $0xc,%esp                      
  10997b:	53                   	push   %ebx                           
  10997c:	e8 7b 00 00 00       	call   1099fc <_TOD_To_seconds>       
  109981:	89 45 f4             	mov    %eax,-0xc(%ebp)                
    newtime.tv_nsec = time_buffer->ticks *                            
  109984:	8b 43 18             	mov    0x18(%ebx),%eax                
  109987:	0f af 05 30 94 12 00 	imul   0x129430,%eax                  
  10998e:	69 c0 e8 03 00 00    	imul   $0x3e8,%eax,%eax               
  109994:	89 45 f8             	mov    %eax,-0x8(%ebp)                
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109997:	a1 94 92 12 00       	mov    0x129294,%eax                  
  10999c:	40                   	inc    %eax                           
  10999d:	a3 94 92 12 00       	mov    %eax,0x129294                  
                 (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);
                                                                      
    _Thread_Disable_dispatch();                                       
      _TOD_Set( &newtime );                                           
  1099a2:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  1099a5:	89 04 24             	mov    %eax,(%esp)                    
  1099a8:	e8 13 18 00 00       	call   10b1c0 <_TOD_Set>              
    _Thread_Enable_dispatch();                                        
  1099ad:	e8 5a 28 00 00       	call   10c20c <_Thread_Enable_dispatch>
  1099b2:	31 d2                	xor    %edx,%edx                      
  1099b4:	83 c4 10             	add    $0x10,%esp                     
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
  return RTEMS_INVALID_CLOCK;                                         
}                                                                     
  1099b7:	89 d0                	mov    %edx,%eax                      
  1099b9:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  1099bc:	c9                   	leave                                 
  1099bd:	c3                   	ret                                   
                                                                      

00108b1c <rtems_clock_set_nanoseconds_extension>: * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) {
  108b1c:	55                   	push   %ebp                           
  108b1d:	89 e5                	mov    %esp,%ebp                      
  108b1f:	8b 55 08             	mov    0x8(%ebp),%edx                 
  if ( !routine )                                                     
  108b22:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108b27:	85 d2                	test   %edx,%edx                      
  108b29:	74 08                	je     108b33 <rtems_clock_set_nanoseconds_extension+0x17><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _Watchdog_Nanoseconds_since_tick_handler = routine;                 
  108b2b:	89 15 3c d9 11 00    	mov    %edx,0x11d93c                  
  108b31:	31 c0                	xor    %eax,%eax                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  108b33:	c9                   	leave                                 
  108b34:	c3                   	ret                                   
                                                                      

00106b88 <rtems_cpu_usage_report_with_plugin>: void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) {
  106b88:	55                   	push   %ebp                           
  106b89:	89 e5                	mov    %esp,%ebp                      
  106b8b:	57                   	push   %edi                           
  106b8c:	56                   	push   %esi                           
  106b8d:	53                   	push   %ebx                           
  106b8e:	83 ec 4c             	sub    $0x4c,%esp                     
    struct timespec    uptime, total, ran;                            
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
  106b91:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  106b95:	0f 84 43 01 00 00    	je     106cde <rtems_cpu_usage_report_with_plugin+0x156><== NEVER TAKEN
   *  When not using nanosecond CPU usage resolution, we have to count
   *  the number of "ticks" we gave credit for to give the user a rough
   *  guideline as to what each number means proportionally.          
   */                                                                 
  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS                 
    _TOD_Get_uptime( &uptime );                                       
  106b9b:	83 ec 0c             	sub    $0xc,%esp                      
  106b9e:	8d 5d e4             	lea    -0x1c(%ebp),%ebx               
  106ba1:	53                   	push   %ebx                           
  106ba2:	e8 89 45 00 00       	call   10b130 <_TOD_Get_uptime>       
    _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
  106ba7:	83 c4 0c             	add    $0xc,%esp                      
  106baa:	8d 45 dc             	lea    -0x24(%ebp),%eax               
  106bad:	50                   	push   %eax                           
  106bae:	53                   	push   %ebx                           
  106baf:	68 2c 98 12 00       	push   $0x12982c                      
  106bb4:	e8 07 64 00 00       	call   10cfc0 <_Timespec_Subtract>    
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)( context, "CPU Usage by thread\n"                          
  106bb9:	58                   	pop    %eax                           
  106bba:	5a                   	pop    %edx                           
  106bbb:	68 2a a1 11 00       	push   $0x11a12a                      
  106bc0:	ff 75 08             	pushl  0x8(%ebp)                      
  106bc3:	ff 55 0c             	call   *0xc(%ebp)                     
  106bc6:	bf 01 00 00 00       	mov    $0x1,%edi                      
  106bcb:	83 c4 10             	add    $0x10,%esp                     
  );                                                                  
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
  106bce:	8b 04 bd 68 92 12 00 	mov    0x129268(,%edi,4),%eax         
  106bd5:	85 c0                	test   %eax,%eax                      
  106bd7:	0f 84 d9 00 00 00    	je     106cb6 <rtems_cpu_usage_report_with_plugin+0x12e>
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
  106bdd:	8b 40 04             	mov    0x4(%eax),%eax                 
  106be0:	89 45 b0             	mov    %eax,-0x50(%ebp)               
    if ( information ) {                                              
  106be3:	be 01 00 00 00       	mov    $0x1,%esi                      
  106be8:	85 c0                	test   %eax,%eax                      
  106bea:	0f 85 b7 00 00 00    	jne    106ca7 <rtems_cpu_usage_report_with_plugin+0x11f><== ALWAYS TAKEN
  106bf0:	e9 c1 00 00 00       	jmp    106cb6 <rtems_cpu_usage_report_with_plugin+0x12e><== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
        the_thread = (Thread_Control *)information->local_table[ i ]; 
  106bf5:	8b 55 b0             	mov    -0x50(%ebp),%edx               
  106bf8:	8b 42 1c             	mov    0x1c(%edx),%eax                
  106bfb:	8b 1c b0             	mov    (%eax,%esi,4),%ebx             
                                                                      
        if ( !the_thread )                                            
  106bfe:	85 db                	test   %ebx,%ebx                      
  106c00:	0f 84 a0 00 00 00    	je     106ca6 <rtems_cpu_usage_report_with_plugin+0x11e><== NEVER TAKEN
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
  106c06:	50                   	push   %eax                           
  106c07:	8d 45 bf             	lea    -0x41(%ebp),%eax               
  106c0a:	50                   	push   %eax                           
  106c0b:	6a 0d                	push   $0xd                           
  106c0d:	ff 73 08             	pushl  0x8(%ebx)                      
  106c10:	e8 8f 32 00 00       	call   109ea4 <rtems_object_get_name> 
                                                                      
        (*print)(                                                     
  106c15:	8d 55 bf             	lea    -0x41(%ebp),%edx               
  106c18:	52                   	push   %edx                           
  106c19:	ff 73 08             	pushl  0x8(%ebx)                      
  106c1c:	68 6f a1 11 00       	push   $0x11a16f                      
  106c21:	ff 75 08             	pushl  0x8(%ebp)                      
  106c24:	ff 55 0c             	call   *0xc(%ebp)                     
        #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS           
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
  106c27:	8b 93 84 00 00 00    	mov    0x84(%ebx),%edx                
  106c2d:	8b 83 88 00 00 00    	mov    0x88(%ebx),%eax                
  106c33:	89 45 d8             	mov    %eax,-0x28(%ebp)               
  106c36:	89 55 d4             	mov    %edx,-0x2c(%ebp)               
          if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
  106c39:	83 c4 20             	add    $0x20,%esp                     
  106c3c:	a1 54 93 12 00       	mov    0x129354,%eax                  
  106c41:	8b 40 08             	mov    0x8(%eax),%eax                 
  106c44:	3b 43 08             	cmp    0x8(%ebx),%eax                 
  106c47:	75 22                	jne    106c6b <rtems_cpu_usage_report_with_plugin+0xe3>
            struct timespec used;                                     
            _Timespec_Subtract(                                       
  106c49:	50                   	push   %eax                           
  106c4a:	8d 5d cc             	lea    -0x34(%ebp),%ebx               
  106c4d:	53                   	push   %ebx                           
  106c4e:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  106c51:	50                   	push   %eax                           
  106c52:	68 5c 93 12 00       	push   $0x12935c                      
  106c57:	e8 64 63 00 00       	call   10cfc0 <_Timespec_Subtract>    
              &_Thread_Time_of_last_context_switch, &uptime, &used    
            );                                                        
            _Timespec_Add_to( &ran, &used );                          
  106c5c:	59                   	pop    %ecx                           
  106c5d:	58                   	pop    %eax                           
  106c5e:	53                   	push   %ebx                           
  106c5f:	8d 45 d4             	lea    -0x2c(%ebp),%eax               
  106c62:	50                   	push   %eax                           
  106c63:	e8 6c 62 00 00       	call   10ced4 <_Timespec_Add_to>      
  106c68:	83 c4 10             	add    $0x10,%esp                     
          };                                                          
          _Timespec_Divide( &ran, &total, &ival, &fval );             
  106c6b:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  106c6e:	50                   	push   %eax                           
  106c6f:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  106c72:	50                   	push   %eax                           
  106c73:	8d 45 dc             	lea    -0x24(%ebp),%eax               
  106c76:	50                   	push   %eax                           
  106c77:	8d 45 d4             	lea    -0x2c(%ebp),%eax               
  106c7a:	50                   	push   %eax                           
  106c7b:	e8 84 62 00 00       	call   10cf04 <_Timespec_Divide>      
                                                                      
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          (*print)( context,                                          
  106c80:	58                   	pop    %eax                           
  106c81:	5a                   	pop    %edx                           
  106c82:	ff 75 ec             	pushl  -0x14(%ebp)                    
  106c85:	ff 75 f0             	pushl  -0x10(%ebp)                    
  106c88:	8b 45 d8             	mov    -0x28(%ebp),%eax               
  106c8b:	b9 e8 03 00 00       	mov    $0x3e8,%ecx                    
  106c90:	31 d2                	xor    %edx,%edx                      
  106c92:	f7 f1                	div    %ecx                           
  106c94:	50                   	push   %eax                           
  106c95:	ff 75 d4             	pushl  -0x2c(%ebp)                    
  106c98:	68 82 a1 11 00       	push   $0x11a182                      
  106c9d:	ff 75 08             	pushl  0x8(%ebp)                      
  106ca0:	ff 55 0c             	call   *0xc(%ebp)                     
  106ca3:	83 c4 20             	add    $0x20,%esp                     
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
  106ca6:	46                   	inc    %esi                           
  106ca7:	8b 55 b0             	mov    -0x50(%ebp),%edx               
  106caa:	0f b7 42 10          	movzwl 0x10(%edx),%eax                
  106cae:	39 c6                	cmp    %eax,%esi                      
  106cb0:	0f 86 3f ff ff ff    	jbe    106bf5 <rtems_cpu_usage_report_with_plugin+0x6d>
  #endif                                                              
  );                                                                  
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
        api_index++ ) {                                               
  106cb6:	47                   	inc    %edi                           
     "   ID            NAME         TICKS   PERCENT\n"                
  #endif                                                              
  );                                                                  
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
  106cb7:	83 ff 05             	cmp    $0x5,%edi                      
  106cba:	0f 85 0e ff ff ff    	jne    106bce <rtems_cpu_usage_report_with_plugin+0x46>
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS                 
    (*print)( context, "Time since last CPU Usage reset %" PRId32     
  106cc0:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  106cc3:	b9 e8 03 00 00       	mov    $0x3e8,%ecx                    
  106cc8:	31 d2                	xor    %edx,%edx                      
  106cca:	f7 f1                	div    %ecx                           
  106ccc:	50                   	push   %eax                           
  106ccd:	ff 75 dc             	pushl  -0x24(%ebp)                    
  106cd0:	68 9a a1 11 00       	push   $0x11a19a                      
  106cd5:	ff 75 08             	pushl  0x8(%ebp)                      
  106cd8:	ff 55 0c             	call   *0xc(%ebp)                     
  106cdb:	83 c4 10             	add    $0x10,%esp                     
      "Ticks since last reset = %" PRId32 "\n",                       
      _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset      
    );                                                                
    (*print)( context, "Total Units = %" PRId32 "\n", total_units );  
  #endif                                                              
}                                                                     
  106cde:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106ce1:	5b                   	pop    %ebx                           
  106ce2:	5e                   	pop    %esi                           
  106ce3:	5f                   	pop    %edi                           
  106ce4:	c9                   	leave                                 
  106ce5:	c3                   	ret                                   
                                                                      

0010e5eb <rtems_deviceio_errno>: { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) {
  10e5eb:	55                   	push   %ebp                           <== NOT EXECUTED
  10e5ec:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10e5ee:	53                   	push   %ebx                           <== NOT EXECUTED
  10e5ef:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
    int rc;                                                           
                                                                      
    if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code)))
  10e5f2:	50                   	push   %eax                           <== NOT EXECUTED
  10e5f3:	68 dc 79 11 00       	push   $0x1179dc                      <== NOT EXECUTED
  10e5f8:	e8 bb 03 00 00       	call   10e9b8 <rtems_assoc_remote_by_local><== NOT EXECUTED
  10e5fd:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
  10e5ff:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10e602:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10e604:	74 07                	je     10e60d <rtems_deviceio_errno+0x22><== NOT EXECUTED
    {                                                                 
        errno = rc;                                                   
  10e606:	e8 1d 0b 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10e60b:	89 18                	mov    %ebx,(%eax)                    <== NOT EXECUTED
        return -1;                                                    
    }                                                                 
    return -1;                                                        
}                                                                     
  10e60d:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  10e610:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10e613:	c9                   	leave                                 <== NOT EXECUTED
  10e614:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00107040 <rtems_error>: int rtems_error( int error_flag, const char *printf_format, ... ) {
  107040:	55                   	push   %ebp                           <== NOT EXECUTED
  107041:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107043:	83 ec 08             	sub    $0x8,%esp                      <== NOT EXECUTED
  107046:	8d 4d 10             	lea    0x10(%ebp),%ecx                <== NOT EXECUTED
    va_list arglist;                                                  
    int chars_written;                                                
                                                                      
    va_start(arglist, printf_format);                                 
    chars_written = rtems_verror(error_flag, printf_format, arglist); 
  107049:	8b 55 0c             	mov    0xc(%ebp),%edx                 <== NOT EXECUTED
  10704c:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10704f:	e8 6d fe ff ff       	call   106ec1 <rtems_verror>          <== NOT EXECUTED
    va_end(arglist);                                                  
                                                                      
    return chars_written;                                             
}                                                                     
  107054:	c9                   	leave                                 <== NOT EXECUTED
  107055:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00108b74 <rtems_event_receive>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) {
  108b74:	55                   	push   %ebp                           
  108b75:	89 e5                	mov    %esp,%ebp                      
  108b77:	83 ec 08             	sub    $0x8,%esp                      
  108b7a:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  108b7d:	8b 55 14             	mov    0x14(%ebp),%edx                
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !event_out )                                                   
  108b80:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108b85:	85 d2                	test   %edx,%edx                      
  108b87:	74 3f                	je     108bc8 <rtems_event_receive+0x54><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];        
  108b89:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  108b8e:	8b 80 f4 00 00 00    	mov    0xf4(%eax),%eax                
                                                                      
  if ( _Event_sets_Is_empty( event_in ) ) {                           
  108b94:	85 c9                	test   %ecx,%ecx                      
  108b96:	75 08                	jne    108ba0 <rtems_event_receive+0x2c>
    *event_out = api->pending_events;                                 
  108b98:	8b 00                	mov    (%eax),%eax                    
  108b9a:	89 02                	mov    %eax,(%edx)                    
  108b9c:	31 c0                	xor    %eax,%eax                      
  108b9e:	eb 28                	jmp    108bc8 <rtems_event_receive+0x54>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  108ba0:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  108ba5:	40                   	inc    %eax                           
  108ba6:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  _Thread_Disable_dispatch();                                         
  _Event_Seize( event_in, option_set, ticks, event_out );             
  108bab:	52                   	push   %edx                           
  108bac:	ff 75 10             	pushl  0x10(%ebp)                     
  108baf:	ff 75 0c             	pushl  0xc(%ebp)                      
  108bb2:	51                   	push   %ecx                           
  108bb3:	e8 14 00 00 00       	call   108bcc <_Event_Seize>          
  _Thread_Enable_dispatch();                                          
  108bb8:	e8 cf 22 00 00       	call   10ae8c <_Thread_Enable_dispatch>
  return( _Thread_Executing->Wait.return_code );                      
  108bbd:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  108bc2:	8b 40 34             	mov    0x34(%eax),%eax                
  108bc5:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  108bc8:	c9                   	leave                                 
  108bc9:	c3                   	ret                                   
                                                                      

001062e0 <rtems_filesystem_evaluate_parent>: int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) {
  1062e0:	55                   	push   %ebp                           
  1062e1:	89 e5                	mov    %esp,%ebp                      
  1062e3:	57                   	push   %edi                           
  1062e4:	56                   	push   %esi                           
  1062e5:	83 ec 10             	sub    $0x10,%esp                     
  1062e8:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  rtems_filesystem_location_info_t  parent;                           
  int                               result;                           
                                                                      
  if ( !pathloc )                                                     
  1062eb:	85 f6                	test   %esi,%esi                      
  1062ed:	75 0d                	jne    1062fc <rtems_filesystem_evaluate_parent+0x1c><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EIO );       /* should never happen */
  1062ef:	e8 34 8e 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  1062f4:	c7 00 05 00 00 00    	movl   $0x5,(%eax)                    <== NOT EXECUTED
  1062fa:	eb 13                	jmp    10630f <rtems_filesystem_evaluate_parent+0x2f><== NOT EXECUTED
                                                                      
  if ( !pathloc->ops->evalpath_h )                                    
  1062fc:	8b 46 08             	mov    0x8(%esi),%eax                 
  1062ff:	83 38 00             	cmpl   $0x0,(%eax)                    
  106302:	75 10                	jne    106314 <rtems_filesystem_evaluate_parent+0x34><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  106304:	e8 1f 8e 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  106309:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10630f:	83 cf ff             	or     $0xffffffff,%edi               <== NOT EXECUTED
  106312:	eb 39                	jmp    10634d <rtems_filesystem_evaluate_parent+0x6d><== NOT EXECUTED
                                                                      
  parent = *pathloc;                                                  
  106314:	8d 7d e8             	lea    -0x18(%ebp),%edi               
  106317:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10631c:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );       
  10631e:	52                   	push   %edx                           
  10631f:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  106322:	56                   	push   %esi                           
  106323:	ff 75 08             	pushl  0x8(%ebp)                      
  106326:	68 f9 71 11 00       	push   $0x1171f9                      
  10632b:	ff 10                	call   *(%eax)                        
  10632d:	89 c7                	mov    %eax,%edi                      
  if (result != 0){                                                   
  10632f:	83 c4 10             	add    $0x10,%esp                     
  106332:	85 c0                	test   %eax,%eax                      
  106334:	75 d9                	jne    10630f <rtems_filesystem_evaluate_parent+0x2f><== NEVER TAKEN
    return -1;                                                        
  }                                                                   
  rtems_filesystem_freenode( &parent );                               
  106336:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  106339:	85 c0                	test   %eax,%eax                      
  10633b:	74 10                	je     10634d <rtems_filesystem_evaluate_parent+0x6d><== NEVER TAKEN
  10633d:	8b 40 1c             	mov    0x1c(%eax),%eax                
  106340:	85 c0                	test   %eax,%eax                      
  106342:	74 09                	je     10634d <rtems_filesystem_evaluate_parent+0x6d><== NEVER TAKEN
  106344:	83 ec 0c             	sub    $0xc,%esp                      
  106347:	56                   	push   %esi                           
  106348:	ff d0                	call   *%eax                          
  10634a:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  10634d:	89 f8                	mov    %edi,%eax                      
  10634f:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  106352:	5e                   	pop    %esi                           
  106353:	5f                   	pop    %edi                           
  106354:	c9                   	leave                                 
  106355:	c3                   	ret                                   
                                                                      

00106356 <rtems_filesystem_evaluate_path>: const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) {
  106356:	55                   	push   %ebp                           
  106357:	89 e5                	mov    %esp,%ebp                      
  106359:	57                   	push   %edi                           
  10635a:	56                   	push   %esi                           
  10635b:	53                   	push   %ebx                           
  10635c:	83 ec 1c             	sub    $0x1c,%esp                     
  10635f:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  106362:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  106365:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  106368:	8b 55 10             	mov    0x10(%ebp),%edx                
  10636b:	89 55 e0             	mov    %edx,-0x20(%ebp)               
  10636e:	8b 7d 14             	mov    0x14(%ebp),%edi                
  106371:	89 7d ec             	mov    %edi,-0x14(%ebp)               
                                                                      
  /*                                                                  
   * Verify Input parameters.                                         
   */                                                                 
                                                                      
  if ( !pathname )                                                    
  106374:	85 db                	test   %ebx,%ebx                      
  106376:	75 0d                	jne    106385 <rtems_filesystem_evaluate_path+0x2f>
    rtems_set_errno_and_return_minus_one( EFAULT );                   
  106378:	e8 ab 8d 00 00       	call   10f128 <__errno>               
  10637d:	c7 00 0e 00 00 00    	movl   $0xe,(%eax)                    
  106383:	eb 11                	jmp    106396 <rtems_filesystem_evaluate_path+0x40>
                                                                      
  if ( !pathloc )                                                     
  106385:	83 7d e0 00          	cmpl   $0x0,-0x20(%ebp)               
  106389:	75 13                	jne    10639e <rtems_filesystem_evaluate_path+0x48><== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EIO );       /* should never happen */
  10638b:	e8 98 8d 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  106390:	c7 00 05 00 00 00    	movl   $0x5,(%eax)                    <== NOT EXECUTED
  106396:	83 ce ff             	or     $0xffffffff,%esi               
  106399:	e9 cd 00 00 00       	jmp    10646b <rtems_filesystem_evaluate_path+0x115>
                                                                      
  /*                                                                  
   * Evaluate the path using the optable evalpath.                    
   */                                                                 
                                                                      
  rtems_filesystem_get_start_loc( pathname, &i, pathloc );            
  10639e:	8a 03                	mov    (%ebx),%al                     
  1063a0:	3c 2f                	cmp    $0x2f,%al                      
  1063a2:	74 08                	je     1063ac <rtems_filesystem_evaluate_path+0x56>
  1063a4:	3c 5c                	cmp    $0x5c,%al                      
  1063a6:	74 04                	je     1063ac <rtems_filesystem_evaluate_path+0x56><== NEVER TAKEN
  1063a8:	84 c0                	test   %al,%al                        
  1063aa:	75 16                	jne    1063c2 <rtems_filesystem_evaluate_path+0x6c><== ALWAYS TAKEN
  1063ac:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  1063b1:	8d 70 14             	lea    0x14(%eax),%esi                
  1063b4:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  1063b9:	8b 7d e0             	mov    -0x20(%ebp),%edi               
  1063bc:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  1063be:	b1 01                	mov    $0x1,%cl                       
  1063c0:	eb 12                	jmp    1063d4 <rtems_filesystem_evaluate_path+0x7e>
  1063c2:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  1063c7:	8d 70 04             	lea    0x4(%eax),%esi                 
  1063ca:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  1063cf:	8b 7d e0             	mov    -0x20(%ebp),%edi               
  1063d2:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  if ( !pathloc->ops->evalpath_h )                                    
  1063d4:	8b 55 e0             	mov    -0x20(%ebp),%edx               
  1063d7:	8b 42 08             	mov    0x8(%edx),%eax                 
  1063da:	8b 10                	mov    (%eax),%edx                    
  1063dc:	85 d2                	test   %edx,%edx                      
  1063de:	74 66                	je     106446 <rtems_filesystem_evaluate_path+0xf0><== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc );
  1063e0:	56                   	push   %esi                           
  1063e1:	ff 75 e0             	pushl  -0x20(%ebp)                    
  1063e4:	ff 75 f0             	pushl  -0x10(%ebp)                    
  1063e7:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax             
  1063ea:	50                   	push   %eax                           
  1063eb:	ff d2                	call   *%edx                          
  1063ed:	89 c6                	mov    %eax,%esi                      
  /*                                                                  
   * Get the Node type and determine if you need to follow the link or
   * not.                                                             
   */                                                                 
                                                                      
  if ( (result == 0) && follow_link ) {                               
  1063ef:	83 c4 10             	add    $0x10,%esp                     
  1063f2:	85 c0                	test   %eax,%eax                      
  1063f4:	75 75                	jne    10646b <rtems_filesystem_evaluate_path+0x115>
  1063f6:	83 7d ec 00          	cmpl   $0x0,-0x14(%ebp)               
  1063fa:	74 6f                	je     10646b <rtems_filesystem_evaluate_path+0x115>
                                                                      
    if ( !pathloc->ops->node_type_h ){                                
  1063fc:	8b 7d e0             	mov    -0x20(%ebp),%edi               
  1063ff:	8b 47 08             	mov    0x8(%edi),%eax                 
  106402:	8b 50 10             	mov    0x10(%eax),%edx                
  106405:	85 d2                	test   %edx,%edx                      
  106407:	75 0d                	jne    106416 <rtems_filesystem_evaluate_path+0xc0><== ALWAYS TAKEN
      rtems_filesystem_freenode( pathloc );                           
  106409:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  10640c:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10640e:	74 36                	je     106446 <rtems_filesystem_evaluate_path+0xf0><== NOT EXECUTED
  106410:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106413:	57                   	push   %edi                           <== NOT EXECUTED
  106414:	eb 2b                	jmp    106441 <rtems_filesystem_evaluate_path+0xeb><== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOTSUP );                
    }                                                                 
                                                                      
    type = (*pathloc->ops->node_type_h)( pathloc );                   
  106416:	83 ec 0c             	sub    $0xc,%esp                      
  106419:	ff 75 e0             	pushl  -0x20(%ebp)                    
  10641c:	ff d2                	call   *%edx                          
                                                                      
    if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||                    
  10641e:	83 e8 03             	sub    $0x3,%eax                      
  106421:	83 c4 10             	add    $0x10,%esp                     
  106424:	83 f8 01             	cmp    $0x1,%eax                      
  106427:	77 42                	ja     10646b <rtems_filesystem_evaluate_path+0x115>
         ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {                    
                                                                      
        if ( !pathloc->ops->eval_link_h ){                            
  106429:	8b 55 e0             	mov    -0x20(%ebp),%edx               
  10642c:	8b 42 08             	mov    0x8(%edx),%eax                 
  10642f:	8b 48 34             	mov    0x34(%eax),%ecx                
  106432:	85 c9                	test   %ecx,%ecx                      
  106434:	75 20                	jne    106456 <rtems_filesystem_evaluate_path+0x100><== ALWAYS TAKEN
          rtems_filesystem_freenode( pathloc );                       
  106436:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  106439:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10643b:	74 09                	je     106446 <rtems_filesystem_evaluate_path+0xf0><== NOT EXECUTED
  10643d:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106440:	52                   	push   %edx                           <== NOT EXECUTED
  106441:	ff d0                	call   *%eax                          <== NOT EXECUTED
  106443:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
          rtems_set_errno_and_return_minus_one( ENOTSUP );            
  106446:	e8 dd 8c 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  10644b:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  106451:	e9 40 ff ff ff       	jmp    106396 <rtems_filesystem_evaluate_path+0x40><== NOT EXECUTED
         *    pathloc will be passed up (and eventually released).    
         *    Hence, the (valid) originial node that we submit to     
         *    eval_link_h() should be released by the handler.        
         */                                                           
                                                                      
        result =  (*pathloc->ops->eval_link_h)( pathloc, flags );     
  106456:	8b 7d f0             	mov    -0x10(%ebp),%edi               
  106459:	89 7d 0c             	mov    %edi,0xc(%ebp)                 
  10645c:	8b 45 e0             	mov    -0x20(%ebp),%eax               
  10645f:	89 45 08             	mov    %eax,0x8(%ebp)                 
                                                                      
    }                                                                 
  }                                                                   
                                                                      
  return result;                                                      
}                                                                     
  106462:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106465:	5b                   	pop    %ebx                           
  106466:	5e                   	pop    %esi                           
  106467:	5f                   	pop    %edi                           
  106468:	c9                   	leave                                 
         *    pathloc will be passed up (and eventually released).    
         *    Hence, the (valid) originial node that we submit to     
         *    eval_link_h() should be released by the handler.        
         */                                                           
                                                                      
        result =  (*pathloc->ops->eval_link_h)( pathloc, flags );     
  106469:	ff e1                	jmp    *%ecx                          
                                                                      
    }                                                                 
  }                                                                   
                                                                      
  return result;                                                      
}                                                                     
  10646b:	89 f0                	mov    %esi,%eax                      
  10646d:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  106470:	5b                   	pop    %ebx                           
  106471:	5e                   	pop    %esi                           
  106472:	5f                   	pop    %edi                           
  106473:	c9                   	leave                                 
  106474:	c3                   	ret                                   
                                                                      

0010cbe8 <rtems_filesystem_initialize>: * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) {
  10cbe8:	55                   	push   %ebp                           
  10cbe9:	89 e5                	mov    %esp,%ebp                      
  10cbeb:	57                   	push   %edi                           
  10cbec:	56                   	push   %esi                           
  10cbed:	53                   	push   %ebx                           
  10cbee:	83 ec 2c             	sub    $0x2c,%esp                     
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
  10cbf1:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10cbf6:	c7 40 24 12 00 00 00 	movl   $0x12,0x24(%eax)               
                                                                      
                                                                      
  init_fs_mount_table();                                              
  10cbfd:	e8 f2 04 00 00       	call   10d0f4 <init_fs_mount_table>   
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
  10cc02:	83 3d e8 5e 11 00 00 	cmpl   $0x0,0x115ee8                  
  10cc09:	75 0a                	jne    10cc15 <rtems_filesystem_initialize+0x2d><== ALWAYS TAKEN
    rtems_fatal_error_occurred( 0xABCD0001 );                         
  10cc0b:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10cc0e:	68 01 00 cd ab       	push   $0xabcd0001                    <== NOT EXECUTED
  10cc13:	eb 2a                	jmp    10cc3f <rtems_filesystem_initialize+0x57><== NOT EXECUTED
                                                                      
  mt = &rtems_filesystem_mount_table[0];                              
  10cc15:	a1 e0 92 11 00       	mov    0x1192e0,%eax                  
                                                                      
  status = mount(                                                     
  10cc1a:	83 ec 0c             	sub    $0xc,%esp                      
  10cc1d:	ff 70 0c             	pushl  0xc(%eax)                      
  10cc20:	ff 70 08             	pushl  0x8(%eax)                      
  10cc23:	ff 70 04             	pushl  0x4(%eax)                      
  10cc26:	ff 30                	pushl  (%eax)                         
  10cc28:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10cc2b:	50                   	push   %eax                           
  10cc2c:	e8 e8 04 00 00       	call   10d119 <mount>                 
     &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
                                                                      
  if ( status == -1 )                                                 
  10cc31:	83 c4 20             	add    $0x20,%esp                     
  10cc34:	40                   	inc    %eax                           
  10cc35:	75 0d                	jne    10cc44 <rtems_filesystem_initialize+0x5c><== ALWAYS TAKEN
    rtems_fatal_error_occurred( 0xABCD0002 );                         
  10cc37:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10cc3a:	68 02 00 cd ab       	push   $0xabcd0002                    <== NOT EXECUTED
  10cc3f:	e8 50 cb ff ff       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
                                                                      
  rtems_filesystem_link_counts = 0;                                   
  10cc44:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10cc49:	66 c7 40 28 00 00    	movw   $0x0,0x28(%eax)                
   *       set_private_env() - but then: that's                       
   *       gonna hit performance.                                     
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  rtems_filesystem_root        = entry->mt_fs_root;                   
  10cc4f:	8d 78 14             	lea    0x14(%eax),%edi                
  10cc52:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10cc55:	8d 70 18             	lea    0x18(%eax),%esi                
  10cc58:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10cc5d:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 0, &loc, 0);                    
  10cc5f:	6a 00                	push   $0x0                           
  10cc61:	8d 5d e0             	lea    -0x20(%ebp),%ebx               
  10cc64:	53                   	push   %ebx                           
  10cc65:	6a 00                	push   $0x0                           
  10cc67:	68 28 77 11 00       	push   $0x117728                      
  10cc6c:	e8 e5 96 ff ff       	call   106356 <rtems_filesystem_evaluate_path>
  rtems_filesystem_root        = loc;                                 
  10cc71:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10cc76:	8d 78 14             	lea    0x14(%eax),%edi                
  10cc79:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10cc7e:	89 de                	mov    %ebx,%esi                      
  10cc80:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  /* One more clone for the current node */                           
  rtems_filesystem_evaluate_path("/", 0, &loc, 0);                    
  10cc82:	6a 00                	push   $0x0                           
  10cc84:	53                   	push   %ebx                           
  10cc85:	6a 00                	push   $0x0                           
  10cc87:	68 28 77 11 00       	push   $0x117728                      
  10cc8c:	e8 c5 96 ff ff       	call   106356 <rtems_filesystem_evaluate_path>
  rtems_filesystem_current     = loc;                                 
  10cc91:	a1 6c b6 11 00       	mov    0x11b66c,%eax                  
  10cc96:	8d 78 04             	lea    0x4(%eax),%edi                 
  10cc99:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10cc9e:	89 de                	mov    %ebx,%esi                      
  10cca0:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).  It is actually
   *        created that way by the IMFS.                             
   */                                                                 
                                                                      
  status = mkdir( "/dev", 0777);                                      
  10cca2:	83 c4 18             	add    $0x18,%esp                     
  10cca5:	68 ff 01 00 00       	push   $0x1ff                         
  10ccaa:	68 2a 77 11 00       	push   $0x11772a                      
  10ccaf:	e8 24 04 00 00       	call   10d0d8 <mkdir>                 
  if ( status != 0 )                                                  
  10ccb4:	83 c4 10             	add    $0x10,%esp                     
  10ccb7:	85 c0                	test   %eax,%eax                      
  10ccb9:	74 0d                	je     10ccc8 <rtems_filesystem_initialize+0xe0><== ALWAYS TAKEN
    rtems_fatal_error_occurred( 0xABCD0003 );                         
  10ccbb:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10ccbe:	68 03 00 cd ab       	push   $0xabcd0003                    <== NOT EXECUTED
  10ccc3:	e9 77 ff ff ff       	jmp    10cc3f <rtems_filesystem_initialize+0x57><== NOT EXECUTED
   *  before device drivers are initialized.  So we return via a base 
   *  filesystem image and nothing auto-mounted at this point.        
   */                                                                 
                                                                      
#endif                                                                
}                                                                     
  10ccc8:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10cccb:	5b                   	pop    %ebx                           
  10cccc:	5e                   	pop    %esi                           
  10cccd:	5f                   	pop    %edi                           
  10ccce:	c9                   	leave                                 
  10cccf:	c3                   	ret                                   
                                                                      

0010a420 <rtems_filesystem_nodes_equal>: ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){
  10a420:	55                   	push   %ebp                           <== NOT EXECUTED
  10a421:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10a423:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10a426:	8b 10                	mov    (%eax),%edx                    <== NOT EXECUTED
  10a428:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  10a42b:	3b 10                	cmp    (%eax),%edx                    <== NOT EXECUTED
  10a42d:	0f 94 c0             	sete   %al                            <== NOT EXECUTED
  return ( loc1->node_access == loc2->node_access );                  
}                                                                     
  10a430:	c9                   	leave                                 <== NOT EXECUTED
  10a431:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001094d0 <rtems_interrupt_catch>: rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) {
  1094d0:	55                   	push   %ebp                           <== NOT EXECUTED
  1094d1:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1094d3:	53                   	push   %ebx                           <== NOT EXECUTED
  1094d4:	83 ec 04             	sub    $0x4,%esp                      <== NOT EXECUTED
  1094d7:	8b 4d 08             	mov    0x8(%ebp),%ecx                 <== NOT EXECUTED
  1094da:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 <== NOT EXECUTED
  1094dd:	8b 55 10             	mov    0x10(%ebp),%edx                <== NOT EXECUTED
  if ( !_ISR_Is_vector_number_valid( vector ) )                       
  1094e0:	b8 0a 00 00 00       	mov    $0xa,%eax                      <== NOT EXECUTED
  1094e5:	81 fb ff 00 00 00    	cmp    $0xff,%ebx                     <== NOT EXECUTED
  1094eb:	77 1d                	ja     10950a <rtems_interrupt_catch+0x3a><== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )      
  1094ed:	85 c9                	test   %ecx,%ecx                      <== NOT EXECUTED
  1094ef:	74 14                	je     109505 <rtems_interrupt_catch+0x35><== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )      
  1094f1:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  1094f3:	74 10                	je     109505 <rtems_interrupt_catch+0x35><== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _ISR_Install_vector(                                                
  1094f5:	50                   	push   %eax                           <== NOT EXECUTED
  1094f6:	52                   	push   %edx                           <== NOT EXECUTED
  1094f7:	51                   	push   %ecx                           <== NOT EXECUTED
  1094f8:	53                   	push   %ebx                           <== NOT EXECUTED
  1094f9:	e8 44 cc ff ff       	call   106142 <_CPU_ISR_install_vector><== NOT EXECUTED
  1094fe:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  109500:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  109503:	eb 05                	jmp    10950a <rtems_interrupt_catch+0x3a><== NOT EXECUTED
    vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); 
                                                                      
  return RTEMS_SUCCESSFUL;                                            
  109505:	b8 09 00 00 00       	mov    $0x9,%eax                      <== NOT EXECUTED
}                                                                     
  10950a:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  10950d:	c9                   	leave                                 <== NOT EXECUTED
  10950e:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00106188 <rtems_io_lookup_name>: rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) {
  106188:	55                   	push   %ebp                           <== NOT EXECUTED
  106189:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10618b:	57                   	push   %edi                           <== NOT EXECUTED
  10618c:	56                   	push   %esi                           <== NOT EXECUTED
  10618d:	53                   	push   %ebx                           <== NOT EXECUTED
  10618e:	83 ec 1c             	sub    $0x1c,%esp                     <== NOT EXECUTED
  106191:	8b 7d 08             	mov    0x8(%ebp),%edi                 <== NOT EXECUTED
  106194:	8b 75 0c             	mov    0xc(%ebp),%esi                 <== NOT EXECUTED
  IMFS_jnode_t                      *the_jnode;                       
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
  rtems_filesystem_node_types_t      node_type;                       
                                                                      
  result = rtems_filesystem_evaluate_path( name, 0x00, &loc, true );  
  106197:	6a 01                	push   $0x1                           <== NOT EXECUTED
  106199:	8d 45 e4             	lea    -0x1c(%ebp),%eax               <== NOT EXECUTED
  10619c:	50                   	push   %eax                           <== NOT EXECUTED
  10619d:	6a 00                	push   $0x0                           <== NOT EXECUTED
  10619f:	57                   	push   %edi                           <== NOT EXECUTED
  1061a0:	e8 b1 01 00 00       	call   106356 <rtems_filesystem_evaluate_path><== NOT EXECUTED
  1061a5:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
  the_jnode = loc.node_access;                                        
  1061a7:	8b 55 e4             	mov    -0x1c(%ebp),%edx               <== NOT EXECUTED
  1061aa:	89 55 e0             	mov    %edx,-0x20(%ebp)               <== NOT EXECUTED
                                                                      
  if ( !loc.ops->node_type_h ) {                                      
  1061ad:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  1061b0:	8b 50 10             	mov    0x10(%eax),%edx                <== NOT EXECUTED
  1061b3:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1061b6:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  1061b8:	75 23                	jne    1061dd <rtems_io_lookup_name+0x55><== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
  1061ba:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  1061bd:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1061bf:	74 0c                	je     1061cd <rtems_io_lookup_name+0x45><== NOT EXECUTED
  1061c1:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1061c4:	8d 55 e4             	lea    -0x1c(%ebp),%edx               <== NOT EXECUTED
  1061c7:	52                   	push   %edx                           <== NOT EXECUTED
  1061c8:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1061ca:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  1061cd:	e8 56 8f 00 00       	call   10f128 <__errno>               <== NOT EXECUTED
  1061d2:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1061d8:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  1061db:	eb 78                	jmp    106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
  }                                                                   
                                                                      
  node_type = (*loc.ops->node_type_h)( &loc );                        
  1061dd:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1061e0:	8d 45 e4             	lea    -0x1c(%ebp),%eax               <== NOT EXECUTED
  1061e3:	50                   	push   %eax                           <== NOT EXECUTED
  1061e4:	ff d2                	call   *%edx                          <== NOT EXECUTED
                                                                      
  if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {      
  1061e6:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1061e9:	85 db                	test   %ebx,%ebx                      <== NOT EXECUTED
  1061eb:	75 05                	jne    1061f2 <rtems_io_lookup_name+0x6a><== NOT EXECUTED
  1061ed:	83 f8 02             	cmp    $0x2,%eax                      <== NOT EXECUTED
  1061f0:	74 1e                	je     106210 <rtems_io_lookup_name+0x88><== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
  1061f2:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  1061f5:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1061f7:	74 53                	je     10624c <rtems_io_lookup_name+0xc4><== NOT EXECUTED
  1061f9:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  1061fc:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  1061fe:	74 4c                	je     10624c <rtems_io_lookup_name+0xc4><== NOT EXECUTED
  106200:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106203:	8d 45 e4             	lea    -0x1c(%ebp),%eax               <== NOT EXECUTED
  106206:	50                   	push   %eax                           <== NOT EXECUTED
  106207:	ff d2                	call   *%edx                          <== NOT EXECUTED
  106209:	b8 0d 00 00 00       	mov    $0xd,%eax                      <== NOT EXECUTED
  10620e:	eb 37                	jmp    106247 <rtems_io_lookup_name+0xbf><== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  device_info->device_name        = (char *) name;                    
  106210:	89 3e                	mov    %edi,(%esi)                    <== NOT EXECUTED
  device_info->device_name_length = strlen( name );                   
  106212:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  106214:	83 c9 ff             	or     $0xffffffff,%ecx               <== NOT EXECUTED
  106217:	f2 ae                	repnz scas %es:(%edi),%al             <== NOT EXECUTED
  106219:	f7 d1                	not    %ecx                           <== NOT EXECUTED
  10621b:	49                   	dec    %ecx                           <== NOT EXECUTED
  10621c:	89 4e 04             	mov    %ecx,0x4(%esi)                 <== NOT EXECUTED
  device_info->major              = the_jnode->info.device.major;     
  10621f:	8b 55 e0             	mov    -0x20(%ebp),%edx               <== NOT EXECUTED
  106222:	8b 42 50             	mov    0x50(%edx),%eax                <== NOT EXECUTED
  106225:	89 46 08             	mov    %eax,0x8(%esi)                 <== NOT EXECUTED
  device_info->minor              = the_jnode->info.device.minor;     
  106228:	8b 42 54             	mov    0x54(%edx),%eax                <== NOT EXECUTED
  10622b:	89 46 0c             	mov    %eax,0xc(%esi)                 <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  10622e:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  106231:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  106233:	74 1e                	je     106253 <rtems_io_lookup_name+0xcb><== NOT EXECUTED
  106235:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  106238:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10623a:	74 17                	je     106253 <rtems_io_lookup_name+0xcb><== NOT EXECUTED
  10623c:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10623f:	8d 55 e4             	lea    -0x1c(%ebp),%edx               <== NOT EXECUTED
  106242:	52                   	push   %edx                           <== NOT EXECUTED
  106243:	ff d0                	call   *%eax                          <== NOT EXECUTED
  106245:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  106247:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10624a:	eb 09                	jmp    106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
  10624c:	b8 0d 00 00 00       	mov    $0xd,%eax                      <== NOT EXECUTED
  106251:	eb 02                	jmp    106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
  106253:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
                                                                      
#endif                                                                
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  106255:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  106258:	5b                   	pop    %ebx                           <== NOT EXECUTED
  106259:	5e                   	pop    %esi                           <== NOT EXECUTED
  10625a:	5f                   	pop    %edi                           <== NOT EXECUTED
  10625b:	c9                   	leave                                 <== NOT EXECUTED
  10625c:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010a4fc <rtems_io_register_driver>: rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) {
  10a4fc:	55                   	push   %ebp                           
  10a4fd:	89 e5                	mov    %esp,%ebp                      
  10a4ff:	57                   	push   %edi                           
  10a500:	56                   	push   %esi                           
  10a501:	53                   	push   %ebx                           
  10a502:	83 ec 08             	sub    $0x8,%esp                      
  10a505:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a508:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  10a50b:	8b 45 10             	mov    0x10(%ebp),%eax                
  10a50e:	89 45 f0             	mov    %eax,-0x10(%ebp)               
                                                                      
  /*                                                                  
   *  Validate the pointer data and contents passed in                
   */                                                                 
  if ( !driver_table )                                                
  10a511:	85 f6                	test   %esi,%esi                      
  10a513:	0f 84 9a 00 00 00    	je     10a5b3 <rtems_io_register_driver+0xb7>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !registered_major )                                            
  10a519:	85 c0                	test   %eax,%eax                      
  10a51b:	0f 84 92 00 00 00    	je     10a5b3 <rtems_io_register_driver+0xb7>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !driver_table->initialization_entry && !driver_table->open_entry )
  10a521:	83 3e 00             	cmpl   $0x0,(%esi)                    
  10a524:	75 0a                	jne    10a530 <rtems_io_register_driver+0x34>
  10a526:	83 7e 04 00          	cmpl   $0x0,0x4(%esi)                 
  10a52a:	0f 84 83 00 00 00    	je     10a5b3 <rtems_io_register_driver+0xb7><== ALWAYS TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  *registered_major = 0;                                              
  10a530:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10a533:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    
                                                                      
  /*                                                                  
   *  The requested major number is higher than what is configured.   
   */                                                                 
  if ( major >= _IO_Number_of_drivers )                               
  10a539:	8b 15 10 15 12 00    	mov    0x121510,%edx                  
  10a53f:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  10a544:	39 d3                	cmp    %edx,%ebx                      
  10a546:	73 77                	jae    10a5bf <rtems_io_register_driver+0xc3>
  /*                                                                  
   * Test for initialise/open being present to indicate the driver slot is
   * in use.                                                          
   */                                                                 
                                                                      
  if ( major == 0 ) {                                                 
  10a548:	85 db                	test   %ebx,%ebx                      
  10a54a:	75 2b                	jne    10a577 <rtems_io_register_driver+0x7b>
    bool found = false;                                               
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {     
  10a54c:	8d 5a ff             	lea    -0x1(%edx),%ebx                
  10a54f:	6b c2 18             	imul   $0x18,%edx,%eax                
  10a552:	83 e8 18             	sub    $0x18,%eax                     
  10a555:	03 05 14 15 12 00    	add    0x121514,%eax                  
  10a55b:	eb 0f                	jmp    10a56c <rtems_io_register_driver+0x70>
      if ( !_IO_Driver_address_table[major].initialization_entry &&   
  10a55d:	83 38 00             	cmpl   $0x0,(%eax)                    
  10a560:	75 06                	jne    10a568 <rtems_io_register_driver+0x6c>
  10a562:	83 78 04 00          	cmpl   $0x0,0x4(%eax)                 
  10a566:	74 0f                	je     10a577 <rtems_io_register_driver+0x7b><== ALWAYS TAKEN
   * in use.                                                          
   */                                                                 
                                                                      
  if ( major == 0 ) {                                                 
    bool found = false;                                               
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {     
  10a568:	4b                   	dec    %ebx                           
  10a569:	83 e8 18             	sub    $0x18,%eax                     
  10a56c:	85 db                	test   %ebx,%ebx                      
  10a56e:	75 ed                	jne    10a55d <rtems_io_register_driver+0x61>
  10a570:	b8 05 00 00 00       	mov    $0x5,%eax                      
  10a575:	eb 48                	jmp    10a5bf <rtems_io_register_driver+0xc3>
                                                                      
    if ( !found )                                                     
      return RTEMS_TOO_MANY;                                          
  }                                                                   
                                                                      
  if ( _IO_Driver_address_table[major].initialization_entry ||        
  10a577:	6b fb 18             	imul   $0x18,%ebx,%edi                
  10a57a:	03 3d 14 15 12 00    	add    0x121514,%edi                  
  10a580:	83 3f 00             	cmpl   $0x0,(%edi)                    
  10a583:	75 35                	jne    10a5ba <rtems_io_register_driver+0xbe>
  10a585:	83 7f 04 00          	cmpl   $0x0,0x4(%edi)                 
  10a589:	75 2f                	jne    10a5ba <rtems_io_register_driver+0xbe><== NEVER TAKEN
       _IO_Driver_address_table[major].open_entry )                   
    return RTEMS_RESOURCE_IN_USE;                                     
                                                                      
                                                                      
  _IO_Driver_address_table[major] = *driver_table;                    
  10a58b:	b9 06 00 00 00       	mov    $0x6,%ecx                      
  10a590:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  *registered_major               = major;                            
  10a592:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10a595:	89 18                	mov    %ebx,(%eax)                    
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
  10a597:	c7 45 10 00 00 00 00 	movl   $0x0,0x10(%ebp)                
  10a59e:	c7 45 0c 00 00 00 00 	movl   $0x0,0xc(%ebp)                 
  10a5a5:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
}                                                                     
  10a5a8:	5b                   	pop    %ebx                           
  10a5a9:	5e                   	pop    %esi                           
  10a5aa:	5b                   	pop    %ebx                           
  10a5ab:	5e                   	pop    %esi                           
  10a5ac:	5f                   	pop    %edi                           
  10a5ad:	c9                   	leave                                 
                                                                      
                                                                      
  _IO_Driver_address_table[major] = *driver_table;                    
  *registered_major               = major;                            
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
  10a5ae:	e9 ed fd ff ff       	jmp    10a3a0 <rtems_io_initialize>   
  10a5b3:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10a5b8:	eb 05                	jmp    10a5bf <rtems_io_register_driver+0xc3>
  10a5ba:	b8 0c 00 00 00       	mov    $0xc,%eax                      
}                                                                     
  10a5bf:	5a                   	pop    %edx                           
  10a5c0:	59                   	pop    %ecx                           
  10a5c1:	5b                   	pop    %ebx                           
  10a5c2:	5e                   	pop    %esi                           
  10a5c3:	5f                   	pop    %edi                           
  10a5c4:	c9                   	leave                                 
  10a5c5:	c3                   	ret                                   
                                                                      

0010a5c8 <rtems_io_unregister_driver>: */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) {
  10a5c8:	55                   	push   %ebp                           
  10a5c9:	89 e5                	mov    %esp,%ebp                      
  10a5cb:	57                   	push   %edi                           
  10a5cc:	83 ec 04             	sub    $0x4,%esp                      
  10a5cf:	8b 55 08             	mov    0x8(%ebp),%edx                 
  if ( major < _IO_Number_of_drivers ) {                              
  10a5d2:	b8 0d 00 00 00       	mov    $0xd,%eax                      
  10a5d7:	3b 15 10 15 12 00    	cmp    0x121510,%edx                  
  10a5dd:	73 12                	jae    10a5f1 <rtems_io_unregister_driver+0x29><== NEVER TAKEN
    memset(                                                           
  10a5df:	6b fa 18             	imul   $0x18,%edx,%edi                
  10a5e2:	03 3d 14 15 12 00    	add    0x121514,%edi                  
  10a5e8:	b9 06 00 00 00       	mov    $0x6,%ecx                      
  10a5ed:	31 c0                	xor    %eax,%eax                      
  10a5ef:	f3 ab                	rep stos %eax,%es:(%edi)              
      sizeof( rtems_driver_address_table )                            
    );                                                                
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
  return RTEMS_UNSATISFIED;                                           
}                                                                     
  10a5f1:	5a                   	pop    %edx                           
  10a5f2:	5f                   	pop    %edi                           
  10a5f3:	c9                   	leave                                 
  10a5f4:	c3                   	ret                                   
                                                                      

0010b4d8 <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) {
  10b4d8:	55                   	push   %ebp                           
  10b4d9:	89 e5                	mov    %esp,%ebp                      
  10b4db:	57                   	push   %edi                           
  10b4dc:	56                   	push   %esi                           
  10b4dd:	53                   	push   %ebx                           
  10b4de:	83 ec 0c             	sub    $0xc,%esp                      
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
  10b4e1:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  10b4e5:	74 41                	je     10b528 <rtems_iterate_over_all_threads+0x50><== NEVER TAKEN
    return;                                                           
  10b4e7:	bf 01 00 00 00       	mov    $0x1,%edi                      
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
  10b4ec:	8b 04 bd 68 92 12 00 	mov    0x129268(,%edi,4),%eax         
  10b4f3:	85 c0                	test   %eax,%eax                      
  10b4f5:	74 2b                	je     10b522 <rtems_iterate_over_all_threads+0x4a>
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
  10b4f7:	8b 70 04             	mov    0x4(%eax),%esi                 
    if ( information ) {                                              
  10b4fa:	bb 01 00 00 00       	mov    $0x1,%ebx                      
  10b4ff:	85 f6                	test   %esi,%esi                      
  10b501:	75 17                	jne    10b51a <rtems_iterate_over_all_threads+0x42><== ALWAYS TAKEN
  10b503:	eb 1d                	jmp    10b522 <rtems_iterate_over_all_threads+0x4a><== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
        the_thread = (Thread_Control *)information->local_table[ i ]; 
  10b505:	8b 46 1c             	mov    0x1c(%esi),%eax                
  10b508:	8b 04 98             	mov    (%eax,%ebx,4),%eax             
                                                                      
        if ( !the_thread )                                            
  10b50b:	85 c0                	test   %eax,%eax                      
  10b50d:	74 0a                	je     10b519 <rtems_iterate_over_all_threads+0x41><== NEVER TAKEN
          continue;                                                   
                                                                      
        (*routine)(the_thread);                                       
  10b50f:	83 ec 0c             	sub    $0xc,%esp                      
  10b512:	50                   	push   %eax                           
  10b513:	ff 55 08             	call   *0x8(%ebp)                     
  10b516:	83 c4 10             	add    $0x10,%esp                     
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
  10b519:	43                   	inc    %ebx                           
  10b51a:	0f b7 46 10          	movzwl 0x10(%esi),%eax                
  10b51e:	39 c3                	cmp    %eax,%ebx                      
  10b520:	76 e3                	jbe    10b505 <rtems_iterate_over_all_threads+0x2d>
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
        api_index++ ) {                                               
  10b522:	47                   	inc    %edi                           
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
  10b523:	83 ff 05             	cmp    $0x5,%edi                      
  10b526:	75 c4                	jne    10b4ec <rtems_iterate_over_all_threads+0x14>
        (*routine)(the_thread);                                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
}                                                                     
  10b528:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b52b:	5b                   	pop    %ebx                           
  10b52c:	5e                   	pop    %esi                           
  10b52d:	5f                   	pop    %edi                           
  10b52e:	c9                   	leave                                 
  10b52f:	c3                   	ret                                   
                                                                      

0010d011 <rtems_libio_allocate>: * This routine searches the IOP Table for an unused entry. If it * finds one, it returns it. Otherwise, it returns NULL. */ rtems_libio_t *rtems_libio_allocate( void ) {
  10d011:	55                   	push   %ebp                           
  10d012:	89 e5                	mov    %esp,%ebp                      
  10d014:	57                   	push   %edi                           
  10d015:	53                   	push   %ebx                           
  10d016:	83 ec 24             	sub    $0x24,%esp                     
  rtems_libio_t *iop, *next;                                          
  rtems_status_code rc;                                               
  rtems_id sema;                                                      
                                                                      
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
  10d019:	6a 00                	push   $0x0                           
  10d01b:	6a 00                	push   $0x0                           
  10d01d:	ff 35 40 d6 11 00    	pushl  0x11d640                       
  10d023:	e8 4c c1 ff ff       	call   109174 <rtems_semaphore_obtain>
                                                                      
  if (rtems_libio_iop_freelist) {                                     
  10d028:	8b 15 3c d6 11 00    	mov    0x11d63c,%edx                  
  10d02e:	83 c4 10             	add    $0x10,%esp                     
  10d031:	85 d2                	test   %edx,%edx                      
  10d033:	74 55                	je     10d08a <rtems_libio_allocate+0x79>
    rc = rtems_semaphore_create(                                      
  10d035:	83 ec 0c             	sub    $0xc,%esp                      
  10d038:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10d03b:	50                   	push   %eax                           
  10d03c:	6a 00                	push   $0x0                           
  10d03e:	6a 54                	push   $0x54                          
  10d040:	6a 01                	push   $0x1                           
  10d042:	2b 15 38 d6 11 00    	sub    0x11d638,%edx                  
  10d048:	c1 fa 02             	sar    $0x2,%edx                      
  10d04b:	69 c2 c5 4e ec c4    	imul   $0xc4ec4ec5,%edx,%eax          
  10d051:	0d 00 49 42 4c       	or     $0x4c424900,%eax               
  10d056:	50                   	push   %eax                           
  10d057:	e8 e4 be ff ff       	call   108f40 <rtems_semaphore_create>
      1,                                                              
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &sema                                                           
    );                                                                
    if (rc != RTEMS_SUCCESSFUL)                                       
  10d05c:	83 c4 20             	add    $0x20,%esp                     
  10d05f:	85 c0                	test   %eax,%eax                      
  10d061:	75 27                	jne    10d08a <rtems_libio_allocate+0x79><== NEVER TAKEN
      goto failed;                                                    
    iop = rtems_libio_iop_freelist;                                   
  10d063:	8b 1d 3c d6 11 00    	mov    0x11d63c,%ebx                  
    next = iop->data1;                                                
  10d069:	8b 53 28             	mov    0x28(%ebx),%edx                
    (void) memset( iop, 0, sizeof(rtems_libio_t) );                   
  10d06c:	b9 0d 00 00 00       	mov    $0xd,%ecx                      
  10d071:	89 df                	mov    %ebx,%edi                      
  10d073:	f3 ab                	rep stos %eax,%es:(%edi)              
    iop->flags = LIBIO_FLAGS_OPEN;                                    
  10d075:	c7 43 0c 00 01 00 00 	movl   $0x100,0xc(%ebx)               
    iop->sem = sema;                                                  
  10d07c:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  10d07f:	89 43 20             	mov    %eax,0x20(%ebx)                
    rtems_libio_iop_freelist = next;                                  
  10d082:	89 15 3c d6 11 00    	mov    %edx,0x11d63c                  
  10d088:	eb 02                	jmp    10d08c <rtems_libio_allocate+0x7b>
  }                                                                   
                                                                      
failed:                                                               
  iop = 0;                                                            
                                                                      
done:                                                                 
  10d08a:	31 db                	xor    %ebx,%ebx                      
  rtems_semaphore_release( rtems_libio_semaphore );                   
  10d08c:	83 ec 0c             	sub    $0xc,%esp                      
  10d08f:	ff 35 40 d6 11 00    	pushl  0x11d640                       
  10d095:	e8 c2 c1 ff ff       	call   10925c <rtems_semaphore_release>
  return iop;                                                         
}                                                                     
  10d09a:	89 d8                	mov    %ebx,%eax                      
  10d09c:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10d09f:	5b                   	pop    %ebx                           
  10d0a0:	5f                   	pop    %edi                           
  10d0a1:	c9                   	leave                                 
  10d0a2:	c3                   	ret                                   
                                                                      

0010cfbc <rtems_libio_free>: */ void rtems_libio_free( rtems_libio_t *iop ) {
  10cfbc:	55                   	push   %ebp                           
  10cfbd:	89 e5                	mov    %esp,%ebp                      
  10cfbf:	53                   	push   %ebx                           
  10cfc0:	83 ec 08             	sub    $0x8,%esp                      
  10cfc3:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
  10cfc6:	6a 00                	push   $0x0                           
  10cfc8:	6a 00                	push   $0x0                           
  10cfca:	ff 35 40 d6 11 00    	pushl  0x11d640                       
  10cfd0:	e8 9f c1 ff ff       	call   109174 <rtems_semaphore_obtain>
                                                                      
    if (iop->sem)                                                     
  10cfd5:	8b 43 20             	mov    0x20(%ebx),%eax                
  10cfd8:	83 c4 10             	add    $0x10,%esp                     
  10cfdb:	85 c0                	test   %eax,%eax                      
  10cfdd:	74 0c                	je     10cfeb <rtems_libio_free+0x2f> <== NEVER TAKEN
      rtems_semaphore_delete(iop->sem);                               
  10cfdf:	83 ec 0c             	sub    $0xc,%esp                      
  10cfe2:	50                   	push   %eax                           
  10cfe3:	e8 fc c0 ff ff       	call   1090e4 <rtems_semaphore_delete>
  10cfe8:	83 c4 10             	add    $0x10,%esp                     
                                                                      
    iop->flags &= ~LIBIO_FLAGS_OPEN;                                  
  10cfeb:	81 63 0c ff fe ff ff 	andl   $0xfffffeff,0xc(%ebx)          
    iop->data1 = rtems_libio_iop_freelist;                            
  10cff2:	a1 3c d6 11 00       	mov    0x11d63c,%eax                  
  10cff7:	89 43 28             	mov    %eax,0x28(%ebx)                
    rtems_libio_iop_freelist = iop;                                   
  10cffa:	89 1d 3c d6 11 00    	mov    %ebx,0x11d63c                  
                                                                      
  rtems_semaphore_release(rtems_libio_semaphore);                     
  10d000:	a1 40 d6 11 00       	mov    0x11d640,%eax                  
  10d005:	89 45 08             	mov    %eax,0x8(%ebp)                 
}                                                                     
  10d008:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10d00b:	c9                   	leave                                 
                                                                      
    iop->flags &= ~LIBIO_FLAGS_OPEN;                                  
    iop->data1 = rtems_libio_iop_freelist;                            
    rtems_libio_iop_freelist = iop;                                   
                                                                      
  rtems_semaphore_release(rtems_libio_semaphore);                     
  10d00c:	e9 4b c2 ff ff       	jmp    10925c <rtems_semaphore_release>
                                                                      

001064f0 <rtems_libio_init>: * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) {
  1064f0:	55                   	push   %ebp                           
  1064f1:	89 e5                	mov    %esp,%ebp                      
  1064f3:	53                   	push   %ebx                           
  1064f4:	83 ec 04             	sub    $0x4,%esp                      
    rtems_status_code rc;                                             
    int i;                                                            
    rtems_libio_t *iop;                                               
                                                                      
    if (rtems_libio_number_iops > 0)                                  
  1064f7:	a1 d8 92 11 00       	mov    0x1192d8,%eax                  
  1064fc:	85 c0                	test   %eax,%eax                      
  1064fe:	74 46                	je     106546 <rtems_libio_init+0x56> 
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
  106500:	52                   	push   %edx                           
  106501:	52                   	push   %edx                           
  106502:	6a 34                	push   $0x34                          
  106504:	50                   	push   %eax                           
  106505:	e8 c6 67 00 00       	call   10ccd0 <calloc>                
  10650a:	89 c1                	mov    %eax,%ecx                      
  10650c:	a3 38 d6 11 00       	mov    %eax,0x11d638                  
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
  106511:	83 c4 10             	add    $0x10,%esp                     
  106514:	85 c0                	test   %eax,%eax                      
  106516:	75 07                	jne    10651f <rtems_libio_init+0x2f> <== ALWAYS TAKEN
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
  106518:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10651b:	6a 1a                	push   $0x1a                          <== NOT EXECUTED
  10651d:	eb 4a                	jmp    106569 <rtems_libio_init+0x79> <== NOT EXECUTED
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
  10651f:	a3 3c d6 11 00       	mov    %eax,0x11d63c                  
	for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)         
  106524:	8b 1d d8 92 11 00    	mov    0x1192d8,%ebx                  
  10652a:	89 c2                	mov    %eax,%edx                      
  10652c:	31 c0                	xor    %eax,%eax                      
  10652e:	eb 03                	jmp    106533 <rtems_libio_init+0x43> 
		iop->data1 = iop + 1;                                               
  106530:	89 52 f4             	mov    %edx,-0xc(%edx)                
  106533:	40                   	inc    %eax                           
  106534:	83 c2 34             	add    $0x34,%edx                     
                                                    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 < (rtems_libio_number_iops - 1) ; i++, iop++)         
  106537:	39 d8                	cmp    %ebx,%eax                      
  106539:	75 f5                	jne    106530 <rtems_libio_init+0x40> 
		iop->data1 = iop + 1;                                               
	iop->data1 = NULL;                                                   
  10653b:	6b c0 34             	imul   $0x34,%eax,%eax                
  10653e:	c7 44 01 f4 00 00 00 	movl   $0x0,-0xc(%ecx,%eax,1)         
  106545:	00                                                          
  /*                                                                  
   *  Create the binary semaphore used to provide mutual exclusion    
   *  on the IOP Table.                                               
   */                                                                 
                                                                      
  rc = rtems_semaphore_create(                                        
  106546:	83 ec 0c             	sub    $0xc,%esp                      
  106549:	68 40 d6 11 00       	push   $0x11d640                      
  10654e:	6a 00                	push   $0x0                           
  106550:	6a 54                	push   $0x54                          
  106552:	6a 01                	push   $0x1                           
  106554:	68 4f 49 42 4c       	push   $0x4c42494f                    
  106559:	e8 e2 29 00 00       	call   108f40 <rtems_semaphore_create>
    1,                                                                
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
  10655e:	83 c4 20             	add    $0x20,%esp                     
  106561:	85 c0                	test   %eax,%eax                      
  106563:	74 09                	je     10656e <rtems_libio_init+0x7e> <== ALWAYS TAKEN
    rtems_fatal_error_occurred( rc );                                 
  106565:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106568:	50                   	push   %eax                           <== NOT EXECUTED
  106569:	e8 26 32 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  rtems_filesystem_initialize();                                      
}                                                                     
  10656e:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  106571:	c9                   	leave                                 
                                                                      
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  rtems_filesystem_initialize();                                      
  106572:	e9 71 66 00 00       	jmp    10cbe8 <rtems_filesystem_initialize>
                                                                      

00107b69 <rtems_libio_set_private_env>: rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) {
  107b69:	55                   	push   %ebp                           
  107b6a:	89 e5                	mov    %esp,%ebp                      
  107b6c:	57                   	push   %edi                           
  107b6d:	56                   	push   %esi                           
  107b6e:	53                   	push   %ebx                           
  107b6f:	83 ec 30             	sub    $0x30,%esp                     
  rtems_status_code 					sc;                                          
  rtems_id          					task_id;                                     
  rtems_filesystem_location_info_t		loc;                              
                                                                      
  sc=rtems_task_ident(RTEMS_SELF,0,&task_id);                         
  107b72:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  107b75:	50                   	push   %eax                           
  107b76:	6a 00                	push   $0x0                           
  107b78:	6a 00                	push   $0x0                           
  107b7a:	e8 c9 25 00 00       	call   10a148 <rtems_task_ident>      
  107b7f:	89 c3                	mov    %eax,%ebx                      
  if (sc != RTEMS_SUCCESSFUL) return sc;                              
  107b81:	83 c4 10             	add    $0x10,%esp                     
  107b84:	85 c0                	test   %eax,%eax                      
  107b86:	0f 85 d4 00 00 00    	jne    107c60 <rtems_libio_set_private_env+0xf7><== NEVER TAKEN
                                                                      
  /* Only for the first time a malloc is necesary */                  
  if (rtems_current_user_env==&rtems_global_user_env) {               
  107b8c:	81 3d ac e3 11 00 00 	cmpl   $0x120a00,0x11e3ac             
  107b93:	0a 12 00                                                    
  107b96:	75 4e                	jne    107be6 <rtems_libio_set_private_env+0x7d>
   rtems_user_env_t	*tmp = malloc(sizeof(rtems_user_env_t));          
  107b98:	83 ec 0c             	sub    $0xc,%esp                      
  107b9b:	6a 40                	push   $0x40                          
  107b9d:	e8 b2 f4 ff ff       	call   107054 <malloc>                
  107ba2:	89 c6                	mov    %eax,%esi                      
   if (!tmp)                                                          
  107ba4:	83 c4 10             	add    $0x10,%esp                     
  107ba7:	85 c0                	test   %eax,%eax                      
  107ba9:	75 07                	jne    107bb2 <rtems_libio_set_private_env+0x49><== ALWAYS TAKEN
  107bab:	b3 1a                	mov    $0x1a,%bl                      <== NOT EXECUTED
  107bad:	e9 ae 00 00 00       	jmp    107c60 <rtems_libio_set_private_env+0xf7><== NOT EXECUTED
                                                                      
#ifdef HAVE_USERENV_REFCNT                                            
   tmp->refcnt = 1;                                                   
#endif                                                                
                                                                      
   sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env);
  107bb2:	57                   	push   %edi                           
  107bb3:	68 74 7a 10 00       	push   $0x107a74                      
  107bb8:	68 ac e3 11 00       	push   $0x11e3ac                      
  107bbd:	6a 00                	push   $0x0                           
  107bbf:	e8 a4 26 00 00       	call   10a268 <rtems_task_variable_add>
  107bc4:	89 c7                	mov    %eax,%edi                      
   if (sc != RTEMS_SUCCESSFUL) {                                      
  107bc6:	83 c4 10             	add    $0x10,%esp                     
  107bc9:	85 c0                	test   %eax,%eax                      
  107bcb:	74 13                	je     107be0 <rtems_libio_set_private_env+0x77><== ALWAYS TAKEN
	 /* don't use free_user_env because the pathlocs are                 
	  * not initialized yet                                              
	  */                                                                 
     free(tmp);                                                       
  107bcd:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107bd0:	56                   	push   %esi                           <== NOT EXECUTED
  107bd1:	e8 fe ef ff ff       	call   106bd4 <free>                  <== NOT EXECUTED
  107bd6:	89 fb                	mov    %edi,%ebx                      <== NOT EXECUTED
  107bd8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107bdb:	e9 80 00 00 00       	jmp    107c60 <rtems_libio_set_private_env+0xf7><== NOT EXECUTED
     return sc;                                                       
   }                                                                  
   rtems_current_user_env = tmp;                                      
  107be0:	89 35 ac e3 11 00    	mov    %esi,0x11e3ac                  
  };                                                                  
                                                                      
  *rtems_current_user_env = rtems_global_user_env; /* get the global values*/
  107be6:	8b 3d ac e3 11 00    	mov    0x11e3ac,%edi                  
  107bec:	be 00 0a 12 00       	mov    $0x120a00,%esi                 
  107bf1:	b9 10 00 00 00       	mov    $0x10,%ecx                     
  107bf6:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  rtems_current_user_env->task_id=task_id;         /* mark the local values*/
  107bf8:	8b 15 ac e3 11 00    	mov    0x11e3ac,%edx                  
  107bfe:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  107c01:	89 02                	mov    %eax,(%edx)                    
                                                                      
  /* get a clean root */                                              
  rtems_filesystem_root    = THE_ROOT_FS_LOC;                         
  107c03:	8d 7a 14             	lea    0x14(%edx),%edi                
  107c06:	a1 40 0a 12 00       	mov    0x120a40,%eax                  
  107c0b:	8d 70 18             	lea    0x18(%eax),%esi                
  107c0e:	b1 04                	mov    $0x4,%cl                       
  107c10:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
   * code we must _not_ free the original locs because                
   * what we are trying to do here is forking off                     
   * clones.                                                          
   */                                                                 
                                                                      
  rtems_filesystem_evaluate_path("/", 0, &loc, 0);                    
  107c12:	6a 00                	push   $0x0                           
  107c14:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  107c17:	89 45 c8             	mov    %eax,-0x38(%ebp)               
  107c1a:	50                   	push   %eax                           
  107c1b:	6a 00                	push   $0x0                           
  107c1d:	68 cf 9d 11 00       	push   $0x119dcf                      
  107c22:	e8 8b ee ff ff       	call   106ab2 <rtems_filesystem_evaluate_path>
  rtems_filesystem_root    = loc;                                     
  107c27:	a1 ac e3 11 00       	mov    0x11e3ac,%eax                  
  107c2c:	8d 78 14             	lea    0x14(%eax),%edi                
  107c2f:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  107c34:	8b 75 c8             	mov    -0x38(%ebp),%esi               
  107c37:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  rtems_filesystem_evaluate_path("/", 0, &loc, 0);                    
  107c39:	6a 00                	push   $0x0                           
  107c3b:	8d 45 e0             	lea    -0x20(%ebp),%eax               
  107c3e:	50                   	push   %eax                           
  107c3f:	6a 00                	push   $0x0                           
  107c41:	68 cf 9d 11 00       	push   $0x119dcf                      
  107c46:	e8 67 ee ff ff       	call   106ab2 <rtems_filesystem_evaluate_path>
  rtems_filesystem_current = loc;                                     
  107c4b:	a1 ac e3 11 00       	mov    0x11e3ac,%eax                  
  107c50:	8d 78 04             	lea    0x4(%eax),%edi                 
  107c53:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  107c58:	8b 75 c8             	mov    -0x38(%ebp),%esi               
  107c5b:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  107c5d:	83 c4 20             	add    $0x20,%esp                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  107c60:	89 d8                	mov    %ebx,%eax                      
  107c62:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  107c65:	5b                   	pop    %ebx                           
  107c66:	5e                   	pop    %esi                           
  107c67:	5f                   	pop    %edi                           
  107c68:	c9                   	leave                                 
  107c69:	c3                   	ret                                   
                                                                      

00107acb <rtems_libio_share_private_env>: * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ #ifndef HAVE_USERENV_REFCNT rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
  107acb:	55                   	push   %ebp                           <== NOT EXECUTED
  107acc:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107ace:	53                   	push   %ebx                           <== NOT EXECUTED
  107acf:	83 ec 18             	sub    $0x18,%esp                     <== NOT EXECUTED
  rtems_status_code  sc;                                              
  rtems_user_env_t * shared_user_env;                                 
  rtems_id           current_task_id;                                 
                                                                      
  sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id);                 
  107ad2:	8d 45 f4             	lea    -0xc(%ebp),%eax                <== NOT EXECUTED
  107ad5:	50                   	push   %eax                           <== NOT EXECUTED
  107ad6:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107ad8:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107ada:	e8 69 26 00 00       	call   10a148 <rtems_task_ident>      <== NOT EXECUTED
  107adf:	89 c2                	mov    %eax,%edx                      <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) return sc;                              
  107ae1:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107ae4:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107ae6:	75 7a                	jne    107b62 <rtems_libio_share_private_env+0x97><== NOT EXECUTED
                                                                      
  if (rtems_current_user_env->task_id==current_task_id) {             
  107ae8:	8b 1d ac e3 11 00    	mov    0x11e3ac,%ebx                  <== NOT EXECUTED
  107aee:	8b 03                	mov    (%ebx),%eax                    <== NOT EXECUTED
  107af0:	3b 45 f4             	cmp    -0xc(%ebp),%eax                <== NOT EXECUTED
  107af3:	75 23                	jne    107b18 <rtems_libio_share_private_env+0x4d><== NOT EXECUTED
   /* kill the current user env & task_var*/                          
	rtems_user_env_t 	*tmp = rtems_current_user_env;                     
   sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env);
  107af5:	51                   	push   %ecx                           <== NOT EXECUTED
  107af6:	51                   	push   %ecx                           <== NOT EXECUTED
  107af7:	68 ac e3 11 00       	push   $0x11e3ac                      <== NOT EXECUTED
  107afc:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107afe:	e8 fd 27 00 00       	call   10a300 <rtems_task_variable_delete><== NOT EXECUTED
  107b03:	89 c2                	mov    %eax,%edx                      <== NOT EXECUTED
   if (sc != RTEMS_SUCCESSFUL) return sc;                             
  107b05:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107b08:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107b0a:	75 56                	jne    107b62 <rtems_libio_share_private_env+0x97><== NOT EXECUTED
   free_user_env(tmp);                                                
  107b0c:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107b0f:	53                   	push   %ebx                           <== NOT EXECUTED
  107b10:	e8 5f ff ff ff       	call   107a74 <free_user_env>         <== NOT EXECUTED
  107b15:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  };                                                                  
                                                                      
  /* AT THIS POINT, rtems_current_user_env is DANGLING */             
                                                                      
  sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env,
  107b18:	52                   	push   %edx                           <== NOT EXECUTED
  107b19:	8d 45 f8             	lea    -0x8(%ebp),%eax                <== NOT EXECUTED
  107b1c:	50                   	push   %eax                           <== NOT EXECUTED
  107b1d:	68 ac e3 11 00       	push   $0x11e3ac                      <== NOT EXECUTED
  107b22:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  107b25:	e8 56 28 00 00       	call   10a380 <rtems_task_variable_get><== NOT EXECUTED
  107b2a:	89 c2                	mov    %eax,%edx                      <== NOT EXECUTED
		                       (void*)&shared_user_env       );             
  if (sc != RTEMS_SUCCESSFUL)                                         
  107b2c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107b2f:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107b31:	75 25                	jne    107b58 <rtems_libio_share_private_env+0x8d><== NOT EXECUTED
    goto bailout;                                                     
                                                                      
  sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
  107b33:	50                   	push   %eax                           <== NOT EXECUTED
  107b34:	68 74 7a 10 00       	push   $0x107a74                      <== NOT EXECUTED
  107b39:	68 ac e3 11 00       	push   $0x11e3ac                      <== NOT EXECUTED
  107b3e:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107b40:	e8 23 27 00 00       	call   10a268 <rtems_task_variable_add><== NOT EXECUTED
  107b45:	89 c2                	mov    %eax,%edx                      <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
  107b47:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107b4a:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107b4c:	75 0a                	jne    107b58 <rtems_libio_share_private_env+0x8d><== NOT EXECUTED
    goto bailout;                                                     
                                                                      
  /* the current_user_env is the same pointer that remote env */      
  rtems_current_user_env = shared_user_env;                           
  107b4e:	8b 45 f8             	mov    -0x8(%ebp),%eax                <== NOT EXECUTED
  107b51:	a3 ac e3 11 00       	mov    %eax,0x11e3ac                  <== NOT EXECUTED
  107b56:	eb 0a                	jmp    107b62 <rtems_libio_share_private_env+0x97><== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
                                                                      
bailout:                                                              
  /* fallback to the global env */                                    
  rtems_current_user_env = &rtems_global_user_env;                    
  107b58:	c7 05 ac e3 11 00 00 	movl   $0x120a00,0x11e3ac             <== NOT EXECUTED
  107b5f:	0a 12 00                                                    
  return sc;                                                          
}                                                                     
  107b62:	89 d0                	mov    %edx,%eax                      <== NOT EXECUTED
  107b64:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  107b67:	c9                   	leave                                 <== NOT EXECUTED
  107b68:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010cec4 <rtems_libio_to_fcntl_flags>: */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) {
  10cec4:	55                   	push   %ebp                           
  10cec5:	89 e5                	mov    %esp,%ebp                      
  10cec7:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  uint32_t   fcntl_flags = 0;                                         
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
  10ceca:	89 c8                	mov    %ecx,%eax                      
  10cecc:	83 e0 06             	and    $0x6,%eax                      
  10cecf:	ba 02 00 00 00       	mov    $0x2,%edx                      
  10ced4:	83 f8 06             	cmp    $0x6,%eax                      
  10ced7:	74 0f                	je     10cee8 <rtems_libio_to_fcntl_flags+0x24><== NEVER TAKEN
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
  10ced9:	31 d2                	xor    %edx,%edx                      
  10cedb:	f6 c1 02             	test   $0x2,%cl                       
  10cede:	75 08                	jne    10cee8 <rtems_libio_to_fcntl_flags+0x24><== ALWAYS TAKEN
  10cee0:	89 ca                	mov    %ecx,%edx                      <== NOT EXECUTED
  10cee2:	c1 ea 02             	shr    $0x2,%edx                      <== NOT EXECUTED
  10cee5:	83 e2 01             	and    $0x1,%edx                      <== NOT EXECUTED
    fcntl_flags |= O_RDONLY;                                          
  } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {     
    fcntl_flags |= O_WRONLY;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {     
  10cee8:	f6 c1 01             	test   $0x1,%cl                       
  10ceeb:	74 03                	je     10cef0 <rtems_libio_to_fcntl_flags+0x2c>
    fcntl_flags |= O_NONBLOCK;                                        
  10ceed:	80 ce 40             	or     $0x40,%dh                      
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {         
  10cef0:	f6 c5 02             	test   $0x2,%ch                       
  10cef3:	74 03                	je     10cef8 <rtems_libio_to_fcntl_flags+0x34>
    fcntl_flags |= O_APPEND;                                          
  10cef5:	83 ca 08             	or     $0x8,%edx                      
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {         
  10cef8:	80 e5 04             	and    $0x4,%ch                       
  10cefb:	74 03                	je     10cf00 <rtems_libio_to_fcntl_flags+0x3c>
    fcntl_flags |= O_CREAT;                                           
  10cefd:	80 ce 02             	or     $0x2,%dh                       
  }                                                                   
                                                                      
  return fcntl_flags;                                                 
}                                                                     
  10cf00:	89 d0                	mov    %edx,%eax                      
  10cf02:	c9                   	leave                                 
  10cf03:	c3                   	ret                                   
                                                                      

001085fc <rtems_memalign>: int rtems_memalign( void **pointer, size_t alignment, size_t size ) {
  1085fc:	55                   	push   %ebp                           
  1085fd:	89 e5                	mov    %esp,%ebp                      
  1085ff:	56                   	push   %esi                           
  108600:	53                   	push   %ebx                           
  108601:	8b 75 08             	mov    0x8(%ebp),%esi                 
  void *return_this;                                                  
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
  108604:	85 f6                	test   %esi,%esi                      
  108606:	74 55                	je     10865d <rtems_memalign+0x61>   
    return EINVAL;                                                    
                                                                      
  *pointer = NULL;                                                    
  108608:	c7 06 00 00 00 00    	movl   $0x0,(%esi)                    
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
  10860e:	83 3d 24 2c 12 00 03 	cmpl   $0x3,0x122c24                  
  108615:	75 09                	jne    108620 <rtems_memalign+0x24>   <== NEVER TAKEN
  108617:	e8 f8 f1 ff ff       	call   107814 <malloc_is_system_state_OK>
  10861c:	84 c0                	test   %al,%al                        
  10861e:	74 3d                	je     10865d <rtems_memalign+0x61>   <== NEVER TAKEN
                                                                      
  /*                                                                  
   *                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
  108620:	e8 46 f2 ff ff       	call   10786b <malloc_deferred_frees_process>
                                                                      
  /*                                                                  
   *  Perform the aligned allocation requested                        
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate_aligned(                     
  108625:	50                   	push   %eax                           
  108626:	ff 75 0c             	pushl  0xc(%ebp)                      
  108629:	ff 75 10             	pushl  0x10(%ebp)                     
  10862c:	68 3c 29 12 00       	push   $0x12293c                      
  108631:	e8 06 40 00 00       	call   10c63c <_Protected_heap_Allocate_aligned>
  108636:	89 c3                	mov    %eax,%ebx                      
    &RTEMS_Malloc_Heap,                                               
    size,                                                             
    alignment                                                         
  );                                                                  
  if ( !return_this )                                                 
  108638:	83 c4 10             	add    $0x10,%esp                     
  10863b:	b8 0c 00 00 00       	mov    $0xc,%eax                      
  108640:	85 db                	test   %ebx,%ebx                      
  108642:	74 1e                	je     108662 <rtems_memalign+0x66>   
    return ENOMEM;                                                    
                                                                      
  /*                                                                  
   *  If configured, update the more involved statistics              
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
  108644:	a1 34 0a 12 00       	mov    0x120a34,%eax                  
  108649:	85 c0                	test   %eax,%eax                      
  10864b:	74 0a                	je     108657 <rtems_memalign+0x5b>   <== ALWAYS TAKEN
    (*rtems_malloc_statistics_helpers->at_malloc)(pointer);           
  10864d:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108650:	56                   	push   %esi                           <== NOT EXECUTED
  108651:	ff 50 04             	call   *0x4(%eax)                     <== NOT EXECUTED
  108654:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
     */                                                               
    if (rtems_malloc_boundary_helpers)                                
      (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); 
  #endif                                                              
                                                                      
  *pointer = return_this;                                             
  108657:	89 1e                	mov    %ebx,(%esi)                    
  108659:	31 c0                	xor    %eax,%eax                      
  10865b:	eb 05                	jmp    108662 <rtems_memalign+0x66>   
  return 0;                                                           
  10865d:	b8 16 00 00 00       	mov    $0x16,%eax                     
}                                                                     
  108662:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108665:	5b                   	pop    %ebx                           
  108666:	5e                   	pop    %esi                           
  108667:	c9                   	leave                                 
  108668:	c3                   	ret                                   
                                                                      

00110d44 <rtems_message_queue_create>: uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) {
  110d44:	55                   	push   %ebp                           
  110d45:	89 e5                	mov    %esp,%ebp                      
  110d47:	57                   	push   %edi                           
  110d48:	56                   	push   %esi                           
  110d49:	53                   	push   %ebx                           
  110d4a:	83 ec 1c             	sub    $0x1c,%esp                     
  110d4d:	8b 7d 10             	mov    0x10(%ebp),%edi                
  110d50:	8b 75 14             	mov    0x14(%ebp),%esi                
  CORE_message_queue_Attributes   the_msgq_attributes;                
#if defined(RTEMS_MULTIPROCESSING)                                    
  bool                            is_global;                          
#endif                                                                
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  110d53:	b8 03 00 00 00       	mov    $0x3,%eax                      
  110d58:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  110d5c:	0f 84 b2 00 00 00    	je     110e14 <rtems_message_queue_create+0xd0>
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
  110d62:	b8 09 00 00 00       	mov    $0x9,%eax                      
  110d67:	83 7d 18 00          	cmpl   $0x0,0x18(%ebp)                
  110d6b:	0f 84 a3 00 00 00    	je     110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&       
       !_System_state_Is_multiprocessing )                            
    return RTEMS_MP_NOT_CONFIGURED;                                   
#endif                                                                
                                                                      
  if ( count == 0 )                                                   
  110d71:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  110d76:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  110d7a:	0f 84 94 00 00 00    	je     110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  if ( max_message_size == 0 )                                        
  110d80:	b8 08 00 00 00       	mov    $0x8,%eax                      
  110d85:	85 ff                	test   %edi,%edi                      
  110d87:	0f 84 87 00 00 00    	je     110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  110d8d:	a1 38 41 13 00       	mov    0x134138,%eax                  
  110d92:	40                   	inc    %eax                           
  110d93:	a3 38 41 13 00       	mov    %eax,0x134138                  
#endif                                                                
#endif                                                                
                                                                      
  _Thread_Disable_dispatch();              /* protects object pointer */
                                                                      
  the_message_queue = _Message_queue_Allocate();                      
  110d98:	e8 4f 79 00 00       	call   1186ec <_Message_queue_Allocate>
  110d9d:	89 c3                	mov    %eax,%ebx                      
                                                                      
  if ( !the_message_queue ) {                                         
  110d9f:	85 c0                	test   %eax,%eax                      
  110da1:	75 0c                	jne    110daf <rtems_message_queue_create+0x6b>
    _Thread_Enable_dispatch();                                        
  110da3:	e8 10 4a 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110da8:	b8 05 00 00 00       	mov    $0x5,%eax                      
  110dad:	eb 65                	jmp    110e14 <rtems_message_queue_create+0xd0>
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_message_queue->attribute_set = attribute_set;                   
  110daf:	89 70 10             	mov    %esi,0x10(%eax)                
                                                                      
  if (_Attributes_Is_priority( attribute_set ) )                      
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
  110db2:	31 c0                	xor    %eax,%eax                      
  110db4:	f7 c6 04 00 00 00    	test   $0x4,%esi                      
  110dba:	0f 95 c0             	setne  %al                            
  110dbd:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  else                                                                
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
                                                                      
  if ( ! _CORE_message_queue_Initialize(                              
  110dc0:	57                   	push   %edi                           
  110dc1:	ff 75 0c             	pushl  0xc(%ebp)                      
  110dc4:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  110dc7:	50                   	push   %eax                           
  110dc8:	8d 43 14             	lea    0x14(%ebx),%eax                
  110dcb:	50                   	push   %eax                           
  110dcc:	e8 3b 2e 00 00       	call   113c0c <_CORE_message_queue_Initialize>
  110dd1:	83 c4 10             	add    $0x10,%esp                     
  110dd4:	84 c0                	test   %al,%al                        
  110dd6:	75 1c                	jne    110df4 <rtems_message_queue_create+0xb0>
 *  @return This method returns the maximum memory available.  If     
 *          unsuccessful, 0 will be returned.                         
 */                                                                   
static inline uint32_t _Protected_heap_Initialize(                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  110dd8:	50                   	push   %eax                           
  110dd9:	50                   	push   %eax                           
  110dda:	53                   	push   %ebx                           
  110ddb:	68 38 4a 13 00       	push   $0x134a38                      
  110de0:	e8 a3 40 00 00       	call   114e88 <_Objects_Free>         
        _Objects_MP_Close(                                            
          &_Message_queue_Information, the_message_queue->Object.id); 
#endif                                                                
                                                                      
    _Message_queue_Free( the_message_queue );                         
    _Thread_Enable_dispatch();                                        
  110de5:	e8 ce 49 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110dea:	b8 0d 00 00 00       	mov    $0xd,%eax                      
  110def:	83 c4 10             	add    $0x10,%esp                     
  110df2:	eb 20                	jmp    110e14 <rtems_message_queue_create+0xd0>
  110df4:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  110df7:	0f b7 d1             	movzwl %cx,%edx                       
  110dfa:	a1 54 4a 13 00       	mov    0x134a54,%eax                  
  110dff:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  110e02:	8b 45 08             	mov    0x8(%ebp),%eax                 
  110e05:	89 43 0c             	mov    %eax,0xc(%ebx)                 
    &_Message_queue_Information,                                      
    &the_message_queue->Object,                                       
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_message_queue->Object.id;                                 
  110e08:	8b 45 18             	mov    0x18(%ebp),%eax                
  110e0b:	89 08                	mov    %ecx,(%eax)                    
      name,                                                           
      0                                                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  110e0d:	e8 a6 49 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110e12:	31 c0                	xor    %eax,%eax                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  110e14:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  110e17:	5b                   	pop    %ebx                           
  110e18:	5e                   	pop    %esi                           
  110e19:	5f                   	pop    %edi                           
  110e1a:	c9                   	leave                                 
  110e1b:	c3                   	ret                                   
                                                                      

00110e80 <rtems_message_queue_flush>: rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) {
  110e80:	55                   	push   %ebp                           
  110e81:	89 e5                	mov    %esp,%ebp                      
  110e83:	53                   	push   %ebx                           
  110e84:	83 ec 14             	sub    $0x14,%esp                     
  110e87:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
  110e8a:	b8 09 00 00 00       	mov    $0x9,%eax                      
  110e8f:	85 db                	test   %ebx,%ebx                      
  110e91:	74 3a                	je     110ecd <rtems_message_queue_flush+0x4d><== NEVER TAKEN
 *  @param[in] size is the size in bytes of the memory area to add    
 *  @return a status indicating success or the reason for failure     
 */                                                                   
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  110e93:	50                   	push   %eax                           
  110e94:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  110e97:	50                   	push   %eax                           
  110e98:	ff 75 08             	pushl  0x8(%ebp)                      
  110e9b:	68 38 4a 13 00       	push   $0x134a38                      
  110ea0:	e8 53 41 00 00       	call   114ff8 <_Objects_Get>          
  110ea5:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
  110ea7:	83 c4 10             	add    $0x10,%esp                     
  110eaa:	b8 04 00 00 00       	mov    $0x4,%eax                      
  110eaf:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  110eb3:	75 18                	jne    110ecd <rtems_message_queue_flush+0x4d>
                                                                      
    case OBJECTS_LOCAL:                                               
      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
  110eb5:	83 ec 0c             	sub    $0xc,%esp                      
  110eb8:	8d 42 14             	lea    0x14(%edx),%eax                
  110ebb:	50                   	push   %eax                           
  110ebc:	e8 e7 2c 00 00       	call   113ba8 <_CORE_message_queue_Flush>
  110ec1:	89 03                	mov    %eax,(%ebx)                    
      _Thread_Enable_dispatch();                                      
  110ec3:	e8 f0 48 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110ec8:	31 c0                	xor    %eax,%eax                      
  110eca:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  110ecd:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  110ed0:	c9                   	leave                                 
  110ed1:	c3                   	ret                                   
                                                                      

00110ed4 <rtems_message_queue_get_number_pending>: rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) {
  110ed4:	55                   	push   %ebp                           
  110ed5:	89 e5                	mov    %esp,%ebp                      
  110ed7:	53                   	push   %ebx                           
  110ed8:	83 ec 14             	sub    $0x14,%esp                     
  110edb:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
  110ede:	b8 09 00 00 00       	mov    $0x9,%eax                      
  110ee3:	85 db                	test   %ebx,%ebx                      
  110ee5:	74 2e                	je     110f15 <rtems_message_queue_get_number_pending+0x41><== NEVER TAKEN
  110ee7:	50                   	push   %eax                           
  110ee8:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  110eeb:	50                   	push   %eax                           
  110eec:	ff 75 08             	pushl  0x8(%ebp)                      
  110eef:	68 38 4a 13 00       	push   $0x134a38                      
  110ef4:	e8 ff 40 00 00       	call   114ff8 <_Objects_Get>          
  110ef9:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
  110efb:	83 c4 10             	add    $0x10,%esp                     
  110efe:	b8 04 00 00 00       	mov    $0x4,%eax                      
  110f03:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  110f07:	75 0c                	jne    110f15 <rtems_message_queue_get_number_pending+0x41>
                                                                      
    case OBJECTS_LOCAL:                                               
      *count = the_message_queue->message_queue.number_of_pending_messages;
  110f09:	8b 42 5c             	mov    0x5c(%edx),%eax                
  110f0c:	89 03                	mov    %eax,(%ebx)                    
      _Thread_Enable_dispatch();                                      
  110f0e:	e8 a5 48 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110f13:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  110f15:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  110f18:	c9                   	leave                                 
  110f19:	c3                   	ret                                   
                                                                      

00108ec0 <rtems_message_queue_send>: rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) {
  108ec0:	55                   	push   %ebp                           
  108ec1:	89 e5                	mov    %esp,%ebp                      
  108ec3:	56                   	push   %esi                           
  108ec4:	53                   	push   %ebx                           
  108ec5:	83 ec 10             	sub    $0x10,%esp                     
  108ec8:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  108ecb:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
  108ece:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108ed3:	85 f6                	test   %esi,%esi                      
  108ed5:	74 4f                	je     108f26 <rtems_message_queue_send+0x66><== NEVER TAKEN
 *  @param[in] size is the size in bytes of the memory area to add    
 *  @return a status indicating success or the reason for failure     
 */                                                                   
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  108ed7:	50                   	push   %eax                           
  108ed8:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  108edb:	50                   	push   %eax                           
  108edc:	53                   	push   %ebx                           
  108edd:	68 90 e0 11 00       	push   $0x11e090                      
  108ee2:	e8 e5 17 00 00       	call   10a6cc <_Objects_Get>          
  108ee7:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
  108ee9:	83 c4 10             	add    $0x10,%esp                     
  108eec:	b8 04 00 00 00       	mov    $0x4,%eax                      
  108ef1:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  108ef5:	75 2f                	jne    108f26 <rtems_message_queue_send+0x66><== NEVER TAKEN
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory for
 *         the heap                                                   
  108ef7:	6a 00                	push   $0x0                           
  108ef9:	6a 00                	push   $0x0                           
  108efb:	68 ff ff ff 7f       	push   $0x7fffffff                    
  108f00:	6a 00                	push   $0x0                           
  108f02:	53                   	push   %ebx                           
  108f03:	ff 75 10             	pushl  0x10(%ebp)                     
  108f06:	56                   	push   %esi                           
  108f07:	8d 42 14             	lea    0x14(%edx),%eax                
  108f0a:	50                   	push   %eax                           
  108f0b:	e8 28 0c 00 00       	call   109b38 <_CORE_message_queue_Submit>
  108f10:	89 c3                	mov    %eax,%ebx                      
        MESSAGE_QUEUE_MP_HANDLER,                                     
        FALSE,   /* sender does not block */                          
        0        /* no timeout */                                     
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
  108f12:	83 c4 20             	add    $0x20,%esp                     
  108f15:	e8 72 1f 00 00       	call   10ae8c <_Thread_Enable_dispatch>
      /*                                                              
       *  Since this API does not allow for blocking sends, we can directly
       *  return the returned status.                                 
       */                                                             
                                                                      
      return _Message_queue_Translate_core_message_queue_return_code(status);
  108f1a:	83 ec 0c             	sub    $0xc,%esp                      
  108f1d:	53                   	push   %ebx                           
  108f1e:	e8 0d 00 00 00       	call   108f30 <_Message_queue_Translate_core_message_queue_return_code>
  108f23:	83 c4 10             	add    $0x10,%esp                     
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
  108f26:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108f29:	5b                   	pop    %ebx                           
  108f2a:	5e                   	pop    %esi                           
  108f2b:	c9                   	leave                                 
  108f2c:	c3                   	ret                                   
                                                                      

00111040 <rtems_message_queue_urgent>: rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) {
  111040:	55                   	push   %ebp                           
  111041:	89 e5                	mov    %esp,%ebp                      
  111043:	56                   	push   %esi                           
  111044:	53                   	push   %ebx                           
  111045:	83 ec 10             	sub    $0x10,%esp                     
  111048:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  11104b:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
  11104e:	b8 09 00 00 00       	mov    $0x9,%eax                      
  111053:	85 f6                	test   %esi,%esi                      
  111055:	74 4f                	je     1110a6 <rtems_message_queue_urgent+0x66><== NEVER TAKEN
 *  @param[in] size is the size in bytes of the memory area to add    
 *  @return a status indicating success or the reason for failure     
 */                                                                   
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  111057:	50                   	push   %eax                           
  111058:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  11105b:	50                   	push   %eax                           
  11105c:	53                   	push   %ebx                           
  11105d:	68 38 4a 13 00       	push   $0x134a38                      
  111062:	e8 91 3f 00 00       	call   114ff8 <_Objects_Get>          
  111067:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
  111069:	83 c4 10             	add    $0x10,%esp                     
  11106c:	b8 04 00 00 00       	mov    $0x4,%eax                      
  111071:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  111075:	75 2f                	jne    1110a6 <rtems_message_queue_urgent+0x66>
  size_t        size                                                  
  111077:	6a 00                	push   $0x0                           
  111079:	6a 00                	push   $0x0                           
  11107b:	68 00 00 00 80       	push   $0x80000000                    
  111080:	6a 00                	push   $0x0                           
  111082:	53                   	push   %ebx                           
  111083:	ff 75 10             	pushl  0x10(%ebp)                     
  111086:	56                   	push   %esi                           
  111087:	8d 42 14             	lea    0x14(%edx),%eax                
  11108a:	50                   	push   %eax                           
  11108b:	e8 6c 2d 00 00       	call   113dfc <_CORE_message_queue_Submit>
  111090:	89 c3                	mov    %eax,%ebx                      
        id,                                                           
        MESSAGE_QUEUE_MP_HANDLER,                                     
        FALSE,   /* sender does not block */                          
        0        /* no timeout */                                     
      );                                                              
      _Thread_Enable_dispatch();                                      
  111092:	83 c4 20             	add    $0x20,%esp                     
  111095:	e8 1e 47 00 00       	call   1157b8 <_Thread_Enable_dispatch>
      /*                                                              
       *  Since this API does not allow for blocking sends, we can directly
       *  return the returned status.                                 
       */                                                             
                                                                      
      return _Message_queue_Translate_core_message_queue_return_code(status);
  11109a:	83 ec 0c             	sub    $0xc,%esp                      
  11109d:	53                   	push   %ebx                           
  11109e:	e8 8d ff ff ff       	call   111030 <_Message_queue_Translate_core_message_queue_return_code>
  1110a3:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  1110a6:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1110a9:	5b                   	pop    %ebx                           
  1110aa:	5e                   	pop    %esi                           
  1110ab:	c9                   	leave                                 
  1110ac:	c3                   	ret                                   
                                                                      

00109448 <rtems_object_set_name>: */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) {
  109448:	55                   	push   %ebp                           
  109449:	89 e5                	mov    %esp,%ebp                      
  10944b:	57                   	push   %edi                           
  10944c:	56                   	push   %esi                           
  10944d:	53                   	push   %ebx                           
  10944e:	83 ec 1c             	sub    $0x1c,%esp                     
  109451:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  Objects_Information *information;                                   
  Objects_Locations    location;                                      
  Objects_Control     *the_object;                                    
  Objects_Id           tmpId;                                         
                                                                      
  if ( !name )                                                        
  109454:	b8 09 00 00 00       	mov    $0x9,%eax                      
  109459:	85 ff                	test   %edi,%edi                      
  10945b:	74 50                	je     1094ad <rtems_object_set_name+0x65><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
  10945d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  109460:	85 db                	test   %ebx,%ebx                      
  109462:	75 08                	jne    10946c <rtems_object_set_name+0x24>
  109464:	a1 4c 0d 12 00       	mov    0x120d4c,%eax                  
  109469:	8b 58 08             	mov    0x8(%eax),%ebx                 
                                                                      
  information  = _Objects_Get_information_id( tmpId );                
  10946c:	83 ec 0c             	sub    $0xc,%esp                      
  10946f:	53                   	push   %ebx                           
  109470:	e8 b3 16 00 00       	call   10ab28 <_Objects_Get_information_id>
  109475:	89 c6                	mov    %eax,%esi                      
  if ( !information )                                                 
  109477:	83 c4 10             	add    $0x10,%esp                     
  10947a:	85 c0                	test   %eax,%eax                      
  10947c:	74 2a                	je     1094a8 <rtems_object_set_name+0x60>
    return RTEMS_INVALID_ID;                                          
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
  10947e:	51                   	push   %ecx                           
  10947f:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  109482:	50                   	push   %eax                           
  109483:	53                   	push   %ebx                           
  109484:	56                   	push   %esi                           
  109485:	e8 36 18 00 00       	call   10acc0 <_Objects_Get>          
  switch ( location ) {                                               
  10948a:	83 c4 10             	add    $0x10,%esp                     
  10948d:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  109491:	75 15                	jne    1094a8 <rtems_object_set_name+0x60>
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Set_name( information, the_object, name );             
  109493:	52                   	push   %edx                           
  109494:	57                   	push   %edi                           
  109495:	50                   	push   %eax                           
  109496:	56                   	push   %esi                           
  109497:	e8 e0 19 00 00       	call   10ae7c <_Objects_Set_name>     
      _Thread_Enable_dispatch();                                      
  10949c:	e8 bf 20 00 00       	call   10b560 <_Thread_Enable_dispatch>
  1094a1:	31 c0                	xor    %eax,%eax                      
  1094a3:	83 c4 10             	add    $0x10,%esp                     
  1094a6:	eb 05                	jmp    1094ad <rtems_object_set_name+0x65>
      return RTEMS_SUCCESSFUL;                                        
  1094a8:	b8 04 00 00 00       	mov    $0x4,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  1094ad:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1094b0:	5b                   	pop    %ebx                           
  1094b1:	5e                   	pop    %esi                           
  1094b2:	5f                   	pop    %edi                           
  1094b3:	c9                   	leave                                 
  1094b4:	c3                   	ret                                   
                                                                      

00107028 <rtems_panic>: void rtems_panic( const char *printf_format, ... ) {
  107028:	55                   	push   %ebp                           <== NOT EXECUTED
  107029:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10702b:	83 ec 08             	sub    $0x8,%esp                      <== NOT EXECUTED
  10702e:	8d 4d 0c             	lea    0xc(%ebp),%ecx                 <== NOT EXECUTED
    va_list arglist;                                                  
                                                                      
    va_start(arglist, printf_format);                                 
    (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);   
  107031:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  107034:	b8 00 00 00 20       	mov    $0x20000000,%eax               <== NOT EXECUTED
  107039:	e8 83 fe ff ff       	call   106ec1 <rtems_verror>          <== NOT EXECUTED
    va_end(arglist);                                                  
}                                                                     
  10703e:	c9                   	leave                                 <== NOT EXECUTED
  10703f:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001110b0 <rtems_partition_create>: uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) {
  1110b0:	55                   	push   %ebp                           
  1110b1:	89 e5                	mov    %esp,%ebp                      
  1110b3:	57                   	push   %edi                           
  1110b4:	56                   	push   %esi                           
  1110b5:	53                   	push   %ebx                           
  1110b6:	83 ec 0c             	sub    $0xc,%esp                      
  1110b9:	8b 7d 10             	mov    0x10(%ebp),%edi                
  1110bc:	8b 75 14             	mov    0x14(%ebp),%esi                
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  1110bf:	b8 03 00 00 00       	mov    $0x3,%eax                      
  1110c4:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  1110c8:	0f 84 c9 00 00 00    	je     111197 <rtems_partition_create+0xe7>
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
  1110ce:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  1110d2:	0f 84 b3 00 00 00    	je     11118b <rtems_partition_create+0xdb><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
  1110d8:	83 7d 1c 00          	cmpl   $0x0,0x1c(%ebp)                
  1110dc:	0f 84 a9 00 00 00    	je     11118b <rtems_partition_create+0xdb><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
  1110e2:	85 ff                	test   %edi,%edi                      
  1110e4:	0f 84 a8 00 00 00    	je     111192 <rtems_partition_create+0xe2>
  1110ea:	85 f6                	test   %esi,%esi                      
  1110ec:	0f 84 a0 00 00 00    	je     111192 <rtems_partition_create+0xe2>
  1110f2:	39 f7                	cmp    %esi,%edi                      
  1110f4:	0f 82 98 00 00 00    	jb     111192 <rtems_partition_create+0xe2>
  1110fa:	f7 c6 03 00 00 00    	test   $0x3,%esi                      
  111100:	0f 85 8c 00 00 00    	jne    111192 <rtems_partition_create+0xe2>
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
  111106:	f6 45 0c 03          	testb  $0x3,0xc(%ebp)                 
  11110a:	75 7f                	jne    11118b <rtems_partition_create+0xdb>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  11110c:	a1 38 41 13 00       	mov    0x134138,%eax                  
  111111:	40                   	inc    %eax                           
  111112:	a3 38 41 13 00       	mov    %eax,0x134138                  
 *  Returns TRUE if the @a starting_address is in the heap, and FALSE 
 *  otherwise.                                                        
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the user block
 *         to obtain the size of                                      
  111117:	83 ec 0c             	sub    $0xc,%esp                      
  11111a:	68 6c 3f 13 00       	push   $0x133f6c                      
  11111f:	e8 54 3a 00 00       	call   114b78 <_Objects_Allocate>     
  111124:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
  111126:	83 c4 10             	add    $0x10,%esp                     
  111129:	85 c0                	test   %eax,%eax                      
  11112b:	75 0c                	jne    111139 <rtems_partition_create+0x89>
    _Thread_Enable_dispatch();                                        
  11112d:	e8 86 46 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  111132:	b8 05 00 00 00       	mov    $0x5,%eax                      
  111137:	eb 5e                	jmp    111197 <rtems_partition_create+0xe7>
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
  111139:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  11113c:	89 43 10             	mov    %eax,0x10(%ebx)                
  the_partition->length                = length;                      
  11113f:	89 7b 14             	mov    %edi,0x14(%ebx)                
  the_partition->buffer_size           = buffer_size;                 
  111142:	89 73 18             	mov    %esi,0x18(%ebx)                
  the_partition->attribute_set         = attribute_set;               
  111145:	8b 45 18             	mov    0x18(%ebp),%eax                
  111148:	89 43 1c             	mov    %eax,0x1c(%ebx)                
  the_partition->number_of_used_blocks = 0;                           
  11114b:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)                
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
  111152:	56                   	push   %esi                           
  111153:	89 f8                	mov    %edi,%eax                      
  111155:	31 d2                	xor    %edx,%edx                      
  111157:	f7 f6                	div    %esi                           
  111159:	50                   	push   %eax                           
  11115a:	ff 75 0c             	pushl  0xc(%ebp)                      
  11115d:	8d 43 24             	lea    0x24(%ebx),%eax                
  111160:	50                   	push   %eax                           
  111161:	e8 6a 29 00 00       	call   113ad0 <_Chain_Initialize>     
  111166:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  111169:	0f b7 d1             	movzwl %cx,%edx                       
  11116c:	a1 88 3f 13 00       	mov    0x133f88,%eax                  
  111171:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  111174:	8b 45 08             	mov    0x8(%ebp),%eax                 
  111177:	89 43 0c             	mov    %eax,0xc(%ebx)                 
    &_Partition_Information,                                          
    &the_partition->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_partition->Object.id;                                     
  11117a:	8b 45 1c             	mov    0x1c(%ebp),%eax                
  11117d:	89 08                	mov    %ecx,(%eax)                    
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  11117f:	e8 34 46 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  111184:	31 c0                	xor    %eax,%eax                      
  111186:	83 c4 10             	add    $0x10,%esp                     
  111189:	eb 0c                	jmp    111197 <rtems_partition_create+0xe7>
  return RTEMS_SUCCESSFUL;                                            
  11118b:	b8 09 00 00 00       	mov    $0x9,%eax                      
  111190:	eb 05                	jmp    111197 <rtems_partition_create+0xe7>
  111192:	b8 08 00 00 00       	mov    $0x8,%eax                      
}                                                                     
  111197:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  11119a:	5b                   	pop    %ebx                           
  11119b:	5e                   	pop    %esi                           
  11119c:	5f                   	pop    %edi                           
  11119d:	c9                   	leave                                 
  11119e:	c3                   	ret                                   
                                                                      

00111204 <rtems_partition_get_buffer>: rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) {
  111204:	55                   	push   %ebp                           
  111205:	89 e5                	mov    %esp,%ebp                      
  111207:	57                   	push   %edi                           
  111208:	56                   	push   %esi                           
  111209:	53                   	push   %ebx                           
  11120a:	83 ec 1c             	sub    $0x1c,%esp                     
  11120d:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
  void                       *the_buffer;                             
                                                                      
  if ( !buffer )                                                      
  111210:	b8 09 00 00 00       	mov    $0x9,%eax                      
  111215:	85 ff                	test   %edi,%edi                      
  111217:	74 4f                	je     111268 <rtems_partition_get_buffer+0x64><== NEVER TAKEN
);                                                                    
                                                                      
/**                                                                   
 *  This routine returns the block of memory which begins             
 *  at @a starting_address to @a the_heap.  Any coalescing which is   
 *  possible with the freeing of this routine is performed.           
  111219:	50                   	push   %eax                           
  11121a:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  11121d:	50                   	push   %eax                           
  11121e:	ff 75 08             	pushl  0x8(%ebp)                      
  111221:	68 6c 3f 13 00       	push   $0x133f6c                      
  111226:	e8 cd 3d 00 00       	call   114ff8 <_Objects_Get>          
  11122b:	89 c3                	mov    %eax,%ebx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
  11122d:	83 c4 10             	add    $0x10,%esp                     
  111230:	b8 04 00 00 00       	mov    $0x4,%eax                      
  111235:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  111239:	75 2d                	jne    111268 <rtems_partition_get_buffer+0x64>
#endif                                                                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
  11123b:	83 ec 0c             	sub    $0xc,%esp                      
  11123e:	8d 43 24             	lea    0x24(%ebx),%eax                
  111241:	50                   	push   %eax                           
  111242:	e8 61 28 00 00       	call   113aa8 <_Chain_Get>            
  111247:	89 c6                	mov    %eax,%esi                      
                                                                      
    case OBJECTS_LOCAL:                                               
      the_buffer = _Partition_Allocate_buffer( the_partition );       
      if ( the_buffer ) {                                             
  111249:	83 c4 10             	add    $0x10,%esp                     
  11124c:	85 c0                	test   %eax,%eax                      
  11124e:	74 0e                	je     11125e <rtems_partition_get_buffer+0x5a>
        the_partition->number_of_used_blocks += 1;                    
  111250:	ff 43 20             	incl   0x20(%ebx)                     
        _Thread_Enable_dispatch();                                    
  111253:	e8 60 45 00 00       	call   1157b8 <_Thread_Enable_dispatch>
        *buffer = the_buffer;                                         
  111258:	89 37                	mov    %esi,(%edi)                    
  11125a:	31 c0                	xor    %eax,%eax                      
  11125c:	eb 0a                	jmp    111268 <rtems_partition_get_buffer+0x64>
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
  11125e:	e8 55 45 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  111263:	b8 0d 00 00 00       	mov    $0xd,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  111268:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  11126b:	5b                   	pop    %ebx                           
  11126c:	5e                   	pop    %esi                           
  11126d:	5f                   	pop    %edi                           
  11126e:	c9                   	leave                                 
  11126f:	c3                   	ret                                   
                                                                      

001107e4 <rtems_port_create>: void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) {
  1107e4:	55                   	push   %ebp                           
  1107e5:	89 e5                	mov    %esp,%ebp                      
  1107e7:	57                   	push   %edi                           
  1107e8:	56                   	push   %esi                           
  1107e9:	53                   	push   %ebx                           
  1107ea:	83 ec 0c             	sub    $0xc,%esp                      
  1107ed:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  1107f0:	8b 7d 10             	mov    0x10(%ebp),%edi                
  register Dual_ported_memory_Control *the_port;                      
                                                                      
  if ( !rtems_is_name_valid( name) )                                  
  1107f3:	b8 03 00 00 00       	mov    $0x3,%eax                      
  1107f8:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  1107fc:	74 6f                	je     11086d <rtems_port_create+0x89>
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
  1107fe:	83 7d 18 00          	cmpl   $0x0,0x18(%ebp)                
  110802:	74 64                	je     110868 <rtems_port_create+0x84><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_Addresses_Is_aligned( internal_start ) ||                    
  110804:	89 f8                	mov    %edi,%eax                      
  110806:	09 f0                	or     %esi,%eax                      
  110808:	a8 03                	test   $0x3,%al                       
  11080a:	75 5c                	jne    110868 <rtems_port_create+0x84>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  11080c:	a1 38 41 13 00       	mov    0x134138,%eax                  
  110811:	40                   	inc    %eax                           
  110812:	a3 38 41 13 00       	mov    %eax,0x134138                  
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
  110817:	83 ec 0c             	sub    $0xc,%esp                      
  11081a:	68 2c 3f 13 00       	push   $0x133f2c                      
  11081f:	e8 54 43 00 00       	call   114b78 <_Objects_Allocate>     
  110824:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();             /* to prevent deletion */   
                                                                      
  the_port = _Dual_ported_memory_Allocate();                          
                                                                      
  if ( !the_port ) {                                                  
  110826:	83 c4 10             	add    $0x10,%esp                     
  110829:	85 c0                	test   %eax,%eax                      
  11082b:	75 0c                	jne    110839 <rtems_port_create+0x55>
    _Thread_Enable_dispatch();                                        
  11082d:	e8 86 4f 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110832:	b8 05 00 00 00       	mov    $0x5,%eax                      
  110837:	eb 34                	jmp    11086d <rtems_port_create+0x89>
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_port->internal_base = internal_start;                           
  110839:	89 70 10             	mov    %esi,0x10(%eax)                
  the_port->external_base = external_start;                           
  11083c:	89 78 14             	mov    %edi,0x14(%eax)                
  the_port->length        = length - 1;                               
  11083f:	8b 45 14             	mov    0x14(%ebp),%eax                
  110842:	48                   	dec    %eax                           
  110843:	89 43 18             	mov    %eax,0x18(%ebx)                
  110846:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  110849:	0f b7 d1             	movzwl %cx,%edx                       
  11084c:	a1 48 3f 13 00       	mov    0x133f48,%eax                  
  110851:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  110854:	8b 45 08             	mov    0x8(%ebp),%eax                 
  110857:	89 43 0c             	mov    %eax,0xc(%ebx)                 
    &_Dual_ported_memory_Information,                                 
    &the_port->Object,                                                
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_port->Object.id;                                          
  11085a:	8b 45 18             	mov    0x18(%ebp),%eax                
  11085d:	89 08                	mov    %ecx,(%eax)                    
  _Thread_Enable_dispatch();                                          
  11085f:	e8 54 4f 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  110864:	31 c0                	xor    %eax,%eax                      
  110866:	eb 05                	jmp    11086d <rtems_port_create+0x89>
  return RTEMS_SUCCESSFUL;                                            
  110868:	b8 09 00 00 00       	mov    $0x9,%eax                      
}                                                                     
  11086d:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  110870:	5b                   	pop    %ebx                           
  110871:	5e                   	pop    %esi                           
  110872:	5f                   	pop    %edi                           
  110873:	c9                   	leave                                 
  110874:	c3                   	ret                                   
                                                                      

001108cc <rtems_port_external_to_internal>: rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) {
  1108cc:	55                   	push   %ebp                           
  1108cd:	89 e5                	mov    %esp,%ebp                      
  1108cf:	56                   	push   %esi                           
  1108d0:	53                   	push   %ebx                           
  1108d1:	83 ec 10             	sub    $0x10,%esp                     
  1108d4:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  1108d7:	8b 5d 10             	mov    0x10(%ebp),%ebx                
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !internal )                                                    
  1108da:	b8 09 00 00 00       	mov    $0x9,%eax                      
  1108df:	85 db                	test   %ebx,%ebx                      
  1108e1:	74 3c                	je     11091f <rtems_port_external_to_internal+0x53><== NEVER TAKEN
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory 
 *         to add to the heap                                         
 *  @param[in] size is the size in bytes of the memory area to add    
  1108e3:	50                   	push   %eax                           
  1108e4:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  1108e7:	50                   	push   %eax                           
  1108e8:	ff 75 08             	pushl  0x8(%ebp)                      
  1108eb:	68 2c 3f 13 00       	push   $0x133f2c                      
  1108f0:	e8 03 47 00 00       	call   114ff8 <_Objects_Get>          
  1108f5:	89 c1                	mov    %eax,%ecx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
  1108f7:	83 c4 10             	add    $0x10,%esp                     
  1108fa:	b8 04 00 00 00       	mov    $0x4,%eax                      
  1108ff:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  110903:	75 1a                	jne    11091f <rtems_port_external_to_internal+0x53>
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
  110905:	89 f2                	mov    %esi,%edx                      
  110907:	2b 51 14             	sub    0x14(%ecx),%edx                
    case OBJECTS_LOCAL:                                               
      ending = _Addresses_Subtract( external, the_port->external_base );
      if ( ending > the_port->length )                                
  11090a:	3b 51 18             	cmp    0x18(%ecx),%edx                
  11090d:	76 04                	jbe    110913 <rtems_port_external_to_internal+0x47>
        *internal = external;                                         
  11090f:	89 33                	mov    %esi,(%ebx)                    
  110911:	eb 05                	jmp    110918 <rtems_port_external_to_internal+0x4c>
      else                                                            
        *internal = _Addresses_Add_offset( the_port->internal_base,   
  110913:	03 51 10             	add    0x10(%ecx),%edx                
  110916:	89 13                	mov    %edx,(%ebx)                    
                                           ending );                  
      _Thread_Enable_dispatch();                                      
  110918:	e8 9b 4e 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  11091d:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  11091f:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  110922:	5b                   	pop    %ebx                           
  110923:	5e                   	pop    %esi                           
  110924:	c9                   	leave                                 
  110925:	c3                   	ret                                   
                                                                      

0011094c <rtems_port_internal_to_external>: rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) {
  11094c:	55                   	push   %ebp                           
  11094d:	89 e5                	mov    %esp,%ebp                      
  11094f:	56                   	push   %esi                           
  110950:	53                   	push   %ebx                           
  110951:	83 ec 10             	sub    $0x10,%esp                     
  110954:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  110957:	8b 5d 10             	mov    0x10(%ebp),%ebx                
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !external )                                                    
  11095a:	b8 09 00 00 00       	mov    $0x9,%eax                      
  11095f:	85 db                	test   %ebx,%ebx                      
  110961:	74 3c                	je     11099f <rtems_port_internal_to_external+0x53><== NEVER TAKEN
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory 
 *         to add to the heap                                         
 *  @param[in] size is the size in bytes of the memory area to add    
  110963:	50                   	push   %eax                           
  110964:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  110967:	50                   	push   %eax                           
  110968:	ff 75 08             	pushl  0x8(%ebp)                      
  11096b:	68 2c 3f 13 00       	push   $0x133f2c                      
  110970:	e8 83 46 00 00       	call   114ff8 <_Objects_Get>          
  110975:	89 c1                	mov    %eax,%ecx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
  110977:	83 c4 10             	add    $0x10,%esp                     
  11097a:	b8 04 00 00 00       	mov    $0x4,%eax                      
  11097f:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  110983:	75 1a                	jne    11099f <rtems_port_internal_to_external+0x53>
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
  110985:	89 f2                	mov    %esi,%edx                      
  110987:	2b 51 10             	sub    0x10(%ecx),%edx                
                                                                      
    case OBJECTS_LOCAL:                                               
      ending = _Addresses_Subtract( internal, the_port->internal_base );
      if ( ending > the_port->length )                                
  11098a:	3b 51 18             	cmp    0x18(%ecx),%edx                
  11098d:	76 04                	jbe    110993 <rtems_port_internal_to_external+0x47>
        *external = internal;                                         
  11098f:	89 33                	mov    %esi,(%ebx)                    
  110991:	eb 05                	jmp    110998 <rtems_port_internal_to_external+0x4c>
      else                                                            
        *external = _Addresses_Add_offset( the_port->external_base,   
  110993:	03 51 14             	add    0x14(%ecx),%edx                
  110996:	89 13                	mov    %edx,(%ebx)                    
                                           ending );                  
      _Thread_Enable_dispatch();                                      
  110998:	e8 1b 4e 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  11099d:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  11099f:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1109a2:	5b                   	pop    %ebx                           
  1109a3:	5e                   	pop    %esi                           
  1109a4:	c9                   	leave                                 
  1109a5:	c3                   	ret                                   
                                                                      

00109ce4 <rtems_rate_monotonic_create>: rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) {
  109ce4:	55                   	push   %ebp                           
  109ce5:	89 e5                	mov    %esp,%ebp                      
  109ce7:	57                   	push   %edi                           
  109ce8:	56                   	push   %esi                           
  109ce9:	53                   	push   %ebx                           
  109cea:	83 ec 0c             	sub    $0xc,%esp                      
  109ced:	8b 75 08             	mov    0x8(%ebp),%esi                 
  Rate_monotonic_Control *the_period;                                 
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  109cf0:	b8 03 00 00 00       	mov    $0x3,%eax                      
  109cf5:	85 f6                	test   %esi,%esi                      
  109cf7:	0f 84 ac 00 00 00    	je     109da9 <rtems_rate_monotonic_create+0xc5>
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
  109cfd:	b8 09 00 00 00       	mov    $0x9,%eax                      
  109d02:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  109d06:	0f 84 9d 00 00 00    	je     109da9 <rtems_rate_monotonic_create+0xc5><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109d0c:	a1 3c 1c 12 00       	mov    0x121c3c,%eax                  
  109d11:	40                   	inc    %eax                           
  109d12:	a3 3c 1c 12 00       	mov    %eax,0x121c3c                  
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
  109d17:	83 ec 0c             	sub    $0xc,%esp                      
  109d1a:	68 44 1b 12 00       	push   $0x121b44                      
  109d1f:	e8 84 1b 00 00       	call   10b8a8 <_Objects_Allocate>     
  109d24:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();            /* to prevent deletion */    
                                                                      
  the_period = _Rate_monotonic_Allocate();                            
                                                                      
  if ( !the_period ) {                                                
  109d26:	83 c4 10             	add    $0x10,%esp                     
  109d29:	85 c0                	test   %eax,%eax                      
  109d2b:	75 0c                	jne    109d39 <rtems_rate_monotonic_create+0x55>
    _Thread_Enable_dispatch();                                        
  109d2d:	e8 52 28 00 00       	call   10c584 <_Thread_Enable_dispatch>
  109d32:	b8 05 00 00 00       	mov    $0x5,%eax                      
  109d37:	eb 70                	jmp    109da9 <rtems_rate_monotonic_create+0xc5>
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_period->owner = _Thread_Executing;                              
  109d39:	a1 fc 1c 12 00       	mov    0x121cfc,%eax                  
  109d3e:	89 43 50             	mov    %eax,0x50(%ebx)                
  the_period->state = RATE_MONOTONIC_INACTIVE;                        
  109d41:	c7 43 38 00 00 00 00 	movl   $0x0,0x38(%ebx)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  109d48:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  109d4f:	c7 43 2c 00 00 00 00 	movl   $0x0,0x2c(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  109d56:	c7 43 30 00 00 00 00 	movl   $0x0,0x30(%ebx)                
 *         the heap                                                   
  109d5d:	c7 43 34 00 00 00 00 	movl   $0x0,0x34(%ebx)                
                                                                      
  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );          
                                                                      
  _Rate_monotonic_Reset_statistics( the_period );                     
  109d64:	8d 7b 54             	lea    0x54(%ebx),%edi                
  109d67:	b9 0e 00 00 00       	mov    $0xe,%ecx                      
  109d6c:	31 c0                	xor    %eax,%eax                      
  109d6e:	f3 ab                	rep stos %eax,%es:(%edi)              
  109d70:	c7 43 5c ff ff ff 7f 	movl   $0x7fffffff,0x5c(%ebx)         
  109d77:	c7 43 60 ff ff ff 7f 	movl   $0x7fffffff,0x60(%ebx)         
  109d7e:	c7 43 74 ff ff ff 7f 	movl   $0x7fffffff,0x74(%ebx)         
  109d85:	c7 43 78 ff ff ff 7f 	movl   $0x7fffffff,0x78(%ebx)         
  109d8c:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  109d8f:	0f b7 d1             	movzwl %cx,%edx                       
  109d92:	a1 60 1b 12 00       	mov    0x121b60,%eax                  
  109d97:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  109d9a:	89 73 0c             	mov    %esi,0xc(%ebx)                 
    &_Rate_monotonic_Information,                                     
    &the_period->Object,                                              
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_period->Object.id;                                        
  109d9d:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  109da0:	89 08                	mov    %ecx,(%eax)                    
  _Thread_Enable_dispatch();                                          
  109da2:	e8 dd 27 00 00       	call   10c584 <_Thread_Enable_dispatch>
  109da7:	31 c0                	xor    %eax,%eax                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  109da9:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109dac:	5b                   	pop    %ebx                           
  109dad:	5e                   	pop    %esi                           
  109dae:	5f                   	pop    %edi                           
  109daf:	c9                   	leave                                 
  109db0:	c3                   	ret                                   
                                                                      

0010f338 <rtems_rate_monotonic_get_statistics>: rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) {
  10f338:	55                   	push   %ebp                           
  10f339:	89 e5                	mov    %esp,%ebp                      
  10f33b:	57                   	push   %edi                           
  10f33c:	56                   	push   %esi                           
  10f33d:	83 ec 20             	sub    $0x20,%esp                     
  10f340:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  Objects_Locations              location;                            
  Rate_monotonic_Control        *the_period;                          
                                                                      
  if ( !statistics )                                                  
  10f343:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10f348:	85 ff                	test   %edi,%edi                      
  10f34a:	74 33                	je     10f37f <rtems_rate_monotonic_get_statistics+0x47><== NEVER TAKEN
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory 
  10f34c:	50                   	push   %eax                           
  10f34d:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10f350:	50                   	push   %eax                           
  10f351:	ff 75 08             	pushl  0x8(%ebp)                      
  10f354:	68 44 1b 12 00       	push   $0x121b44                      
  10f359:	e8 66 ca ff ff       	call   10bdc4 <_Objects_Get>          
  10f35e:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
  10f360:	83 c4 10             	add    $0x10,%esp                     
  10f363:	b8 04 00 00 00       	mov    $0x4,%eax                      
  10f368:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10f36c:	75 11                	jne    10f37f <rtems_rate_monotonic_get_statistics+0x47>
                                                                      
    case OBJECTS_LOCAL:                                               
      *statistics = the_period->Statistics;                           
  10f36e:	8d 72 54             	lea    0x54(%edx),%esi                
  10f371:	b9 0e 00 00 00       	mov    $0xe,%ecx                      
  10f376:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
      _Thread_Enable_dispatch();                                      
  10f378:	e8 07 d2 ff ff       	call   10c584 <_Thread_Enable_dispatch>
  10f37d:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10f37f:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10f382:	5e                   	pop    %esi                           
  10f383:	5f                   	pop    %edi                           
  10f384:	c9                   	leave                                 
  10f385:	c3                   	ret                                   
                                                                      

0010f388 <rtems_rate_monotonic_get_status>: rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) {
  10f388:	55                   	push   %ebp                           
  10f389:	89 e5                	mov    %esp,%ebp                      
  10f38b:	57                   	push   %edi                           
  10f38c:	56                   	push   %esi                           
  10f38d:	53                   	push   %ebx                           
  10f38e:	83 ec 1c             	sub    $0x1c,%esp                     
  10f391:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Objects_Locations              location;                            
  Rate_monotonic_Control        *the_period;                          
                                                                      
  if ( !status )                                                      
  10f394:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10f399:	85 f6                	test   %esi,%esi                      
  10f39b:	0f 84 91 00 00 00    	je     10f432 <rtems_rate_monotonic_get_status+0xaa><== NEVER TAKEN
  10f3a1:	50                   	push   %eax                           
  10f3a2:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10f3a5:	50                   	push   %eax                           
  10f3a6:	ff 75 08             	pushl  0x8(%ebp)                      
  10f3a9:	68 44 1b 12 00       	push   $0x121b44                      
  10f3ae:	e8 11 ca ff ff       	call   10bdc4 <_Objects_Get>          
  10f3b3:	89 c7                	mov    %eax,%edi                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
  10f3b5:	83 c4 10             	add    $0x10,%esp                     
  10f3b8:	b8 04 00 00 00       	mov    $0x4,%eax                      
  10f3bd:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10f3c1:	75 6f                	jne    10f432 <rtems_rate_monotonic_get_status+0xaa>
                                                                      
    case OBJECTS_LOCAL:                                               
      status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
  10f3c3:	8b 47 50             	mov    0x50(%edi),%eax                
  10f3c6:	31 d2                	xor    %edx,%edx                      
  10f3c8:	85 c0                	test   %eax,%eax                      
  10f3ca:	74 03                	je     10f3cf <rtems_rate_monotonic_get_status+0x47><== NEVER TAKEN
  10f3cc:	8b 50 08             	mov    0x8(%eax),%edx                 
  10f3cf:	89 16                	mov    %edx,(%esi)                    
      status->state = the_period->state;                              
  10f3d1:	8b 47 38             	mov    0x38(%edi),%eax                
  10f3d4:	89 46 04             	mov    %eax,0x4(%esi)                 
                                                                      
      if ( status->state == RATE_MONOTONIC_INACTIVE ) {               
  10f3d7:	85 c0                	test   %eax,%eax                      
  10f3d9:	75 1e                	jne    10f3f9 <rtems_rate_monotonic_get_status+0x71>
        #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS      
          status->since_last_period.tv_sec = 0;                       
  10f3db:	c7 46 08 00 00 00 00 	movl   $0x0,0x8(%esi)                 
          status->since_last_period.tv_nsec = 0;                      
  10f3e2:	c7 46 0c 00 00 00 00 	movl   $0x0,0xc(%esi)                 
        #else                                                         
          status->since_last_period = 0;                              
        #endif                                                        
        #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS           
          status->executed_since_last_period.tv_sec = 0;              
  10f3e9:	c7 46 10 00 00 00 00 	movl   $0x0,0x10(%esi)                
          status->executed_since_last_period.tv_nsec = 0;             
  10f3f0:	c7 46 14 00 00 00 00 	movl   $0x0,0x14(%esi)                
  10f3f7:	eb 32                	jmp    10f42b <rtems_rate_monotonic_get_status+0xa3>
         *  This lets them share one single invocation of _TOD_Get_uptime().
         */                                                           
        #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \
            defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)     
          struct timespec uptime;                                     
          _TOD_Get_uptime( &uptime );                                 
  10f3f9:	83 ec 0c             	sub    $0xc,%esp                      
  10f3fc:	8d 5d e8             	lea    -0x18(%ebp),%ebx               
  10f3ff:	53                   	push   %ebx                           
  10f400:	e8 57 c1 ff ff       	call   10b55c <_TOD_Get_uptime>       
        #endif                                                        
                                                                      
        #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS      
          _Timespec_Subtract(                                         
  10f405:	83 c4 0c             	add    $0xc,%esp                      
  10f408:	8d 46 08             	lea    0x8(%esi),%eax                 
  10f40b:	50                   	push   %eax                           
  10f40c:	53                   	push   %ebx                           
  10f40d:	8d 47 44             	lea    0x44(%edi),%eax                
  10f410:	50                   	push   %eax                           
  10f411:	e8 86 de ff ff       	call   10d29c <_Timespec_Subtract>    
          status->since_last_period =                                 
            _Watchdog_Ticks_since_boot - the_period->time_at_period;  
        #endif                                                        
                                                                      
        #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS           
          _Timespec_Subtract(                                         
  10f416:	83 c4 0c             	add    $0xc,%esp                      
  10f419:	8d 46 10             	lea    0x10(%esi),%eax                
  10f41c:	50                   	push   %eax                           
  10f41d:	53                   	push   %ebx                           
  10f41e:	68 04 1d 12 00       	push   $0x121d04                      
  10f423:	e8 74 de ff ff       	call   10d29c <_Timespec_Subtract>    
  10f428:	83 c4 10             	add    $0x10,%esp                     
            the_period->owner->cpu_time_used -                        
            the_period->owner_executed_at_period;                     
        #endif                                                        
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
  10f42b:	e8 54 d1 ff ff       	call   10c584 <_Thread_Enable_dispatch>
  10f430:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10f432:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10f435:	5b                   	pop    %ebx                           
  10f436:	5e                   	pop    %esi                           
  10f437:	5f                   	pop    %edi                           
  10f438:	c9                   	leave                                 
  10f439:	c3                   	ret                                   
                                                                      

00109f7e <rtems_rate_monotonic_period>: rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) {
  109f7e:	55                   	push   %ebp                           
  109f7f:	89 e5                	mov    %esp,%ebp                      
  109f81:	57                   	push   %edi                           
  109f82:	56                   	push   %esi                           
  109f83:	53                   	push   %ebx                           
  109f84:	83 ec 20             	sub    $0x20,%esp                     
  109f87:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory 
  109f8a:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  109f8d:	50                   	push   %eax                           
  109f8e:	ff 75 08             	pushl  0x8(%ebp)                      
  109f91:	68 44 1b 12 00       	push   $0x121b44                      
  109f96:	e8 29 1e 00 00       	call   10bdc4 <_Objects_Get>          
  109f9b:	89 c3                	mov    %eax,%ebx                      
  rtems_rate_monotonic_period_states   local_state;                   
  ISR_Level                            level;                         
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
                                                                      
  switch ( location ) {                                               
  109f9d:	83 c4 10             	add    $0x10,%esp                     
  109fa0:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  109fa4:	0f 85 44 01 00 00    	jne    10a0ee <rtems_rate_monotonic_period+0x170>
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
  109faa:	8b 40 50             	mov    0x50(%eax),%eax                
  109fad:	3b 05 fc 1c 12 00    	cmp    0x121cfc,%eax                  
  109fb3:	74 0f                	je     109fc4 <rtems_rate_monotonic_period+0x46>
        _Thread_Enable_dispatch();                                    
  109fb5:	e8 ca 25 00 00       	call   10c584 <_Thread_Enable_dispatch>
  109fba:	bb 17 00 00 00       	mov    $0x17,%ebx                     
  109fbf:	e9 2f 01 00 00       	jmp    10a0f3 <rtems_rate_monotonic_period+0x175>
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
  109fc4:	85 ff                	test   %edi,%edi                      
  109fc6:	75 21                	jne    109fe9 <rtems_rate_monotonic_period+0x6b>
        switch ( the_period->state ) {                                
  109fc8:	8b 43 38             	mov    0x38(%ebx),%eax                
  109fcb:	bb 0b 00 00 00       	mov    $0xb,%ebx                      
  109fd0:	85 c0                	test   %eax,%eax                      
  109fd2:	74 0b                	je     109fdf <rtems_rate_monotonic_period+0x61>
  109fd4:	83 e8 03             	sub    $0x3,%eax                      
  109fd7:	83 f8 02             	cmp    $0x2,%eax                      
  109fda:	19 db                	sbb    %ebx,%ebx                      
  109fdc:	83 e3 06             	and    $0x6,%ebx                      
          case RATE_MONOTONIC_ACTIVE:                                 
          default:              /* unreached -- only to remove warnings */
            return_value = RTEMS_SUCCESSFUL;                          
            break;                                                    
        }                                                             
        _Thread_Enable_dispatch();                                    
  109fdf:	e8 a0 25 00 00       	call   10c584 <_Thread_Enable_dispatch>
  109fe4:	e9 0a 01 00 00       	jmp    10a0f3 <rtems_rate_monotonic_period+0x175>
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
  109fe9:	9c                   	pushf                                 
  109fea:	fa                   	cli                                   
  109feb:	5e                   	pop    %esi                           
                                                                      
      switch ( the_period->state ) {                                  
  109fec:	8b 43 38             	mov    0x38(%ebx),%eax                
  109fef:	83 f8 02             	cmp    $0x2,%eax                      
  109ff2:	74 60                	je     10a054 <rtems_rate_monotonic_period+0xd6>
  109ff4:	83 f8 04             	cmp    $0x4,%eax                      
  109ff7:	0f 84 ba 00 00 00    	je     10a0b7 <rtems_rate_monotonic_period+0x139>
  109ffd:	85 c0                	test   %eax,%eax                      
  109fff:	0f 85 e9 00 00 00    	jne    10a0ee <rtems_rate_monotonic_period+0x170><== NEVER TAKEN
        case RATE_MONOTONIC_INACTIVE: {                               
                                                                      
          _ISR_Enable( level );                                       
  10a005:	56                   	push   %esi                           
  10a006:	9d                   	popf                                  
                                                                      
          /*                                                          
           *  Baseline statistics information for the beginning of a period.
           */                                                         
          _Rate_monotonic_Initiate_statistics( the_period );          
  10a007:	83 ec 0c             	sub    $0xc,%esp                      
  10a00a:	53                   	push   %ebx                           
  10a00b:	e8 c8 fd ff ff       	call   109dd8 <_Rate_monotonic_Initiate_statistics>
                                                                      
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
  10a010:	c7 43 38 02 00 00 00 	movl   $0x2,0x38(%ebx)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10a017:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  10a01e:	c7 43 2c 14 a3 10 00 	movl   $0x10a314,0x2c(%ebx)           
 *  @param[in] starting_address is the starting address of the memory for
  10a025:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10a028:	89 43 30             	mov    %eax,0x30(%ebx)                
 *         the heap                                                   
  10a02b:	c7 43 34 00 00 00 00 	movl   $0x0,0x34(%ebx)                
            _Rate_monotonic_Timeout,                                  
            id,                                                       
            NULL                                                      
          );                                                          
                                                                      
          the_period->next_length = length;                           
  10a032:	89 7b 4c             	mov    %edi,0x4c(%ebx)                
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10a035:	89 7b 1c             	mov    %edi,0x1c(%ebx)                
  void                *starting_address,                              
  size_t              *size                                           
  10a038:	58                   	pop    %eax                           
  10a039:	5a                   	pop    %edx                           
  10a03a:	8d 43 10             	lea    0x10(%ebx),%eax                
  10a03d:	50                   	push   %eax                           
  10a03e:	68 1c 1d 12 00       	push   $0x121d1c                      
  10a043:	e8 98 34 00 00       	call   10d4e0 <_Watchdog_Insert>      
                                                                      
          _Watchdog_Insert_ticks( &the_period->Timer, length );       
          _Thread_Enable_dispatch();                                  
  10a048:	e8 37 25 00 00       	call   10c584 <_Thread_Enable_dispatch>
  10a04d:	31 db                	xor    %ebx,%ebx                      
  10a04f:	e9 95 00 00 00       	jmp    10a0e9 <rtems_rate_monotonic_period+0x16b>
        case RATE_MONOTONIC_ACTIVE:                                   
                                                                      
          /*                                                          
           *  Update statistics from the concluding period.           
           */                                                         
          _Rate_monotonic_Update_statistics( the_period );            
  10a054:	83 ec 0c             	sub    $0xc,%esp                      
  10a057:	53                   	push   %ebx                           
  10a058:	e8 e3 fd ff ff       	call   109e40 <_Rate_monotonic_Update_statistics>
          /*                                                          
           *  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;       
  10a05d:	c7 43 38 01 00 00 00 	movl   $0x1,0x38(%ebx)                
          the_period->next_length = length;                           
  10a064:	89 7b 4c             	mov    %edi,0x4c(%ebx)                
                                                                      
          _ISR_Enable( level );                                       
  10a067:	56                   	push   %esi                           
  10a068:	9d                   	popf                                  
                                                                      
          _Thread_Executing->Wait.id = the_period->Object.id;         
  10a069:	8b 15 fc 1c 12 00    	mov    0x121cfc,%edx                  
  10a06f:	8b 43 08             	mov    0x8(%ebx),%eax                 
  10a072:	89 42 20             	mov    %eax,0x20(%edx)                
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
  10a075:	5e                   	pop    %esi                           
  10a076:	5f                   	pop    %edi                           
  10a077:	68 00 40 00 00       	push   $0x4000                        
  10a07c:	52                   	push   %edx                           
  10a07d:	e8 1e 2d 00 00       	call   10cda0 <_Thread_Set_state>     
                                                                      
          /*                                                          
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?                                                  
           */                                                         
          _ISR_Disable( level );                                      
  10a082:	9c                   	pushf                                 
  10a083:	fa                   	cli                                   
  10a084:	58                   	pop    %eax                           
            local_state = the_period->state;                          
  10a085:	8b 53 38             	mov    0x38(%ebx),%edx                
            the_period->state = RATE_MONOTONIC_ACTIVE;                
  10a088:	c7 43 38 02 00 00 00 	movl   $0x2,0x38(%ebx)                
          _ISR_Enable( level );                                       
  10a08f:	50                   	push   %eax                           
  10a090:	9d                   	popf                                  
                                                                      
          /*                                                          
           *  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 ) 
  10a091:	83 c4 10             	add    $0x10,%esp                     
  10a094:	83 fa 03             	cmp    $0x3,%edx                      
  10a097:	75 15                	jne    10a0ae <rtems_rate_monotonic_period+0x130><== ALWAYS TAKEN
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
  10a099:	51                   	push   %ecx                           <== NOT EXECUTED
  10a09a:	51                   	push   %ecx                           <== NOT EXECUTED
  10a09b:	68 00 40 00 00       	push   $0x4000                        <== NOT EXECUTED
  10a0a0:	ff 35 fc 1c 12 00    	pushl  0x121cfc                       <== NOT EXECUTED
  10a0a6:	e8 59 21 00 00       	call   10c204 <_Thread_Clear_state>   <== NOT EXECUTED
  10a0ab:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
          _Thread_Enable_dispatch();                                  
  10a0ae:	e8 d1 24 00 00       	call   10c584 <_Thread_Enable_dispatch>
  10a0b3:	31 db                	xor    %ebx,%ebx                      
  10a0b5:	eb 3c                	jmp    10a0f3 <rtems_rate_monotonic_period+0x175>
        case RATE_MONOTONIC_EXPIRED:                                  
                                                                      
          /*                                                          
           *  Update statistics from the concluding period            
           */                                                         
          _Rate_monotonic_Update_statistics( the_period );            
  10a0b7:	83 ec 0c             	sub    $0xc,%esp                      
  10a0ba:	53                   	push   %ebx                           
  10a0bb:	e8 80 fd ff ff       	call   109e40 <_Rate_monotonic_Update_statistics>
                                                                      
          _ISR_Enable( level );                                       
  10a0c0:	56                   	push   %esi                           
  10a0c1:	9d                   	popf                                  
                                                                      
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
  10a0c2:	c7 43 38 02 00 00 00 	movl   $0x2,0x38(%ebx)                
          the_period->next_length = length;                           
  10a0c9:	89 7b 4c             	mov    %edi,0x4c(%ebx)                
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10a0cc:	89 7b 1c             	mov    %edi,0x1c(%ebx)                
  void                *starting_address,                              
  size_t              *size                                           
  10a0cf:	58                   	pop    %eax                           
  10a0d0:	5a                   	pop    %edx                           
  10a0d1:	8d 43 10             	lea    0x10(%ebx),%eax                
  10a0d4:	50                   	push   %eax                           
  10a0d5:	68 1c 1d 12 00       	push   $0x121d1c                      
  10a0da:	e8 01 34 00 00       	call   10d4e0 <_Watchdog_Insert>      
                                                                      
          _Watchdog_Insert_ticks( &the_period->Timer, length );       
          _Thread_Enable_dispatch();                                  
  10a0df:	e8 a0 24 00 00       	call   10c584 <_Thread_Enable_dispatch>
  10a0e4:	bb 06 00 00 00       	mov    $0x6,%ebx                      
  10a0e9:	83 c4 10             	add    $0x10,%esp                     
  10a0ec:	eb 05                	jmp    10a0f3 <rtems_rate_monotonic_period+0x175>
          return RTEMS_TIMEOUT;                                       
  10a0ee:	bb 04 00 00 00       	mov    $0x4,%ebx                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10a0f3:	89 d8                	mov    %ebx,%eax                      
  10a0f5:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a0f8:	5b                   	pop    %ebx                           
  10a0f9:	5e                   	pop    %esi                           
  10a0fa:	5f                   	pop    %edi                           
  10a0fb:	c9                   	leave                                 
  10a0fc:	c3                   	ret                                   
                                                                      

0010a100 <rtems_rate_monotonic_report_statistics_with_plugin>: */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
  10a100:	55                   	push   %ebp                           
  10a101:	89 e5                	mov    %esp,%ebp                      
  10a103:	57                   	push   %edi                           
  10a104:	56                   	push   %esi                           
  10a105:	53                   	push   %ebx                           
  10a106:	83 ec 6c             	sub    $0x6c,%esp                     
  10a109:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  rtems_id                               id;                          
  rtems_rate_monotonic_period_statistics the_stats;                   
  rtems_rate_monotonic_period_status     the_status;                  
  char                                   name[5];                     
                                                                      
  if ( !print )                                                       
  10a10c:	85 f6                	test   %esi,%esi                      
  10a10e:	0f 84 44 01 00 00    	je     10a258 <rtems_rate_monotonic_report_statistics_with_plugin+0x158><== NEVER TAKEN
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
  10a114:	51                   	push   %ecx                           
  10a115:	51                   	push   %ecx                           
  10a116:	68 e4 a9 11 00       	push   $0x11a9e4                      
  10a11b:	ff 75 08             	pushl  0x8(%ebp)                      
  10a11e:	ff d6                	call   *%esi                          
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)             
  (*print)( context, "--- CPU times are in seconds ---\n" );          
  10a120:	58                   	pop    %eax                           
  10a121:	5a                   	pop    %edx                           
  10a122:	68 02 aa 11 00       	push   $0x11aa02                      
  10a127:	ff 75 08             	pushl  0x8(%ebp)                      
  10a12a:	ff d6                	call   *%esi                          
#endif                                                                
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)        
  (*print)( context, "--- Wall times are in seconds ---\n" );         
  10a12c:	5f                   	pop    %edi                           
  10a12d:	58                   	pop    %eax                           
  10a12e:	68 24 aa 11 00       	push   $0x11aa24                      
  10a133:	ff 75 08             	pushl  0x8(%ebp)                      
  10a136:	ff d6                	call   *%esi                          
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
  10a138:	59                   	pop    %ecx                           
  10a139:	5b                   	pop    %ebx                           
  10a13a:	68 47 aa 11 00       	push   $0x11aa47                      
  10a13f:	ff 75 08             	pushl  0x8(%ebp)                      
  10a142:	ff d6                	call   *%esi                          
       #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS       
          "      "                                                    
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
  10a144:	58                   	pop    %eax                           
  10a145:	5a                   	pop    %edx                           
  10a146:	68 92 aa 11 00       	push   $0x11aa92                      
  10a14b:	ff 75 08             	pushl  0x8(%ebp)                      
  10a14e:	ff d6                	call   *%esi                          
                                                                      
  /*                                                                  
   * 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 ;                   
  10a150:	8b 3d 4c 1b 12 00    	mov    0x121b4c,%edi                  
  10a156:	83 c4 10             	add    $0x10,%esp                     
  10a159:	e9 ee 00 00 00       	jmp    10a24c <rtems_rate_monotonic_report_statistics_with_plugin+0x14c>
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
  10a15e:	50                   	push   %eax                           
  10a15f:	50                   	push   %eax                           
  10a160:	8d 45 94             	lea    -0x6c(%ebp),%eax               
  10a163:	50                   	push   %eax                           
  10a164:	57                   	push   %edi                           
  10a165:	e8 ce 51 00 00       	call   10f338 <rtems_rate_monotonic_get_statistics>
    if ( status != RTEMS_SUCCESSFUL )                                 
  10a16a:	83 c4 10             	add    $0x10,%esp                     
  10a16d:	85 c0                	test   %eax,%eax                      
  10a16f:	0f 85 d6 00 00 00    	jne    10a24b <rtems_rate_monotonic_report_statistics_with_plugin+0x14b>
      continue;                                                       
                                                                      
    /* If the above passed, so should this but check it anyway */     
    status = rtems_rate_monotonic_get_status( id, &the_status );      
  10a175:	50                   	push   %eax                           
  10a176:	50                   	push   %eax                           
  10a177:	8d 55 cc             	lea    -0x34(%ebp),%edx               
  10a17a:	52                   	push   %edx                           
  10a17b:	57                   	push   %edi                           
  10a17c:	e8 07 52 00 00       	call   10f388 <rtems_rate_monotonic_get_status>
    #if defined(RTEMS_DEBUG)                                          
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #endif                                                            
                                                                      
    name[ 0 ] = '\0';                                                 
  10a181:	c6 45 ef 00          	movb   $0x0,-0x11(%ebp)               
                                                                      
    if ( the_status.owner ) {                                         
  10a185:	8b 55 cc             	mov    -0x34(%ebp),%edx               
  10a188:	83 c4 10             	add    $0x10,%esp                     
  10a18b:	85 d2                	test   %edx,%edx                      
  10a18d:	74 10                	je     10a19f <rtems_rate_monotonic_report_statistics_with_plugin+0x9f><== NEVER TAKEN
      rtems_object_get_name( the_status.owner, sizeof(name), name );  
  10a18f:	50                   	push   %eax                           
  10a190:	8d 45 ef             	lea    -0x11(%ebp),%eax               
  10a193:	50                   	push   %eax                           
  10a194:	6a 05                	push   $0x5                           
  10a196:	52                   	push   %edx                           
  10a197:	e8 04 02 00 00       	call   10a3a0 <rtems_object_get_name> 
  10a19c:	83 c4 10             	add    $0x10,%esp                     
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
                                                                      
    (*print)( context,                                                
  10a19f:	53                   	push   %ebx                           
  10a1a0:	53                   	push   %ebx                           
  10a1a1:	ff 75 98             	pushl  -0x68(%ebp)                    
  10a1a4:	ff 75 94             	pushl  -0x6c(%ebp)                    
  10a1a7:	8d 45 ef             	lea    -0x11(%ebp),%eax               
  10a1aa:	50                   	push   %eax                           
  10a1ab:	57                   	push   %edi                           
  10a1ac:	68 de aa 11 00       	push   $0x11aade                      
  10a1b1:	ff 75 08             	pushl  0x8(%ebp)                      
  10a1b4:	ff d6                	call   *%esi                          
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
                                                                      
    if (the_stats.count == 0) {                                       
  10a1b6:	8b 45 94             	mov    -0x6c(%ebp),%eax               
  10a1b9:	83 c4 20             	add    $0x20,%esp                     
  10a1bc:	85 c0                	test   %eax,%eax                      
  10a1be:	75 11                	jne    10a1d1 <rtems_rate_monotonic_report_statistics_with_plugin+0xd1>
      (*print)( context, "\n" );                                      
  10a1c0:	51                   	push   %ecx                           
  10a1c1:	51                   	push   %ecx                           
  10a1c2:	68 91 ad 11 00       	push   $0x11ad91                      
  10a1c7:	ff 75 08             	pushl  0x8(%ebp)                      
  10a1ca:	ff d6                	call   *%esi                          
  10a1cc:	83 c4 10             	add    $0x10,%esp                     
  10a1cf:	eb 7a                	jmp    10a24b <rtems_rate_monotonic_report_statistics_with_plugin+0x14b>
     */                                                               
    {                                                                 
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS               
      struct timespec   cpu_average;                                  
                                                                      
      _Timespec_Divide_by_integer(                                    
  10a1d1:	52                   	push   %edx                           
  10a1d2:	8d 55 e4             	lea    -0x1c(%ebp),%edx               
  10a1d5:	52                   	push   %edx                           
  10a1d6:	50                   	push   %eax                           
  10a1d7:	8d 45 ac             	lea    -0x54(%ebp),%eax               
  10a1da:	50                   	push   %eax                           
  10a1db:	e8 f8 2f 00 00       	call   10d1d8 <_Timespec_Divide_by_integer>
         &the_stats.total_cpu_time,                                   
         the_stats.count,                                             
         &cpu_average                                                 
      );                                                              
      (*print)( context,                                              
  10a1e0:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10a1e3:	bb e8 03 00 00       	mov    $0x3e8,%ebx                    
  10a1e8:	99                   	cltd                                  
  10a1e9:	f7 fb                	idiv   %ebx                           
  10a1eb:	50                   	push   %eax                           
  10a1ec:	ff 75 e4             	pushl  -0x1c(%ebp)                    
  10a1ef:	8b 45 a8             	mov    -0x58(%ebp),%eax               
  10a1f2:	99                   	cltd                                  
  10a1f3:	f7 fb                	idiv   %ebx                           
  10a1f5:	50                   	push   %eax                           
  10a1f6:	ff 75 a4             	pushl  -0x5c(%ebp)                    
  10a1f9:	8b 45 a0             	mov    -0x60(%ebp),%eax               
  10a1fc:	99                   	cltd                                  
  10a1fd:	f7 fb                	idiv   %ebx                           
  10a1ff:	50                   	push   %eax                           
  10a200:	ff 75 9c             	pushl  -0x64(%ebp)                    
  10a203:	68 f5 aa 11 00       	push   $0x11aaf5                      
  10a208:	ff 75 08             	pushl  0x8(%ebp)                      
  10a20b:	ff d6                	call   *%esi                          
     *  print Wall time part of statistics                            
     */                                                               
    {                                                                 
    #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS          
      struct timespec  wall_average;                                  
      _Timespec_Divide_by_integer(                                    
  10a20d:	83 c4 2c             	add    $0x2c,%esp                     
  10a210:	8d 45 e4             	lea    -0x1c(%ebp),%eax               
  10a213:	50                   	push   %eax                           
  10a214:	ff 75 94             	pushl  -0x6c(%ebp)                    
  10a217:	8d 45 c4             	lea    -0x3c(%ebp),%eax               
  10a21a:	50                   	push   %eax                           
  10a21b:	e8 b8 2f 00 00       	call   10d1d8 <_Timespec_Divide_by_integer>
         &the_stats.total_wall_time,                                  
         the_stats.count,                                             
         &wall_average                                                
      );                                                              
      (*print)( context,                                              
  10a220:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  10a223:	99                   	cltd                                  
  10a224:	f7 fb                	idiv   %ebx                           
  10a226:	50                   	push   %eax                           
  10a227:	ff 75 e4             	pushl  -0x1c(%ebp)                    
  10a22a:	8b 45 c0             	mov    -0x40(%ebp),%eax               
  10a22d:	99                   	cltd                                  
  10a22e:	f7 fb                	idiv   %ebx                           
  10a230:	50                   	push   %eax                           
  10a231:	ff 75 bc             	pushl  -0x44(%ebp)                    
  10a234:	8b 45 b8             	mov    -0x48(%ebp),%eax               
  10a237:	99                   	cltd                                  
  10a238:	f7 fb                	idiv   %ebx                           
  10a23a:	50                   	push   %eax                           
  10a23b:	ff 75 b4             	pushl  -0x4c(%ebp)                    
  10a23e:	68 14 ab 11 00       	push   $0x11ab14                      
  10a243:	ff 75 08             	pushl  0x8(%ebp)                      
  10a246:	ff d6                	call   *%esi                          
  10a248:	83 c4 30             	add    $0x30,%esp                     
   * 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++ ) {                                                      
  10a24b:	47                   	inc    %edi                           
  /*                                                                  
   * 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 ;                
  10a24c:	3b 3d 50 1b 12 00    	cmp    0x121b50,%edi                  
  10a252:	0f 86 06 ff ff ff    	jbe    10a15e <rtems_rate_monotonic_report_statistics_with_plugin+0x5e>
        the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
      );                                                              
    #endif                                                            
    }                                                                 
  }                                                                   
}                                                                     
  10a258:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a25b:	5b                   	pop    %ebx                           
  10a25c:	5e                   	pop    %esi                           
  10a25d:	5f                   	pop    %edi                           
  10a25e:	c9                   	leave                                 
  10a25f:	c3                   	ret                                   
                                                                      

00111ac0 <rtems_region_extend>: rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) {
  111ac0:	55                   	push   %ebp                           
  111ac1:	89 e5                	mov    %esp,%ebp                      
  111ac3:	57                   	push   %edi                           
  111ac4:	56                   	push   %esi                           
  111ac5:	53                   	push   %ebx                           
  111ac6:	83 ec 1c             	sub    $0x1c,%esp                     
  111ac9:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  Heap_Extend_status  heap_status;                                    
  Objects_Locations   location;                                       
  rtems_status_code   return_status = RTEMS_INTERNAL_ERROR;           
  Region_Control     *the_region;                                     
                                                                      
  if ( !starting_address )                                            
  111acc:	bb 09 00 00 00       	mov    $0x9,%ebx                      
  111ad1:	85 ff                	test   %edi,%edi                      
  111ad3:	0f 84 82 00 00 00    	je     111b5b <rtems_region_extend+0x9b><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                      /* to prevent deletion */
  111ad9:	83 ec 0c             	sub    $0xc,%esp                      
  111adc:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111ae2:	e8 29 1f 00 00       	call   113a10 <_API_Mutex_Lock>       
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  111ae7:	83 c4 0c             	add    $0xc,%esp                      
  111aea:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  111aed:	50                   	push   %eax                           
  111aee:	ff 75 08             	pushl  0x8(%ebp)                      
  111af1:	68 ec 3f 13 00       	push   $0x133fec                      
  111af6:	e8 c1 34 00 00       	call   114fbc <_Objects_Get_no_protection>
  111afb:	89 c6                	mov    %eax,%esi                      
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
  111afd:	83 c4 10             	add    $0x10,%esp                     
  111b00:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  111b03:	85 c0                	test   %eax,%eax                      
  111b05:	74 08                	je     111b0f <rtems_region_extend+0x4f>
  111b07:	bb 04 00 00 00       	mov    $0x4,%ebx                      
  111b0c:	48                   	dec    %eax                           
  111b0d:	eb 25                	jmp    111b34 <rtems_region_extend+0x74>
                                                                      
      case OBJECTS_LOCAL:                                             
                                                                      
        heap_status = _Heap_Extend(                                   
  111b0f:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  111b12:	50                   	push   %eax                           
  111b13:	ff 75 10             	pushl  0x10(%ebp)                     
  111b16:	57                   	push   %edi                           
  111b17:	8d 46 68             	lea    0x68(%esi),%eax                
  111b1a:	50                   	push   %eax                           
  111b1b:	e8 ec 28 00 00       	call   11440c <_Heap_Extend>          
          starting_address,                                           
          length,                                                     
          &amount_extended                                            
        );                                                            
                                                                      
        switch ( heap_status ) {                                      
  111b20:	83 c4 10             	add    $0x10,%esp                     
  111b23:	bb 09 00 00 00       	mov    $0x9,%ebx                      
  111b28:	83 f8 01             	cmp    $0x1,%eax                      
  111b2b:	74 1d                	je     111b4a <rtems_region_extend+0x8a>
  111b2d:	72 09                	jb     111b38 <rtems_region_extend+0x78>
          case HEAP_EXTEND_SUCCESSFUL:                                
            the_region->length                += amount_extended;     
            the_region->maximum_segment_size  += amount_extended;     
            return_status = RTEMS_SUCCESSFUL;                         
            break;                                                    
  111b2f:	b3 18                	mov    $0x18,%bl                      
          starting_address,                                           
          length,                                                     
          &amount_extended                                            
        );                                                            
                                                                      
        switch ( heap_status ) {                                      
  111b31:	83 f8 02             	cmp    $0x2,%eax                      
  111b34:	75 0f                	jne    111b45 <rtems_region_extend+0x85><== NEVER TAKEN
  111b36:	eb 12                	jmp    111b4a <rtems_region_extend+0x8a>
          case HEAP_EXTEND_SUCCESSFUL:                                
            the_region->length                += amount_extended;     
  111b38:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  111b3b:	01 46 54             	add    %eax,0x54(%esi)                
            the_region->maximum_segment_size  += amount_extended;     
  111b3e:	01 46 5c             	add    %eax,0x5c(%esi)                
  111b41:	31 db                	xor    %ebx,%ebx                      
  111b43:	eb 05                	jmp    111b4a <rtems_region_extend+0x8a>
            return_status = RTEMS_SUCCESSFUL;                         
            break;                                                    
  111b45:	bb 19 00 00 00       	mov    $0x19,%ebx                     <== NOT EXECUTED
      case OBJECTS_ERROR:                                             
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
  111b4a:	83 ec 0c             	sub    $0xc,%esp                      
  111b4d:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111b53:	e8 00 1f 00 00       	call   113a58 <_API_Mutex_Unlock>     
  111b58:	83 c4 10             	add    $0x10,%esp                     
  return return_status;                                               
}                                                                     
  111b5b:	89 d8                	mov    %ebx,%eax                      
  111b5d:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  111b60:	5b                   	pop    %ebx                           
  111b61:	5e                   	pop    %esi                           
  111b62:	5f                   	pop    %edi                           
  111b63:	c9                   	leave                                 
  111b64:	c3                   	ret                                   
                                                                      

00111c80 <rtems_region_get_segment>: uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) {
  111c80:	55                   	push   %ebp                           
  111c81:	89 e5                	mov    %esp,%ebp                      
  111c83:	57                   	push   %edi                           
  111c84:	56                   	push   %esi                           
  111c85:	53                   	push   %ebx                           
  111c86:	83 ec 1c             	sub    $0x1c,%esp                     
  Objects_Locations        location;                                  
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;      
  register Region_Control *the_region;                                
  void                    *the_segment;                               
                                                                      
  if ( !segment )                                                     
  111c89:	bb 09 00 00 00       	mov    $0x9,%ebx                      
  111c8e:	83 7d 18 00          	cmpl   $0x0,0x18(%ebp)                
  111c92:	0f 84 fd 00 00 00    	je     111d95 <rtems_region_get_segment+0x115><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  *segment = NULL;                                                    
  111c98:	8b 45 18             	mov    0x18(%ebp),%eax                
  111c9b:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    
                                                                      
  if ( size == 0 )                                                    
  111ca1:	bb 08 00 00 00       	mov    $0x8,%ebx                      
  111ca6:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  111caa:	0f 84 e5 00 00 00    	je     111d95 <rtems_region_get_segment+0x115><== NEVER TAKEN
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  _RTEMS_Lock_allocator();                                            
  111cb0:	83 ec 0c             	sub    $0xc,%esp                      
  111cb3:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111cb9:	e8 52 1d 00 00       	call   113a10 <_API_Mutex_Lock>       
                                                                      
    executing  = _Thread_Executing;                                   
  111cbe:	8b 3d f8 41 13 00    	mov    0x1341f8,%edi                  
  111cc4:	83 c4 0c             	add    $0xc,%esp                      
  111cc7:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  111cca:	50                   	push   %eax                           
  111ccb:	ff 75 08             	pushl  0x8(%ebp)                      
  111cce:	68 ec 3f 13 00       	push   $0x133fec                      
  111cd3:	e8 e4 32 00 00       	call   114fbc <_Objects_Get_no_protection>
  111cd8:	89 c6                	mov    %eax,%esi                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
  111cda:	83 c4 10             	add    $0x10,%esp                     
  111cdd:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  111ce0:	85 c0                	test   %eax,%eax                      
  111ce2:	74 14                	je     111cf8 <rtems_region_get_segment+0x78>
  111ce4:	31 db                	xor    %ebx,%ebx                      
  111ce6:	83 f8 01             	cmp    $0x1,%eax                      
  111ce9:	0f 95 c3             	setne  %bl                            
  111cec:	4b                   	dec    %ebx                           
  111ced:	83 e3 eb             	and    $0xffffffeb,%ebx               
  111cf0:	83 c3 19             	add    $0x19,%ebx                     
  111cf3:	e9 8c 00 00 00       	jmp    111d84 <rtems_region_get_segment+0x104>
                                                                      
      case OBJECTS_LOCAL:                                             
        if ( size > the_region->maximum_segment_size )                
  111cf8:	bb 08 00 00 00       	mov    $0x8,%ebx                      
  111cfd:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  111d00:	3b 56 5c             	cmp    0x5c(%esi),%edx                
  111d03:	77 7f                	ja     111d84 <rtems_region_get_segment+0x104>
                                                                      
/**                                                                   
 *  This function attempts to allocate a block of @a size bytes from  
 *  @a the_heap.  If insufficient memory is free in @a the_heap to allocate
 *  a block of the requested size, then NULL is returned.             
 *                                                                    
  111d05:	50                   	push   %eax                           
  111d06:	50                   	push   %eax                           
  111d07:	ff 75 0c             	pushl  0xc(%ebp)                      
  111d0a:	8d 46 68             	lea    0x68(%esi),%eax                
  111d0d:	50                   	push   %eax                           
  111d0e:	e8 8d 26 00 00       	call   1143a0 <_Heap_Allocate>        
                                                                      
          the_segment = _Region_Allocate_segment( the_region, size ); 
                                                                      
          _Region_Debug_Walk( the_region, 2 );                        
                                                                      
          if ( the_segment ) {                                        
  111d13:	83 c4 10             	add    $0x10,%esp                     
  111d16:	85 c0                	test   %eax,%eax                      
  111d18:	74 0c                	je     111d26 <rtems_region_get_segment+0xa6>
            the_region->number_of_used_blocks += 1;                   
  111d1a:	ff 46 64             	incl   0x64(%esi)                     
            *segment = the_segment;                                   
  111d1d:	8b 55 18             	mov    0x18(%ebp),%edx                
  111d20:	89 02                	mov    %eax,(%edx)                    
  111d22:	31 db                	xor    %ebx,%ebx                      
  111d24:	eb 5e                	jmp    111d84 <rtems_region_get_segment+0x104>
            return_status = RTEMS_SUCCESSFUL;                         
          }                                                           
                                                                      
          else if ( _Options_Is_no_wait( option_set ) ) {             
  111d26:	bb 0d 00 00 00       	mov    $0xd,%ebx                      
  111d2b:	f6 45 10 01          	testb  $0x1,0x10(%ebp)                
  111d2f:	75 53                	jne    111d84 <rtems_region_get_segment+0x104>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  111d31:	a1 38 41 13 00       	mov    0x134138,%eax                  
  111d36:	40                   	inc    %eax                           
  111d37:	a3 38 41 13 00       	mov    %eax,0x134138                  
             *  Switch from using the memory allocation mutex to using a
             *  dispatching disabled critical section.  We have to do this
             *  because this thread is going to block.                
             */                                                       
            _Thread_Disable_dispatch();                               
            _RTEMS_Unlock_allocator();                                
  111d3c:	83 ec 0c             	sub    $0xc,%esp                      
  111d3f:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111d45:	e8 0e 1d 00 00       	call   113a58 <_API_Mutex_Unlock>     
                                                                      
            executing->Wait.queue           = &the_region->Wait_queue;
  111d4a:	8d 46 10             	lea    0x10(%esi),%eax                
  111d4d:	89 47 44             	mov    %eax,0x44(%edi)                
            executing->Wait.id              = id;                     
  111d50:	8b 55 08             	mov    0x8(%ebp),%edx                 
  111d53:	89 57 20             	mov    %edx,0x20(%edi)                
            executing->Wait.count           = size;                   
  111d56:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  111d59:	89 57 24             	mov    %edx,0x24(%edi)                
            executing->Wait.return_argument = segment;                
  111d5c:	8b 55 18             	mov    0x18(%ebp),%edx                
  111d5f:	89 57 28             	mov    %edx,0x28(%edi)                
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  111d62:	c7 46 40 01 00 00 00 	movl   $0x1,0x40(%esi)                
                                                                      
            _Thread_queue_Enter_critical_section( &the_region->Wait_queue );
                                                                      
            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
  111d69:	83 c4 0c             	add    $0xc,%esp                      
  111d6c:	68 0c 5f 11 00       	push   $0x115f0c                      
  111d71:	ff 75 14             	pushl  0x14(%ebp)                     
  111d74:	50                   	push   %eax                           
  111d75:	e8 8e 3e 00 00       	call   115c08 <_Thread_queue_Enqueue_with_handler>
                                                                      
            _Thread_Enable_dispatch();                                
  111d7a:	e8 39 3a 00 00       	call   1157b8 <_Thread_Enable_dispatch>
                                                                      
            return (rtems_status_code) executing->Wait.return_code;   
  111d7f:	8b 5f 34             	mov    0x34(%edi),%ebx                
  111d82:	eb 0e                	jmp    111d92 <rtems_region_get_segment+0x112>
      case OBJECTS_ERROR:                                             
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
  111d84:	83 ec 0c             	sub    $0xc,%esp                      
  111d87:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111d8d:	e8 c6 1c 00 00       	call   113a58 <_API_Mutex_Unlock>     
  111d92:	83 c4 10             	add    $0x10,%esp                     
  return return_status;                                               
}                                                                     
  111d95:	89 d8                	mov    %ebx,%eax                      
  111d97:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  111d9a:	5b                   	pop    %ebx                           
  111d9b:	5e                   	pop    %esi                           
  111d9c:	5f                   	pop    %edi                           
  111d9d:	c9                   	leave                                 
  111d9e:	c3                   	ret                                   
                                                                      

00111e50 <rtems_region_resize_segment>: Objects_Id id, void *segment, size_t size, size_t *old_size ) {
  111e50:	55                   	push   %ebp                           
  111e51:	89 e5                	mov    %esp,%ebp                      
  111e53:	57                   	push   %edi                           
  111e54:	56                   	push   %esi                           
  111e55:	53                   	push   %ebx                           
  111e56:	83 ec 1c             	sub    $0x1c,%esp                     
  111e59:	8b 7d 14             	mov    0x14(%ebp),%edi                
  uint32_t                 osize;                                     
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;      
  Heap_Resize_status       status;                                    
  register Region_Control *the_region;                                
                                                                      
  if ( !old_size )                                                    
  111e5c:	85 ff                	test   %edi,%edi                      
  111e5e:	0f 84 aa 00 00 00    	je     111f0e <rtems_region_resize_segment+0xbe>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
  111e64:	83 ec 0c             	sub    $0xc,%esp                      
  111e67:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111e6d:	e8 9e 1b 00 00       	call   113a10 <_API_Mutex_Lock>       
  111e72:	83 c4 0c             	add    $0xc,%esp                      
  111e75:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  111e78:	50                   	push   %eax                           
  111e79:	ff 75 08             	pushl  0x8(%ebp)                      
  111e7c:	68 ec 3f 13 00       	push   $0x133fec                      
  111e81:	e8 36 31 00 00       	call   114fbc <_Objects_Get_no_protection>
  111e86:	89 c3                	mov    %eax,%ebx                      
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
  111e88:	83 c4 10             	add    $0x10,%esp                     
  111e8b:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  111e8e:	85 c0                	test   %eax,%eax                      
  111e90:	74 1f                	je     111eb1 <rtems_region_resize_segment+0x61>
  111e92:	31 db                	xor    %ebx,%ebx                      
  111e94:	83 f8 01             	cmp    $0x1,%eax                      
  111e97:	0f 95 c3             	setne  %bl                            
  111e9a:	4b                   	dec    %ebx                           
  111e9b:	83 e3 eb             	and    $0xffffffeb,%ebx               
  111e9e:	83 c3 19             	add    $0x19,%ebx                     
      case OBJECTS_ERROR:                                             
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
  111ea1:	83 ec 0c             	sub    $0xc,%esp                      
  111ea4:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111eaa:	e8 a9 1b 00 00       	call   113a58 <_API_Mutex_Unlock>     
  111eaf:	eb 39                	jmp    111eea <rtems_region_resize_segment+0x9a>
                                                                      
      case OBJECTS_LOCAL:                                             
                                                                      
        _Region_Debug_Walk( the_region, 7 );                          
                                                                      
        status = _Heap_Resize_block(                                  
  111eb1:	83 ec 0c             	sub    $0xc,%esp                      
  111eb4:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  111eb7:	50                   	push   %eax                           
  111eb8:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  111ebb:	50                   	push   %eax                           
  111ebc:	ff 75 10             	pushl  0x10(%ebp)                     
  111ebf:	ff 75 0c             	pushl  0xc(%ebp)                      
  111ec2:	8d 43 68             	lea    0x68(%ebx),%eax                
  111ec5:	50                   	push   %eax                           
  111ec6:	e8 b9 29 00 00       	call   114884 <_Heap_Resize_block>    
  111ecb:	89 c6                	mov    %eax,%esi                      
          segment,                                                    
          (uint32_t) size,                                            
          &osize,                                                     
          &avail_size                                                 
        );                                                            
        *old_size = (uint32_t) osize;                                 
  111ecd:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  111ed0:	89 07                	mov    %eax,(%edi)                    
                                                                      
        _Region_Debug_Walk( the_region, 8 );                          
                                                                      
        if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )     
  111ed2:	83 c4 20             	add    $0x20,%esp                     
  111ed5:	85 f6                	test   %esi,%esi                      
  111ed7:	75 16                	jne    111eef <rtems_region_resize_segment+0x9f><== ALWAYS TAKEN
  111ed9:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               <== NOT EXECUTED
  111edd:	74 10                	je     111eef <rtems_region_resize_segment+0x9f><== NOT EXECUTED
          _Region_Process_queue( the_region );    /* unlocks allocator */
  111edf:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  111ee2:	53                   	push   %ebx                           <== NOT EXECUTED
  111ee3:	e8 8c 68 00 00       	call   118774 <_Region_Process_queue> <== NOT EXECUTED
  111ee8:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  111eea:	83 c4 10             	add    $0x10,%esp                     
  111eed:	eb 24                	jmp    111f13 <rtems_region_resize_segment+0xc3>
        else                                                          
          _RTEMS_Unlock_allocator();                                  
  111eef:	83 ec 0c             	sub    $0xc,%esp                      
  111ef2:	ff 35 f0 41 13 00    	pushl  0x1341f0                       
  111ef8:	e8 5b 1b 00 00       	call   113a58 <_API_Mutex_Unlock>     
                                                                      
        return                                                        
  111efd:	83 c4 10             	add    $0x10,%esp                     
  111f00:	31 db                	xor    %ebx,%ebx                      
  111f02:	85 f6                	test   %esi,%esi                      
  111f04:	74 0d                	je     111f13 <rtems_region_resize_segment+0xc3><== NEVER TAKEN
  111f06:	bb 0d 00 00 00       	mov    $0xd,%ebx                      
  111f0b:	4e                   	dec    %esi                           
  111f0c:	74 05                	je     111f13 <rtems_region_resize_segment+0xc3><== NEVER TAKEN
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
  return return_status;                                               
  111f0e:	bb 09 00 00 00       	mov    $0x9,%ebx                      
}                                                                     
  111f13:	89 d8                	mov    %ebx,%eax                      
  111f15:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  111f18:	5b                   	pop    %ebx                           
  111f19:	5e                   	pop    %esi                           
  111f1a:	5f                   	pop    %edi                           
  111f1b:	c9                   	leave                                 
  111f1c:	c3                   	ret                                   
                                                                      

00108f40 <rtems_semaphore_create>: uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) {
  108f40:	55                   	push   %ebp                           
  108f41:	89 e5                	mov    %esp,%ebp                      
  108f43:	57                   	push   %edi                           
  108f44:	56                   	push   %esi                           
  108f45:	53                   	push   %ebx                           
  108f46:	83 ec 2c             	sub    $0x2c,%esp                     
  108f49:	8b 5d 10             	mov    0x10(%ebp),%ebx                
  register Semaphore_Control *the_semaphore;                          
  CORE_mutex_Attributes       the_mutex_attributes;                   
  CORE_semaphore_Attributes   the_semaphore_attributes;               
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  108f4c:	b8 03 00 00 00       	mov    $0x3,%eax                      
  108f51:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  108f55:	0f 84 7f 01 00 00    	je     1090da <rtems_semaphore_create+0x19a><== NEVER TAKEN
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
  108f5b:	b8 09 00 00 00       	mov    $0x9,%eax                      
  108f60:	83 7d 18 00          	cmpl   $0x0,0x18(%ebp)                
  108f64:	0f 84 70 01 00 00    	je     1090da <rtems_semaphore_create+0x19a><== NEVER TAKEN
      return RTEMS_NOT_DEFINED;                                       
                                                                      
  } else                                                              
#endif                                                                
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) ||            
  108f6a:	89 da                	mov    %ebx,%edx                      
  108f6c:	81 e2 c0 00 00 00    	and    $0xc0,%edx                     
  108f72:	74 28                	je     108f9c <rtems_semaphore_create+0x5c>
 *  @param[in] alignment the required alignment                       
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  108f74:	89 d8                	mov    %ebx,%eax                      
  108f76:	83 e0 30             	and    $0x30,%eax                     
              _Attributes_Is_priority_ceiling( attribute_set ) ) {    
                                                                      
    if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||     
  108f79:	83 f8 10             	cmp    $0x10,%eax                     
  108f7c:	74 09                	je     108f87 <rtems_semaphore_create+0x47>
  108f7e:	83 f8 20             	cmp    $0x20,%eax                     
  108f81:	0f 85 4e 01 00 00    	jne    1090d5 <rtems_semaphore_create+0x195><== NEVER TAKEN
  108f87:	f6 c3 04             	test   $0x4,%bl                       
  108f8a:	0f 84 45 01 00 00    	je     1090d5 <rtems_semaphore_create+0x195><== NEVER TAKEN
             _Attributes_Is_priority( attribute_set ) ) )             
      return RTEMS_NOT_DEFINED;                                       
                                                                      
  }                                                                   
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) &&            
  108f90:	81 fa c0 00 00 00    	cmp    $0xc0,%edx                     
  108f96:	0f 84 39 01 00 00    	je     1090d5 <rtems_semaphore_create+0x195>
       _Attributes_Is_priority_ceiling( attribute_set ) )             
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
  108f9c:	89 df                	mov    %ebx,%edi                      
  108f9e:	83 e7 30             	and    $0x30,%edi                     
  108fa1:	74 0f                	je     108fb2 <rtems_semaphore_create+0x72>
  108fa3:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  108fa8:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)                 
  108fac:	0f 87 28 01 00 00    	ja     1090da <rtems_semaphore_create+0x19a>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  108fb2:	a1 98 d7 11 00       	mov    0x11d798,%eax                  
  108fb7:	40                   	inc    %eax                           
  108fb8:	a3 98 d7 11 00       	mov    %eax,0x11d798                  
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
  108fbd:	83 ec 0c             	sub    $0xc,%esp                      
  108fc0:	68 e0 d6 11 00       	push   $0x11d6e0                      
  108fc5:	e8 be 12 00 00       	call   10a288 <_Objects_Allocate>     
  108fca:	89 c6                	mov    %eax,%esi                      
                                                                      
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_semaphore = _Semaphore_Allocate();                              
                                                                      
  if ( !the_semaphore ) {                                             
  108fcc:	83 c4 10             	add    $0x10,%esp                     
  108fcf:	85 c0                	test   %eax,%eax                      
  108fd1:	75 0f                	jne    108fe2 <rtems_semaphore_create+0xa2>
    _Thread_Enable_dispatch();                                        
  108fd3:	e8 b4 1e 00 00       	call   10ae8c <_Thread_Enable_dispatch>
  108fd8:	b8 05 00 00 00       	mov    $0x5,%eax                      
  108fdd:	e9 f8 00 00 00       	jmp    1090da <rtems_semaphore_create+0x19a>
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_semaphore->attribute_set = attribute_set;                       
  108fe2:	89 58 10             	mov    %ebx,0x10(%eax)                
   *  If it is not a counting semaphore, then it is either a          
   *  simple binary semaphore or a more powerful mutex style binary   
   *  semaphore.                                                      
   */                                                                 
                                                                      
  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {        
  108fe5:	85 ff                	test   %edi,%edi                      
  108fe7:	0f 84 92 00 00 00    	je     10907f <rtems_semaphore_create+0x13f>
    CORE_mutex_Status mutex_status;                                   
                                                                      
    if ( _Attributes_Is_inherit_priority( attribute_set ) )           
  108fed:	f6 c3 40             	test   $0x40,%bl                      
  108ff0:	74 09                	je     108ffb <rtems_semaphore_create+0xbb>
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
  108ff2:	c7 45 e4 02 00 00 00 	movl   $0x2,-0x1c(%ebp)               
  108ff9:	eb 18                	jmp    109013 <rtems_semaphore_create+0xd3>
    else if ( _Attributes_Is_priority_ceiling( attribute_set ) )      
  108ffb:	84 db                	test   %bl,%bl                        
  108ffd:	79 09                	jns    109008 <rtems_semaphore_create+0xc8>
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
  108fff:	c7 45 e4 03 00 00 00 	movl   $0x3,-0x1c(%ebp)               
  109006:	eb 0b                	jmp    109013 <rtems_semaphore_create+0xd3>
    else if ( _Attributes_Is_priority( attribute_set ) )              
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
  109008:	31 c0                	xor    %eax,%eax                      
  10900a:	f6 c3 04             	test   $0x4,%bl                       
  10900d:	0f 95 c0             	setne  %al                            
  109010:	89 45 e4             	mov    %eax,-0x1c(%ebp)               
    else                                                              
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;  
                                                                      
                                                                      
    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {         
  109013:	83 ff 10             	cmp    $0x10,%edi                     
  109016:	75 1a                	jne    109032 <rtems_semaphore_create+0xf2>
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
  109018:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               
                                                                      
      switch ( the_mutex_attributes.discipline ) {                    
  10901f:	8b 45 e4             	mov    -0x1c(%ebp),%eax               
  109022:	83 f8 01             	cmp    $0x1,%eax                      
  109025:	76 12                	jbe    109039 <rtems_semaphore_create+0xf9>
  109027:	83 f8 03             	cmp    $0x3,%eax                      
  10902a:	77 11                	ja     10903d <rtems_semaphore_create+0xfd><== NEVER TAKEN
        case CORE_MUTEX_DISCIPLINES_PRIORITY:                         
          the_mutex_attributes.only_owner_release = FALSE;            
          break;                                                      
        case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:                 
        case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:                 
          the_mutex_attributes.only_owner_release = TRUE;             
  10902c:	c6 45 e0 01          	movb   $0x1,-0x20(%ebp)               
  109030:	eb 0b                	jmp    10903d <rtems_semaphore_create+0xfd>
          break;                                                      
      }                                                               
    } else {                                                          
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
  109032:	c7 45 dc 02 00 00 00 	movl   $0x2,-0x24(%ebp)               
      the_mutex_attributes.only_owner_release = FALSE;                
  109039:	c6 45 e0 00          	movb   $0x0,-0x20(%ebp)               
    }                                                                 
                                                                      
    the_mutex_attributes.priority_ceiling = priority_ceiling;         
  10903d:	8b 45 14             	mov    0x14(%ebp),%eax                
  109040:	89 45 e8             	mov    %eax,-0x18(%ebp)               
                                                                      
    mutex_status = _CORE_mutex_Initialize(                            
  109043:	51                   	push   %ecx                           
  109044:	31 c0                	xor    %eax,%eax                      
  109046:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)                 
  10904a:	0f 94 c0             	sete   %al                            
  10904d:	50                   	push   %eax                           
  10904e:	8d 45 dc             	lea    -0x24(%ebp),%eax               
  109051:	50                   	push   %eax                           
  109052:	8d 46 14             	lea    0x14(%esi),%eax                
  109055:	50                   	push   %eax                           
  109056:	e8 ed 0b 00 00       	call   109c48 <_CORE_mutex_Initialize>
      &the_semaphore->Core_control.mutex,                             
      &the_mutex_attributes,                                          
      (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED          
     );                                                               
                                                                      
     if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {      
  10905b:	83 c4 10             	add    $0x10,%esp                     
  10905e:	83 f8 06             	cmp    $0x6,%eax                      
  109061:	75 50                	jne    1090b3 <rtems_semaphore_create+0x173><== ALWAYS TAKEN
 *  @param[in] starting_address is the starting address of the memory for
 *         the heap                                                   
 *  @param[in] size is the size in bytes of the memory area for the heap
 *  @param[in] page_size is the size in bytes of the allocation unit  
 *                                                                    
 *  @return This method returns the maximum memory available.  If     
  109063:	52                   	push   %edx                           <== NOT EXECUTED
  109064:	52                   	push   %edx                           <== NOT EXECUTED
  109065:	56                   	push   %esi                           <== NOT EXECUTED
  109066:	68 e0 d6 11 00       	push   $0x11d6e0                      <== NOT EXECUTED
  10906b:	e8 28 15 00 00       	call   10a598 <_Objects_Free>         <== NOT EXECUTED
       _Semaphore_Free( the_semaphore );                              
       _Thread_Enable_dispatch();                                     
  109070:	e8 17 1e 00 00       	call   10ae8c <_Thread_Enable_dispatch><== NOT EXECUTED
  109075:	b8 13 00 00 00       	mov    $0x13,%eax                     <== NOT EXECUTED
  10907a:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10907d:	eb 5b                	jmp    1090da <rtems_semaphore_create+0x19a><== NOT EXECUTED
       return RTEMS_INVALID_PRIORITY;                                 
     }                                                                
  } else {                                                            
    if ( _Attributes_Is_priority( attribute_set ) )                   
      the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
  10907f:	31 c0                	xor    %eax,%eax                      
  109081:	f6 c3 04             	test   $0x4,%bl                       
  109084:	0f 95 c0             	setne  %al                            
  109087:	89 45 f0             	mov    %eax,-0x10(%ebp)               
                                                                      
    /*                                                                
     *  This effectively disables limit checking.                     
     */                                                               
                                                                      
    the_semaphore_attributes.maximum_count = 0xFFFFFFFF;              
  10908a:	c7 45 ec ff ff ff ff 	movl   $0xffffffff,-0x14(%ebp)        
                                                                      
    /*                                                                
     *  The following are just to make Purify happy.                  
     */                                                               
                                                                      
    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
  109091:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;         
  109098:	c7 45 e8 00 00 00 00 	movl   $0x0,-0x18(%ebp)               
                                                                      
    _CORE_semaphore_Initialize(                                       
  10909f:	50                   	push   %eax                           
  1090a0:	ff 75 0c             	pushl  0xc(%ebp)                      
  1090a3:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  1090a6:	50                   	push   %eax                           
  1090a7:	8d 46 14             	lea    0x14(%esi),%eax                
  1090aa:	50                   	push   %eax                           
  1090ab:	e8 14 0e 00 00       	call   109ec4 <_CORE_semaphore_Initialize>
  1090b0:	83 c4 10             	add    $0x10,%esp                     
  1090b3:	8b 4e 08             	mov    0x8(%esi),%ecx                 
  1090b6:	0f b7 d1             	movzwl %cx,%edx                       
  1090b9:	a1 fc d6 11 00       	mov    0x11d6fc,%eax                  
  1090be:	89 34 90             	mov    %esi,(%eax,%edx,4)             
  1090c1:	8b 45 08             	mov    0x8(%ebp),%eax                 
  1090c4:	89 46 0c             	mov    %eax,0xc(%esi)                 
    &_Semaphore_Information,                                          
    &the_semaphore->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_semaphore->Object.id;                                     
  1090c7:	8b 45 18             	mov    0x18(%ebp),%eax                
  1090ca:	89 08                	mov    %ecx,(%eax)                    
      the_semaphore->Object.id,                                       
      name,                                                           
      0                          /* Not used */                       
    );                                                                
#endif                                                                
  _Thread_Enable_dispatch();                                          
  1090cc:	e8 bb 1d 00 00       	call   10ae8c <_Thread_Enable_dispatch>
  1090d1:	31 c0                	xor    %eax,%eax                      
  1090d3:	eb 05                	jmp    1090da <rtems_semaphore_create+0x19a>
  return RTEMS_SUCCESSFUL;                                            
  1090d5:	b8 0b 00 00 00       	mov    $0xb,%eax                      
}                                                                     
  1090da:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1090dd:	5b                   	pop    %ebx                           
  1090de:	5e                   	pop    %esi                           
  1090df:	5f                   	pop    %edi                           
  1090e0:	c9                   	leave                                 
  1090e1:	c3                   	ret                                   
                                                                      

001121dc <rtems_semaphore_flush>: #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) {
  1121dc:	55                   	push   %ebp                           
  1121dd:	89 e5                	mov    %esp,%ebp                      
  1121df:	83 ec 1c             	sub    $0x1c,%esp                     
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] starting_address is the starting address of the memory 
 *         to add to the heap                                         
  1121e2:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  1121e5:	50                   	push   %eax                           
  1121e6:	ff 75 08             	pushl  0x8(%ebp)                      
  1121e9:	68 2c 40 13 00       	push   $0x13402c                      
  1121ee:	e8 05 2e 00 00       	call   114ff8 <_Objects_Get>          
  1121f3:	89 c2                	mov    %eax,%edx                      
  register Semaphore_Control *the_semaphore;                          
  Objects_Locations           location;                               
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
  1121f5:	83 c4 10             	add    $0x10,%esp                     
  1121f8:	b8 04 00 00 00       	mov    $0x4,%eax                      
  1121fd:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  112201:	75 2b                	jne    11222e <rtems_semaphore_flush+0x52>
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
  112203:	f6 42 10 30          	testb  $0x30,0x10(%edx)               
  112207:	8d 42 14             	lea    0x14(%edx),%eax                
  11220a:	74 0d                	je     112219 <rtems_semaphore_flush+0x3d><== NEVER TAKEN
        _CORE_mutex_Flush(                                            
  11220c:	51                   	push   %ecx                           
  11220d:	6a 01                	push   $0x1                           
  11220f:	6a 00                	push   $0x0                           
  112211:	50                   	push   %eax                           
  112212:	e8 e9 1c 00 00       	call   113f00 <_CORE_mutex_Flush>     
  112217:	eb 0b                	jmp    112224 <rtems_semaphore_flush+0x48>
          &the_semaphore->Core_control.mutex,                         
          SEND_OBJECT_WAS_DELETED,                                    
          CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT                        
        );                                                            
      } else {                                                        
        _CORE_semaphore_Flush(                                        
  112219:	52                   	push   %edx                           <== NOT EXECUTED
  11221a:	6a 01                	push   $0x1                           <== NOT EXECUTED
  11221c:	6a 00                	push   $0x0                           <== NOT EXECUTED
  11221e:	50                   	push   %eax                           <== NOT EXECUTED
  11221f:	e8 58 1f 00 00       	call   11417c <_CORE_semaphore_Flush> <== NOT EXECUTED
  112224:	83 c4 10             	add    $0x10,%esp                     
          &the_semaphore->Core_control.semaphore,                     
          SEND_OBJECT_WAS_DELETED,                                    
          CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT                    
        );                                                            
      }                                                               
      _Thread_Enable_dispatch();                                      
  112227:	e8 8c 35 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  11222c:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  11222e:	c9                   	leave                                 
  11222f:	c3                   	ret                                   
                                                                      

0011582c <rtems_shutdown_executive>: */ void rtems_shutdown_executive( uint32_t result ) {
  11582c:	55                   	push   %ebp                           
  11582d:	89 e5                	mov    %esp,%ebp                      
  11582f:	83 ec 28             	sub    $0x28,%esp                     
  if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {             
  115832:	83 3d 38 d9 11 00 04 	cmpl   $0x4,0x11d938                  
  115839:	74 1d                	je     115858 <rtems_shutdown_executive+0x2c><== NEVER TAKEN
                                                                      
RTEMS_INLINE_ROUTINE void _System_state_Set (                         
  System_state_Codes state                                            
)                                                                     
{                                                                     
  _System_state_Current = state;                                      
  11583b:	c7 05 38 d9 11 00 04 	movl   $0x4,0x11d938                  
  115842:	00 00 00                                                    
  #endif                                                              
}                                                                     
                                                                      
/**                                                                   
 *  This routine sets the current system state to that specified by   
 *  the called.                                                       
  115845:	50                   	push   %eax                           
  115846:	50                   	push   %eax                           
  115847:	68 80 d7 11 00       	push   $0x11d780                      
  11584c:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  11584f:	50                   	push   %eax                           
  115850:	e8 6b 66 ff ff       	call   10bec0 <_CPU_Context_switch>   
  115855:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    _System_state_Set( SYSTEM_STATE_SHUTDOWN );                       
    _Thread_Stop_multitasking();                                      
  }                                                                   
}                                                                     
  115858:	c9                   	leave                                 <== NOT EXECUTED
  115859:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00109ef0 <rtems_signal_catch>: rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) {
  109ef0:	55                   	push   %ebp                           
  109ef1:	89 e5                	mov    %esp,%ebp                      
  109ef3:	83 ec 08             	sub    $0x8,%esp                      
  109ef6:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  RTEMS_API_Control  *api;                                            
  ASR_Information    *asr;                                            
                                                                      
/* XXX normalize mode */                                              
  executing = _Thread_Executing;                                      
  api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ];
  109ef9:	a1 c4 12 12 00       	mov    0x1212c4,%eax                  
  109efe:	8b 90 f4 00 00 00    	mov    0xf4(%eax),%edx                
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109f04:	a1 04 12 12 00       	mov    0x121204,%eax                  
  109f09:	40                   	inc    %eax                           
  109f0a:	a3 04 12 12 00       	mov    %eax,0x121204                  
  asr = &api->Signal;                                                 
                                                                      
  _Thread_Disable_dispatch(); /* cannot reschedule while */           
                              /*   the thread is inconsistent */      
                                                                      
  if ( !_ASR_Is_null_handler( asr_handler ) ) {                       
  109f0f:	85 c9                	test   %ecx,%ecx                      
  109f11:	74 0b                	je     109f1e <rtems_signal_catch+0x2e><== NEVER TAKEN
    asr->mode_set = mode_set;                                         
  109f13:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  109f16:	89 42 10             	mov    %eax,0x10(%edx)                
    asr->handler = asr_handler;                                       
  109f19:	89 4a 0c             	mov    %ecx,0xc(%edx)                 
  109f1c:	eb 27                	jmp    109f45 <rtems_signal_catch+0x55>
#endif                                                                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
  109f1e:	c6 42 08 01          	movb   $0x1,0x8(%edx)                 <== NOT EXECUTED
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
  109f22:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)                 <== NOT EXECUTED
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
  109f29:	c7 42 10 00 00 00 00 	movl   $0x0,0x10(%edx)                <== NOT EXECUTED
 *                                                                    
  109f30:	c7 42 14 00 00 00 00 	movl   $0x0,0x14(%edx)                <== NOT EXECUTED
 *  @param[in] the_heap is the heap to operate upon                   
  109f37:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)                <== NOT EXECUTED
 *  @param[in] starting_address is the starting address of the memory for
  109f3e:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)                <== NOT EXECUTED
  }                                                                   
  else                                                                
    _ASR_Initialize( asr );                                           
  _Thread_Enable_dispatch();                                          
  109f45:	e8 8e 1e 00 00       	call   10bdd8 <_Thread_Enable_dispatch>
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  109f4a:	31 c0                	xor    %eax,%eax                      
  109f4c:	c9                   	leave                                 
  109f4d:	c3                   	ret                                   
                                                                      

001123cc <rtems_signal_send>: rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) {
  1123cc:	55                   	push   %ebp                           
  1123cd:	89 e5                	mov    %esp,%ebp                      
  1123cf:	53                   	push   %ebx                           
  1123d0:	83 ec 14             	sub    $0x14,%esp                     
  1123d3:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
  1123d6:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  1123db:	85 db                	test   %ebx,%ebx                      
  1123dd:	74 71                	je     112450 <rtems_signal_send+0x84><== NEVER TAKEN
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  1123df:	50                   	push   %eax                           
  1123e0:	50                   	push   %eax                           
  1123e1:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  1123e4:	50                   	push   %eax                           
  1123e5:	ff 75 08             	pushl  0x8(%ebp)                      
  1123e8:	e8 eb 33 00 00       	call   1157d8 <_Thread_Get>           
  1123ed:	89 c1                	mov    %eax,%ecx                      
  switch ( location ) {                                               
  1123ef:	83 c4 10             	add    $0x10,%esp                     
  1123f2:	b8 04 00 00 00       	mov    $0x4,%eax                      
  1123f7:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  1123fb:	75 53                	jne    112450 <rtems_signal_send+0x84>
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
  1123fd:	8b 91 f4 00 00 00    	mov    0xf4(%ecx),%edx                
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
  112403:	83 7a 0c 00          	cmpl   $0x0,0xc(%edx)                 
  112407:	74 3d                	je     112446 <rtems_signal_send+0x7a>
        if ( asr->is_enabled ) {                                      
  112409:	80 7a 08 00          	cmpb   $0x0,0x8(%edx)                 
  11240d:	74 26                	je     112435 <rtems_signal_send+0x69><== NEVER TAKEN
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  11240f:	9c                   	pushf                                 
  112410:	fa                   	cli                                   
  112411:	58                   	pop    %eax                           
);                                                                    
  112412:	09 5a 14             	or     %ebx,0x14(%edx)                
                                                                      
  112415:	50                   	push   %eax                           
  112416:	9d                   	popf                                  
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          the_thread->do_post_task_switch_extension = true;           
  112417:	c6 41 75 01          	movb   $0x1,0x75(%ecx)                
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
  11241b:	a1 d4 41 13 00       	mov    0x1341d4,%eax                  
  112420:	85 c0                	test   %eax,%eax                      
  112422:	74 19                	je     11243d <rtems_signal_send+0x71>
  112424:	3b 0d f8 41 13 00    	cmp    0x1341f8,%ecx                  
  11242a:	75 11                	jne    11243d <rtems_signal_send+0x71><== NEVER TAKEN
            _ISR_Signals_to_thread_executing = TRUE;                  
  11242c:	c6 05 8c 42 13 00 01 	movb   $0x1,0x13428c                  
  112433:	eb 08                	jmp    11243d <rtems_signal_send+0x71>
 *  @return NULL if unsuccessful and a pointer to the block if successful
 */                                                                   
void *_Protected_heap_Allocate_aligned(                               
  Heap_Control *the_heap,                                             
  size_t        size,                                                 
  uint32_t      alignment                                             
  112435:	9c                   	pushf                                 <== NOT EXECUTED
  112436:	fa                   	cli                                   <== NOT EXECUTED
  112437:	58                   	pop    %eax                           <== NOT EXECUTED
);                                                                    
  112438:	09 5a 18             	or     %ebx,0x18(%edx)                <== NOT EXECUTED
                                                                      
  11243b:	50                   	push   %eax                           <== NOT EXECUTED
  11243c:	9d                   	popf                                  <== NOT EXECUTED
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
  11243d:	e8 76 33 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112442:	31 c0                	xor    %eax,%eax                      
  112444:	eb 0a                	jmp    112450 <rtems_signal_send+0x84>
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
  112446:	e8 6d 33 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  11244b:	b8 0b 00 00 00       	mov    $0xb,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  112450:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  112453:	c9                   	leave                                 
  112454:	c3                   	ret                                   
                                                                      

001066f8 <rtems_stack_checker_begin_extension>: * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) {
  1066f8:	55                   	push   %ebp                           
  1066f9:	89 e5                	mov    %esp,%ebp                      
  1066fb:	57                   	push   %edi                           
  1066fc:	56                   	push   %esi                           
  1066fd:	8b 45 08             	mov    0x8(%ebp),%eax                 
  Stack_check_Control  *the_pattern;                                  
                                                                      
  if ( the_thread->Object.id == 0 )        /* skip system tasks */    
  106700:	83 78 08 00          	cmpl   $0x0,0x8(%eax)                 
  106704:	74 15                	je     10671b <rtems_stack_checker_begin_extension+0x23><== NEVER TAKEN
    return;                                                           
                                                                      
  the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
                                                                      
  *the_pattern = Stack_check_Pattern;                                 
  106706:	8b 80 c8 00 00 00    	mov    0xc8(%eax),%eax                
  10670c:	8d 78 08             	lea    0x8(%eax),%edi                 
  10670f:	be 08 10 12 00       	mov    $0x121008,%esi                 
  106714:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  106719:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
}                                                                     
  10671b:	5e                   	pop    %esi                           
  10671c:	5f                   	pop    %edi                           
  10671d:	c9                   	leave                                 
  10671e:	c3                   	ret                                   
                                                                      

00106a80 <rtems_stack_checker_create_extension>: */ bool rtems_stack_checker_create_extension( Thread_Control *running, Thread_Control *the_thread ) {
  106a80:	55                   	push   %ebp                           
  106a81:	89 e5                	mov    %esp,%ebp                      
  106a83:	57                   	push   %edi                           
  106a84:	83 ec 04             	sub    $0x4,%esp                      
  106a87:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  Stack_check_Initialize();                                           
  106a8a:	e8 84 ff ff ff       	call   106a13 <Stack_check_Initialize>
                                                                      
  if (the_thread)                                                     
  106a8f:	85 ff                	test   %edi,%edi                      
  106a91:	74 10                	je     106aa3 <rtems_stack_checker_create_extension+0x23><== NEVER TAKEN
    Stack_check_Dope_stack(&the_thread->Start.Initial_stack);         
  106a93:	8b 8f c4 00 00 00    	mov    0xc4(%edi),%ecx                
  106a99:	8b bf c8 00 00 00    	mov    0xc8(%edi),%edi                
  106a9f:	b0 a5                	mov    $0xa5,%al                      
  106aa1:	f3 aa                	rep stos %al,%es:(%edi)               
                                                                      
  return true;                                                        
}                                                                     
  106aa3:	b0 01                	mov    $0x1,%al                       
  106aa5:	5a                   	pop    %edx                           
  106aa6:	5f                   	pop    %edi                           
  106aa7:	c9                   	leave                                 
  106aa8:	c3                   	ret                                   
                                                                      

00106941 <rtems_stack_checker_is_blown>: /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) {
  106941:	55                   	push   %ebp                           <== NOT EXECUTED
  106942:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  106944:	53                   	push   %ebx                           <== NOT EXECUTED
  106945:	83 ec 04             	sub    $0x4,%esp                      <== NOT EXECUTED
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
  106948:	a1 44 12 12 00       	mov    0x121244,%eax                  <== NOT EXECUTED
)                                                                     
{                                                                     
  void *sp = __builtin_frame_address(0);                              
                                                                      
  #if defined(__GNUC__)                                               
    if ( sp < the_stack->area ) {                                     
  10694d:	8b 90 c8 00 00 00    	mov    0xc8(%eax),%edx                <== NOT EXECUTED
  106953:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  106955:	39 d5                	cmp    %edx,%ebp                      <== NOT EXECUTED
  106957:	72 0e                	jb     106967 <rtems_stack_checker_is_blown+0x26><== NOT EXECUTED
  106959:	8b 88 c4 00 00 00    	mov    0xc4(%eax),%ecx                <== NOT EXECUTED
  10695f:	8d 04 0a             	lea    (%edx,%ecx,1),%eax             <== NOT EXECUTED
  106962:	39 c5                	cmp    %eax,%ebp                      <== NOT EXECUTED
  106964:	0f 96 c3             	setbe  %bl                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * The stack checker must be initialized before the pattern is there
   * to check.                                                        
   */                                                                 
  if ( Stack_check_Initialized ) {                                    
  106967:	b0 01                	mov    $0x1,%al                       <== NOT EXECUTED
  106969:	83 3d ec 0d 12 00 00 	cmpl   $0x0,0x120dec                  <== NOT EXECUTED
  106970:	74 19                	je     10698b <rtems_stack_checker_is_blown+0x4a><== NOT EXECUTED
    pattern_ok = (!memcmp(                                            
  106972:	51                   	push   %ecx                           <== NOT EXECUTED
  106973:	6a 10                	push   $0x10                          <== NOT EXECUTED
  106975:	68 08 10 12 00       	push   $0x121008                      <== NOT EXECUTED
  10697a:	8d 42 08             	lea    0x8(%edx),%eax                 <== NOT EXECUTED
  10697d:	50                   	push   %eax                           <== NOT EXECUTED
  10697e:	e8 c5 9e 00 00       	call   110848 <memcmp>                <== NOT EXECUTED
  106983:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106986:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  106988:	0f 94 c0             	sete   %al                            <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * The Stack Pointer and the Pattern Area are OK so return false.   
   */                                                                 
  if ( sp_ok && pattern_ok )                                          
  10698b:	84 db                	test   %bl,%bl                        <== NOT EXECUTED
  10698d:	74 06                	je     106995 <rtems_stack_checker_is_blown+0x54><== NOT EXECUTED
  10698f:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  106991:	84 c0                	test   %al,%al                        <== NOT EXECUTED
  106993:	75 16                	jne    1069ab <rtems_stack_checker_is_blown+0x6a><== NOT EXECUTED
    return false;                                                     
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  Stack_check_report_blown_task( _Thread_Executing, pattern_ok );     
  106995:	52                   	push   %edx                           <== NOT EXECUTED
  106996:	52                   	push   %edx                           <== NOT EXECUTED
  106997:	0f b6 c0             	movzbl %al,%eax                       <== NOT EXECUTED
  10699a:	50                   	push   %eax                           <== NOT EXECUTED
  10699b:	ff 35 44 12 12 00    	pushl  0x121244                       <== NOT EXECUTED
  1069a1:	e8 34 ff ff ff       	call   1068da <Stack_check_report_blown_task><== NOT EXECUTED
  1069a6:	b2 01                	mov    $0x1,%dl                       <== NOT EXECUTED
  1069a8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  return true;                                                        
}                                                                     
  1069ab:	88 d0                	mov    %dl,%al                        <== NOT EXECUTED
  1069ad:	8b 5d fc             	mov    -0x4(%ebp),%ebx                <== NOT EXECUTED
  1069b0:	c9                   	leave                                 <== NOT EXECUTED
  1069b1:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001068c3 <rtems_stack_checker_report_usage>: void rtems_stack_checker_report_usage( void ) {
  1068c3:	55                   	push   %ebp                           <== NOT EXECUTED
  1068c4:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1068c6:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
  rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
  1068c9:	68 d0 7b 10 00       	push   $0x107bd0                      <== NOT EXECUTED
  1068ce:	6a 00                	push   $0x0                           <== NOT EXECUTED
  1068d0:	e8 8d ff ff ff       	call   106862 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
  1068d5:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
}                                                                     
  1068d8:	c9                   	leave                                 <== NOT EXECUTED
  1068d9:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00106862 <rtems_stack_checker_report_usage_with_plugin>: void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) {
  106862:	55                   	push   %ebp                           <== NOT EXECUTED
  106863:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  106865:	56                   	push   %esi                           <== NOT EXECUTED
  106866:	53                   	push   %ebx                           <== NOT EXECUTED
  106867:	8b 5d 08             	mov    0x8(%ebp),%ebx                 <== NOT EXECUTED
  10686a:	8b 75 0c             	mov    0xc(%ebp),%esi                 <== NOT EXECUTED
  print_context = context;                                            
  10686d:	89 1d f0 0d 12 00    	mov    %ebx,0x120df0                  <== NOT EXECUTED
  print_handler = print;                                              
  106873:	89 35 f4 0d 12 00    	mov    %esi,0x120df4                  <== NOT EXECUTED
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
  106879:	51                   	push   %ecx                           <== NOT EXECUTED
  10687a:	51                   	push   %ecx                           <== NOT EXECUTED
  10687b:	68 25 9a 11 00       	push   $0x119a25                      <== NOT EXECUTED
  106880:	53                   	push   %ebx                           <== NOT EXECUTED
  106881:	ff d6                	call   *%esi                          <== NOT EXECUTED
  (*print)( context,                                                  
  106883:	58                   	pop    %eax                           <== NOT EXECUTED
  106884:	5a                   	pop    %edx                           <== NOT EXECUTED
  106885:	68 3c 9a 11 00       	push   $0x119a3c                      <== NOT EXECUTED
  10688a:	53                   	push   %ebx                           <== NOT EXECUTED
  10688b:	ff d6                	call   *%esi                          <== NOT EXECUTED
"    ID      NAME    LOW          HIGH     CURRENT     AVAILABLE     USED\n"
  );                                                                  
                                                                      
  /* iterate over all threads and dump the usage */                   
  rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );   
  10688d:	c7 04 24 4a 67 10 00 	movl   $0x10674a,(%esp)               <== NOT EXECUTED
  106894:	e8 43 47 00 00       	call   10afdc <rtems_iterate_over_all_threads><== NOT EXECUTED
                                                                      
  /* dump interrupt stack info if any */                              
  Stack_check_Dump_threads_usage((Thread_Control *) -1);              
  106899:	c7 04 24 ff ff ff ff 	movl   $0xffffffff,(%esp)             <== NOT EXECUTED
  1068a0:	e8 a5 fe ff ff       	call   10674a <Stack_check_Dump_threads_usage><== NOT EXECUTED
                                                                      
  print_context = NULL;                                               
  1068a5:	c7 05 f0 0d 12 00 00 	movl   $0x0,0x120df0                  <== NOT EXECUTED
  1068ac:	00 00 00                                                    
  print_handler = NULL;                                               
  1068af:	c7 05 f4 0d 12 00 00 	movl   $0x0,0x120df4                  <== NOT EXECUTED
  1068b6:	00 00 00                                                    
  1068b9:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
}                                                                     
  1068bc:	8d 65 f8             	lea    -0x8(%ebp),%esp                <== NOT EXECUTED
  1068bf:	5b                   	pop    %ebx                           <== NOT EXECUTED
  1068c0:	5e                   	pop    %esi                           <== NOT EXECUTED
  1068c1:	c9                   	leave                                 <== NOT EXECUTED
  1068c2:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001069b2 <rtems_stack_checker_switch_extension>: */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) {
  1069b2:	55                   	push   %ebp                           
  1069b3:	89 e5                	mov    %esp,%ebp                      
  1069b5:	56                   	push   %esi                           
  1069b6:	53                   	push   %ebx                           
  1069b7:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  Stack_Control *the_stack = &running->Start.Initial_stack;           
  void          *pattern;                                             
  bool        sp_ok;                                                  
  bool        pattern_ok = true;                                      
                                                                      
  pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
  1069ba:	8b 93 c8 00 00 00    	mov    0xc8(%ebx),%edx                
)                                                                     
{                                                                     
  void *sp = __builtin_frame_address(0);                              
                                                                      
  #if defined(__GNUC__)                                               
    if ( sp < the_stack->area ) {                                     
  1069c0:	31 f6                	xor    %esi,%esi                      
  1069c2:	39 d5                	cmp    %edx,%ebp                      
  1069c4:	72 0f                	jb     1069d5 <rtems_stack_checker_switch_extension+0x23><== NEVER TAKEN
  1069c6:	89 d0                	mov    %edx,%eax                      
  1069c8:	03 83 c4 00 00 00    	add    0xc4(%ebx),%eax                
  1069ce:	39 c5                	cmp    %eax,%ebp                      
  1069d0:	0f 96 c0             	setbe  %al                            
  1069d3:	89 c6                	mov    %eax,%esi                      
  /*                                                                  
   *  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,                                     
  1069d5:	50                   	push   %eax                           
  1069d6:	6a 10                	push   $0x10                          
  1069d8:	68 08 10 12 00       	push   $0x121008                      
  1069dd:	8d 42 08             	lea    0x8(%edx),%eax                 
  1069e0:	50                   	push   %eax                           
  1069e1:	e8 62 9e 00 00       	call   110848 <memcmp>                
  1069e6:	83 c4 10             	add    $0x10,%esp                     
  1069e9:	85 c0                	test   %eax,%eax                      
  1069eb:	0f 94 c0             	sete   %al                            
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
  1069ee:	89 f2                	mov    %esi,%edx                      
  1069f0:	84 d2                	test   %dl,%dl                        
  1069f2:	74 04                	je     1069f8 <rtems_stack_checker_switch_extension+0x46><== NEVER TAKEN
  1069f4:	84 c0                	test   %al,%al                        
  1069f6:	75 14                	jne    106a0c <rtems_stack_checker_switch_extension+0x5a>
    Stack_check_report_blown_task( running, pattern_ok );             
  1069f8:	0f b6 c0             	movzbl %al,%eax                       
  1069fb:	89 45 0c             	mov    %eax,0xc(%ebp)                 
  1069fe:	89 5d 08             	mov    %ebx,0x8(%ebp)                 
  }                                                                   
}                                                                     
  106a01:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  106a04:	5b                   	pop    %ebx                           
  106a05:	5e                   	pop    %esi                           
  106a06:	c9                   	leave                                 
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
    Stack_check_report_blown_task( running, pattern_ok );             
  106a07:	e9 ce fe ff ff       	jmp    1068da <Stack_check_report_blown_task>
  }                                                                   
}                                                                     
  106a0c:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  106a0f:	5b                   	pop    %ebx                           
  106a10:	5e                   	pop    %esi                           
  106a11:	c9                   	leave                                 
  106a12:	c3                   	ret                                   
                                                                      

00106eac <rtems_status_text>: const char * rtems_status_text( rtems_status_code status ) {
  106eac:	55                   	push   %ebp                           <== NOT EXECUTED
  106ead:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  106eaf:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
    return rtems_assoc_name_by_local(rtems_status_assoc, status);     
  106eb2:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  106eb5:	68 18 a5 11 00       	push   $0x11a518                      <== NOT EXECUTED
  106eba:	e8 c9 73 00 00       	call   10e288 <rtems_assoc_name_by_local><== NOT EXECUTED
}                                                                     
  106ebf:	c9                   	leave                                 <== NOT EXECUTED
  106ec0:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001092ec <rtems_task_create>: size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) {
  1092ec:	55                   	push   %ebp                           
  1092ed:	89 e5                	mov    %esp,%ebp                      
  1092ef:	57                   	push   %edi                           
  1092f0:	56                   	push   %esi                           
  1092f1:	53                   	push   %ebx                           
  1092f2:	83 ec 0c             	sub    $0xc,%esp                      
  1092f5:	8b 5d 14             	mov    0x14(%ebp),%ebx                
  1092f8:	8b 7d 18             	mov    0x18(%ebp),%edi                
  Priority_Control         core_priority;                             
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
                                                                      
  if ( !id )                                                          
  1092fb:	b8 09 00 00 00       	mov    $0x9,%eax                      
  109300:	83 7d 1c 00          	cmpl   $0x0,0x1c(%ebp)                
  109304:	0f 84 08 01 00 00    	je     109412 <rtems_task_create+0x126><== NEVER TAKEN
   return RTEMS_INVALID_ADDRESS;                                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  10930a:	b8 03 00 00 00       	mov    $0x3,%eax                      
  10930f:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  109313:	0f 84 f9 00 00 00    	je     109412 <rtems_task_create+0x126>
                                                                      
  /*                                                                  
   *  Validate the RTEMS API priority and convert it to the core priority range.
   */                                                                 
                                                                      
  if ( !_Attributes_Is_system_task( the_attribute_set ) ) {           
  109319:	66 85 ff             	test   %di,%di                        
  10931c:	78 24                	js     109342 <rtems_task_create+0x56>
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size                                                  
);                                                                    
                                                                      
  10931e:	31 d2                	xor    %edx,%edx                      
  109320:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  109324:	74 0f                	je     109335 <rtems_task_create+0x49>
  109326:	0f b6 05 84 93 11 00 	movzbl 0x119384,%eax                  
  10932d:	31 d2                	xor    %edx,%edx                      
  10932f:	39 45 0c             	cmp    %eax,0xc(%ebp)                 
  109332:	0f 96 c2             	setbe  %dl                            
    if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )        
  109335:	b8 13 00 00 00       	mov    $0x13,%eax                     
  10933a:	85 d2                	test   %edx,%edx                      
  10933c:	0f 84 d0 00 00 00    	je     109412 <rtems_task_create+0x126>
   */                                                                 
                                                                      
  /*                                                                  
   *  Lock the allocator mutex for protection                         
   */                                                                 
  _RTEMS_Lock_allocator();                                            
  109342:	83 ec 0c             	sub    $0xc,%esp                      
  109345:	ff 35 50 d8 11 00    	pushl  0x11d850                       
  10934b:	e8 28 07 00 00       	call   109a78 <_API_Mutex_Lock>       
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
  109350:	c7 04 24 20 d7 11 00 	movl   $0x11d720,(%esp)               
  109357:	e8 2c 0f 00 00       	call   10a288 <_Objects_Allocate>     
  10935c:	89 c6                	mov    %eax,%esi                      
   *         the event of an error.                                   
   */                                                                 
                                                                      
  the_thread = _RTEMS_tasks_Allocate();                               
                                                                      
  if ( !the_thread ) {                                                
  10935e:	83 c4 10             	add    $0x10,%esp                     
  109361:	85 c0                	test   %eax,%eax                      
  109363:	75 18                	jne    10937d <rtems_task_create+0x91>
    _RTEMS_Unlock_allocator();                                        
  109365:	83 ec 0c             	sub    $0xc,%esp                      
  109368:	ff 35 50 d8 11 00    	pushl  0x11d850                       
  10936e:	e8 4d 07 00 00       	call   109ac0 <_API_Mutex_Unlock>     
  109373:	b8 05 00 00 00       	mov    $0x5,%eax                      
  109378:	e9 92 00 00 00       	jmp    10940f <rtems_task_create+0x123>
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
                                                                      
  status = _Thread_Initialize(                                        
  10937d:	50                   	push   %eax                           
  10937e:	ff 75 08             	pushl  0x8(%ebp)                      
  109381:	89 d8                	mov    %ebx,%eax                      
  109383:	83 e0 01             	and    $0x1,%eax                      
  109386:	50                   	push   %eax                           
  109387:	6a 00                	push   $0x0                           
  109389:	89 d8                	mov    %ebx,%eax                      
  10938b:	c1 e8 09             	shr    $0x9,%eax                      
  10938e:	83 e0 01             	and    $0x1,%eax                      
  109391:	50                   	push   %eax                           
  109392:	89 d8                	mov    %ebx,%eax                      
  109394:	c1 e8 08             	shr    $0x8,%eax                      
  109397:	83 f0 01             	xor    $0x1,%eax                      
  10939a:	83 e0 01             	and    $0x1,%eax                      
  10939d:	50                   	push   %eax                           
  10939e:	ff 75 0c             	pushl  0xc(%ebp)                      
  1093a1:	83 e7 01             	and    $0x1,%edi                      
  1093a4:	57                   	push   %edi                           
  1093a5:	ff 75 10             	pushl  0x10(%ebp)                     
  1093a8:	6a 00                	push   $0x0                           
  1093aa:	56                   	push   %esi                           
  1093ab:	68 20 d7 11 00       	push   $0x11d720                      
  1093b0:	e8 6f 1b 00 00       	call   10af24 <_Thread_Initialize>    
    NULL,        /* no budget algorithm callout */                    
    _Modes_Get_interrupt_level(initial_modes),                        
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  if ( !status ) {                                                    
  1093b5:	83 c4 30             	add    $0x30,%esp                     
  1093b8:	84 c0                	test   %al,%al                        
  1093ba:	75 27                	jne    1093e3 <rtems_task_create+0xf7>
 *  @param[in] starting_address is the starting address of the memory for
 *         the heap                                                   
 *  @param[in] size is the size in bytes of the memory area for the heap
 *  @param[in] page_size is the size in bytes of the allocation unit  
 *                                                                    
 *  @return This method returns the maximum memory available.  If     
  1093bc:	83 ec 0c             	sub    $0xc,%esp                      
  1093bf:	ff 76 08             	pushl  0x8(%esi)                      
  1093c2:	e8 45 12 00 00       	call   10a60c <_Objects_Get_information_id>
  1093c7:	5a                   	pop    %edx                           
  1093c8:	59                   	pop    %ecx                           
  1093c9:	56                   	push   %esi                           
  1093ca:	50                   	push   %eax                           
  1093cb:	e8 c8 11 00 00       	call   10a598 <_Objects_Free>         
#if defined(RTEMS_MULTIPROCESSING)                                    
    if ( is_global )                                                  
      _Objects_MP_Free_global_object( the_global_object );            
#endif                                                                
    _RTEMS_tasks_Free( the_thread );                                  
    _RTEMS_Unlock_allocator();                                        
  1093d0:	58                   	pop    %eax                           
  1093d1:	ff 35 50 d8 11 00    	pushl  0x11d850                       
  1093d7:	e8 e4 06 00 00       	call   109ac0 <_API_Mutex_Unlock>     
  1093dc:	b8 0d 00 00 00       	mov    $0xd,%eax                      
  1093e1:	eb 2c                	jmp    10940f <rtems_task_create+0x123>
  }                                                                   
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
  asr = &api->Signal;                                                 
                                                                      
  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
  1093e3:	8b 86 f4 00 00 00    	mov    0xf4(%esi),%eax                
  1093e9:	c1 eb 0a             	shr    $0xa,%ebx                      
  1093ec:	83 f3 01             	xor    $0x1,%ebx                      
  1093ef:	88 da                	mov    %bl,%dl                        
  1093f1:	83 e2 01             	and    $0x1,%edx                      
  1093f4:	88 50 08             	mov    %dl,0x8(%eax)                  
                                                                      
  *id = the_thread->Object.id;                                        
  1093f7:	8b 46 08             	mov    0x8(%esi),%eax                 
  1093fa:	8b 55 1c             	mov    0x1c(%ebp),%edx                
  1093fd:	89 02                	mov    %eax,(%edx)                    
    );                                                                
                                                                      
   }                                                                  
#endif                                                                
                                                                      
  _RTEMS_Unlock_allocator();                                          
  1093ff:	83 ec 0c             	sub    $0xc,%esp                      
  109402:	ff 35 50 d8 11 00    	pushl  0x11d850                       
  109408:	e8 b3 06 00 00       	call   109ac0 <_API_Mutex_Unlock>     
  10940d:	31 c0                	xor    %eax,%eax                      
  10940f:	83 c4 10             	add    $0x10,%esp                     
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  109412:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109415:	5b                   	pop    %ebx                           
  109416:	5e                   	pop    %esi                           
  109417:	5f                   	pop    %edi                           
  109418:	c9                   	leave                                 
  109419:	c3                   	ret                                   
                                                                      

0010aa24 <rtems_task_get_note>: rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) {
  10aa24:	55                   	push   %ebp                           
  10aa25:	89 e5                	mov    %esp,%ebp                      
  10aa27:	56                   	push   %esi                           
  10aa28:	53                   	push   %ebx                           
  10aa29:	83 ec 10             	sub    $0x10,%esp                     
  10aa2c:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10aa2f:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10aa32:	8b 75 10             	mov    0x10(%ebp),%esi                
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
  10aa35:	a1 a4 28 12 00       	mov    0x1228a4,%eax                  
  10aa3a:	8b 40 40             	mov    0x40(%eax),%eax                
  10aa3d:	ba 16 00 00 00       	mov    $0x16,%edx                     
  10aa42:	80 78 04 00          	cmpb   $0x0,0x4(%eax)                 
  10aa46:	74 61                	je     10aaa9 <rtems_task_get_note+0x85><== NEVER TAKEN
    return RTEMS_NOT_CONFIGURED;                                      
                                                                      
  if ( !note )                                                        
  10aa48:	ba 09 00 00 00       	mov    $0x9,%edx                      
  10aa4d:	85 f6                	test   %esi,%esi                      
  10aa4f:	74 58                	je     10aaa9 <rtems_task_get_note+0x85><== NEVER TAKEN
  /*                                                                  
   *  NOTE:  There is no check for < RTEMS_NOTEPAD_FIRST because that would
   *         be checking an unsigned number for being negative.       
   */                                                                 
                                                                      
  if ( notepad > RTEMS_NOTEPAD_LAST )                                 
  10aa51:	ba 0a 00 00 00       	mov    $0xa,%edx                      
  10aa56:	83 fb 0f             	cmp    $0xf,%ebx                      
  10aa59:	77 4e                	ja     10aaa9 <rtems_task_get_note+0x85>
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
  10aa5b:	85 c9                	test   %ecx,%ecx                      
  10aa5d:	74 0a                	je     10aa69 <rtems_task_get_note+0x45>
  10aa5f:	a1 cc 28 12 00       	mov    0x1228cc,%eax                  
  10aa64:	3b 48 08             	cmp    0x8(%eax),%ecx                 
  10aa67:	75 13                	jne    10aa7c <rtems_task_get_note+0x58>
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      *note = api->Notepads[ notepad ];                               
  10aa69:	a1 cc 28 12 00       	mov    0x1228cc,%eax                  
  10aa6e:	8b 80 f4 00 00 00    	mov    0xf4(%eax),%eax                
  10aa74:	8b 44 98 20          	mov    0x20(%eax,%ebx,4),%eax         
  10aa78:	89 06                	mov    %eax,(%esi)                    
  10aa7a:	eb 2b                	jmp    10aaa7 <rtems_task_get_note+0x83>
      return RTEMS_SUCCESSFUL;                                        
  }                                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  10aa7c:	50                   	push   %eax                           
  10aa7d:	50                   	push   %eax                           
  10aa7e:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10aa81:	50                   	push   %eax                           
  10aa82:	51                   	push   %ecx                           
  10aa83:	e8 d8 1c 00 00       	call   10c760 <_Thread_Get>           
  switch ( location ) {                                               
  10aa88:	83 c4 10             	add    $0x10,%esp                     
  10aa8b:	ba 04 00 00 00       	mov    $0x4,%edx                      
  10aa90:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10aa94:	75 13                	jne    10aaa9 <rtems_task_get_note+0x85><== ALWAYS TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
      *note = api->Notepads[ notepad ];                               
  10aa96:	8b 80 f4 00 00 00    	mov    0xf4(%eax),%eax                <== NOT EXECUTED
  10aa9c:	8b 44 98 20          	mov    0x20(%eax,%ebx,4),%eax         <== NOT EXECUTED
  10aaa0:	89 06                	mov    %eax,(%esi)                    <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
  10aaa2:	e8 99 1c 00 00       	call   10c740 <_Thread_Enable_dispatch><== NOT EXECUTED
  10aaa7:	31 d2                	xor    %edx,%edx                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10aaa9:	89 d0                	mov    %edx,%eax                      
  10aaab:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10aaae:	5b                   	pop    %ebx                           
  10aaaf:	5e                   	pop    %esi                           
  10aab0:	c9                   	leave                                 
  10aab1:	c3                   	ret                                   
                                                                      

001094a0 <rtems_task_ident>: rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) {
  1094a0:	55                   	push   %ebp                           
  1094a1:	89 e5                	mov    %esp,%ebp                      
  1094a3:	83 ec 08             	sub    $0x8,%esp                      
  1094a6:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  1094a9:	8b 55 10             	mov    0x10(%ebp),%edx                
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  if ( !id )                                                          
  1094ac:	b8 09 00 00 00       	mov    $0x9,%eax                      
  1094b1:	85 d2                	test   %edx,%edx                      
  1094b3:	74 2b                	je     1094e0 <rtems_task_ident+0x40> <== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( name == OBJECTS_ID_OF_SELF ) {                                 
  1094b5:	85 c9                	test   %ecx,%ecx                      
  1094b7:	75 0e                	jne    1094c7 <rtems_task_ident+0x27> 
    *id = _Thread_Executing->Object.id;                               
  1094b9:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  1094be:	8b 40 08             	mov    0x8(%eax),%eax                 
  1094c1:	89 02                	mov    %eax,(%edx)                    
  1094c3:	31 c0                	xor    %eax,%eax                      
  1094c5:	eb 19                	jmp    1094e0 <rtems_task_ident+0x40> 
    return RTEMS_SUCCESSFUL;                                          
   }                                                                  
                                                                      
  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
  1094c7:	52                   	push   %edx                           
  1094c8:	ff 75 0c             	pushl  0xc(%ebp)                      
  1094cb:	51                   	push   %ecx                           
  1094cc:	68 20 d7 11 00       	push   $0x11d720                      
  1094d1:	e8 3e 13 00 00       	call   10a814 <_Objects_Name_to_id_u32>
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
  1094d6:	8b 04 85 1c 73 11 00 	mov    0x11731c(,%eax,4),%eax         
  1094dd:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  1094e0:	c9                   	leave                                 
  1094e1:	c3                   	ret                                   
                                                                      

001099ec <rtems_task_is_suspended>: */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) {
  1099ec:	55                   	push   %ebp                           
  1099ed:	89 e5                	mov    %esp,%ebp                      
  1099ef:	83 ec 20             	sub    $0x20,%esp                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  1099f2:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  1099f5:	50                   	push   %eax                           
  1099f6:	ff 75 08             	pushl  0x8(%ebp)                      
  1099f9:	e8 46 1a 00 00       	call   10b444 <_Thread_Get>           
  1099fe:	89 c2                	mov    %eax,%edx                      
  switch ( location ) {                                               
  109a00:	83 c4 10             	add    $0x10,%esp                     
  109a03:	b8 04 00 00 00       	mov    $0x4,%eax                      
  109a08:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  109a0c:	75 19                	jne    109a27 <rtems_task_is_suspended+0x3b><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_States_Is_suspended( the_thread->current_state ) ) {     
  109a0e:	f6 42 10 02          	testb  $0x2,0x10(%edx)                
  109a12:	75 09                	jne    109a1d <rtems_task_is_suspended+0x31>
        _Thread_Enable_dispatch();                                    
  109a14:	e8 0b 1a 00 00       	call   10b424 <_Thread_Enable_dispatch>
  109a19:	31 c0                	xor    %eax,%eax                      
  109a1b:	eb 0a                	jmp    109a27 <rtems_task_is_suspended+0x3b>
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
  109a1d:	e8 02 1a 00 00       	call   10b424 <_Thread_Enable_dispatch>
  109a22:	b8 0f 00 00 00       	mov    $0xf,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  109a27:	c9                   	leave                                 
  109a28:	c3                   	ret                                   
                                                                      

0010ecd4 <rtems_task_mode>: rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) {
  10ecd4:	55                   	push   %ebp                           
  10ecd5:	89 e5                	mov    %esp,%ebp                      
  10ecd7:	57                   	push   %edi                           
  10ecd8:	56                   	push   %esi                           
  10ecd9:	53                   	push   %ebx                           
  10ecda:	83 ec 0c             	sub    $0xc,%esp                      
  10ecdd:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  ASR_Information    *asr;                                            
  bool                is_asr_enabled = false;                         
  bool                needs_asr_dispatching = false;                  
  rtems_mode          old_mode;                                       
                                                                      
  if ( !previous_mode_set )                                           
  10ece0:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10ece5:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  10ece9:	0f 84 04 01 00 00    	je     10edf3 <rtems_task_mode+0x11f> <== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
  10ecef:	a1 58 d8 11 00       	mov    0x11d858,%eax                  
  10ecf4:	89 45 ec             	mov    %eax,-0x14(%ebp)               
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  10ecf7:	8b 90 f4 00 00 00    	mov    0xf4(%eax),%edx                
  10ecfd:	89 55 f0             	mov    %edx,-0x10(%ebp)               
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
  10ed00:	80 78 76 01          	cmpb   $0x1,0x76(%eax)                
  10ed04:	19 f6                	sbb    %esi,%esi                      
  10ed06:	81 e6 00 01 00 00    	and    $0x100,%esi                    
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
  10ed0c:	83 78 7c 00          	cmpl   $0x0,0x7c(%eax)                
  10ed10:	74 06                	je     10ed18 <rtems_task_mode+0x44>  
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
  10ed12:	81 ce 00 02 00 00    	or     $0x200,%esi                    
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
  10ed18:	8b 5d f0             	mov    -0x10(%ebp),%ebx               
  10ed1b:	80 7b 08 01          	cmpb   $0x1,0x8(%ebx)                 
  10ed1f:	19 db                	sbb    %ebx,%ebx                      
  10ed21:	81 e3 00 04 00 00    	and    $0x400,%ebx                    
  old_mode |= _ISR_Get_level();                                       
  10ed27:	e8 6f d3 ff ff       	call   10c09b <_CPU_ISR_Get_level>    
  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;           
  10ed2c:	09 c3                	or     %eax,%ebx                      
  old_mode |= _ISR_Get_level();                                       
                                                                      
  *previous_mode_set = old_mode;                                      
  10ed2e:	09 f3                	or     %esi,%ebx                      
  10ed30:	8b 45 10             	mov    0x10(%ebp),%eax                
  10ed33:	89 18                	mov    %ebx,(%eax)                    
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
                                                                      
  if ( mask & RTEMS_PREEMPT_MASK )                                    
  10ed35:	f7 45 0c 00 01 00 00 	testl  $0x100,0xc(%ebp)               
  10ed3c:	74 11                	je     10ed4f <rtems_task_mode+0x7b>  
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
  10ed3e:	89 f8                	mov    %edi,%eax                      
  10ed40:	c1 e8 08             	shr    $0x8,%eax                      
  10ed43:	83 f0 01             	xor    $0x1,%eax                      
  10ed46:	83 e0 01             	and    $0x1,%eax                      
  10ed49:	8b 55 ec             	mov    -0x14(%ebp),%edx               
  10ed4c:	88 42 76             	mov    %al,0x76(%edx)                 
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
  10ed4f:	f7 45 0c 00 02 00 00 	testl  $0x200,0xc(%ebp)               
  10ed56:	74 26                	je     10ed7e <rtems_task_mode+0xaa>  
    if ( _Modes_Is_timeslice(mode_set) ) {                            
  10ed58:	f7 c7 00 02 00 00    	test   $0x200,%edi                    
  10ed5e:	74 14                	je     10ed74 <rtems_task_mode+0xa0>  
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
  10ed60:	8b 5d ec             	mov    -0x14(%ebp),%ebx               
  10ed63:	c7 43 7c 01 00 00 00 	movl   $0x1,0x7c(%ebx)                
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
  10ed6a:	a1 64 d7 11 00       	mov    0x11d764,%eax                  
  10ed6f:	89 43 78             	mov    %eax,0x78(%ebx)                
  10ed72:	eb 0a                	jmp    10ed7e <rtems_task_mode+0xaa>  
    } else                                                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 
  10ed74:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10ed77:	c7 40 7c 00 00 00 00 	movl   $0x0,0x7c(%eax)                
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
                                                                      
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
  10ed7e:	f6 45 0c 01          	testb  $0x1,0xc(%ebp)                 
  10ed82:	74 0c                	je     10ed90 <rtems_task_mode+0xbc>  
 *  Returns pointer to the start of the memory block if success, NULL if
 *  failure.                                                          
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
 *  @param[in] size is the amount of memory to allocate in bytes      
 *  @param[in] alignment the required alignment                       
  10ed84:	f7 c7 01 00 00 00    	test   $0x1,%edi                      
  10ed8a:	74 03                	je     10ed8f <rtems_task_mode+0xbb>  
  10ed8c:	fa                   	cli                                   
  10ed8d:	eb 01                	jmp    10ed90 <rtems_task_mode+0xbc>  
  10ed8f:	fb                   	sti                                   
   */                                                                 
                                                                      
  is_asr_enabled = FALSE;                                             
  needs_asr_dispatching = FALSE;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
  10ed90:	f7 45 0c 00 04 00 00 	testl  $0x400,0xc(%ebp)               
  10ed97:	74 3b                	je     10edd4 <rtems_task_mode+0x100> 
  10ed99:	c1 ef 0a             	shr    $0xa,%edi                      
  10ed9c:	83 f7 01             	xor    $0x1,%edi                      
  10ed9f:	89 f8                	mov    %edi,%eax                      
  10eda1:	83 e0 01             	and    $0x1,%eax                      
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
  10eda4:	8b 55 f0             	mov    -0x10(%ebp),%edx               
  10eda7:	3a 42 08             	cmp    0x8(%edx),%al                  
  10edaa:	74 28                	je     10edd4 <rtems_task_mode+0x100> 
      asr->is_enabled = is_asr_enabled;                               
  10edac:	88 42 08             	mov    %al,0x8(%edx)                  
  uint32_t      page_size                                             
)                                                                     
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
  10edaf:	9c                   	pushf                                 
  10edb0:	fa                   	cli                                   
  10edb1:	59                   	pop    %ecx                           
/**                                                                   
  10edb2:	8b 5d f0             	mov    -0x10(%ebp),%ebx               
  10edb5:	8b 53 18             	mov    0x18(%ebx),%edx                
 *  This routine grows @a the_heap memory area using the size bytes which
  10edb8:	8b 43 14             	mov    0x14(%ebx),%eax                
  10edbb:	89 43 18             	mov    %eax,0x18(%ebx)                
 *  begin at @a starting_address.                                     
  10edbe:	89 53 14             	mov    %edx,0x14(%ebx)                
 *                                                                    
  10edc1:	51                   	push   %ecx                           
  10edc2:	9d                   	popf                                  
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
  10edc3:	83 7b 14 00          	cmpl   $0x0,0x14(%ebx)                
  10edc7:	74 0b                	je     10edd4 <rtems_task_mode+0x100> <== ALWAYS TAKEN
        needs_asr_dispatching = true;                                 
        executing->do_post_task_switch_extension = true;              
  10edc9:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  10edcc:	c6 40 75 01          	movb   $0x1,0x75(%eax)                <== NOT EXECUTED
  10edd0:	b3 01                	mov    $0x1,%bl                       <== NOT EXECUTED
  10edd2:	eb 02                	jmp    10edd6 <rtems_task_mode+0x102> <== NOT EXECUTED
  10edd4:	31 db                	xor    %ebx,%ebx                      
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up(_System_state_Current) )                   
  10edd6:	83 3d 38 d9 11 00 03 	cmpl   $0x3,0x11d938                  
  10eddd:	75 12                	jne    10edf1 <rtems_task_mode+0x11d> <== NEVER TAKEN
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )           
  10eddf:	e8 58 01 00 00       	call   10ef3c <_Thread_Evaluate_mode> 
  10ede4:	84 c0                	test   %al,%al                        
  10ede6:	75 04                	jne    10edec <rtems_task_mode+0x118> 
  10ede8:	84 db                	test   %bl,%bl                        
  10edea:	74 05                	je     10edf1 <rtems_task_mode+0x11d> <== ALWAYS TAKEN
      _Thread_Dispatch();                                             
  10edec:	e8 57 bf ff ff       	call   10ad48 <_Thread_Dispatch>      
  10edf1:	31 c0                	xor    %eax,%eax                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  10edf3:	83 c4 0c             	add    $0xc,%esp                      
  10edf6:	5b                   	pop    %ebx                           
  10edf7:	5e                   	pop    %esi                           
  10edf8:	5f                   	pop    %edi                           
  10edf9:	c9                   	leave                                 
  10edfa:	c3                   	ret                                   
                                                                      

0010ab88 <rtems_task_set_note>: rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) {
  10ab88:	55                   	push   %ebp                           
  10ab89:	89 e5                	mov    %esp,%ebp                      
  10ab8b:	56                   	push   %esi                           
  10ab8c:	53                   	push   %ebx                           
  10ab8d:	83 ec 10             	sub    $0x10,%esp                     
  10ab90:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  10ab93:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10ab96:	8b 75 10             	mov    0x10(%ebp),%esi                
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
  10ab99:	a1 a4 28 12 00       	mov    0x1228a4,%eax                  
  10ab9e:	8b 40 40             	mov    0x40(%eax),%eax                
  10aba1:	ba 16 00 00 00       	mov    $0x16,%edx                     
  10aba6:	80 78 04 00          	cmpb   $0x0,0x4(%eax)                 
  10abaa:	74 54                	je     10ac00 <rtems_task_set_note+0x78><== NEVER TAKEN
  /*                                                                  
   *  NOTE:  There is no check for < RTEMS_NOTEPAD_FIRST because that would
   *         be checking an unsigned number for being negative.       
   */                                                                 
                                                                      
  if ( notepad > RTEMS_NOTEPAD_LAST )                                 
  10abac:	ba 0a 00 00 00       	mov    $0xa,%edx                      
  10abb1:	83 fb 0f             	cmp    $0xf,%ebx                      
  10abb4:	77 4a                	ja     10ac00 <rtems_task_set_note+0x78>
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
  10abb6:	85 c9                	test   %ecx,%ecx                      
  10abb8:	74 0a                	je     10abc4 <rtems_task_set_note+0x3c>
  10abba:	a1 cc 28 12 00       	mov    0x1228cc,%eax                  
  10abbf:	3b 48 08             	cmp    0x8(%eax),%ecx                 
  10abc2:	75 11                	jne    10abd5 <rtems_task_set_note+0x4d><== ALWAYS TAKEN
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      api->Notepads[ notepad ] = note;                                
  10abc4:	a1 cc 28 12 00       	mov    0x1228cc,%eax                  
  10abc9:	8b 80 f4 00 00 00    	mov    0xf4(%eax),%eax                
  10abcf:	89 74 98 20          	mov    %esi,0x20(%eax,%ebx,4)         
  10abd3:	eb 29                	jmp    10abfe <rtems_task_set_note+0x76>
      return RTEMS_SUCCESSFUL;                                        
  }                                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  10abd5:	50                   	push   %eax                           
  10abd6:	50                   	push   %eax                           
  10abd7:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10abda:	50                   	push   %eax                           
  10abdb:	51                   	push   %ecx                           
  10abdc:	e8 7f 1b 00 00       	call   10c760 <_Thread_Get>           
  switch ( location ) {                                               
  10abe1:	83 c4 10             	add    $0x10,%esp                     
  10abe4:	ba 04 00 00 00       	mov    $0x4,%edx                      
  10abe9:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10abed:	75 11                	jne    10ac00 <rtems_task_set_note+0x78>
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
      api->Notepads[ notepad ] = note;                                
  10abef:	8b 80 f4 00 00 00    	mov    0xf4(%eax),%eax                
  10abf5:	89 74 98 20          	mov    %esi,0x20(%eax,%ebx,4)         
      _Thread_Enable_dispatch();                                      
  10abf9:	e8 42 1b 00 00       	call   10c740 <_Thread_Enable_dispatch>
  10abfe:	31 d2                	xor    %edx,%edx                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10ac00:	89 d0                	mov    %edx,%eax                      
  10ac02:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10ac05:	5b                   	pop    %ebx                           
  10ac06:	5e                   	pop    %esi                           
  10ac07:	c9                   	leave                                 
  10ac08:	c3                   	ret                                   
                                                                      

0010a3a8 <rtems_task_set_priority>: rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) {
  10a3a8:	55                   	push   %ebp                           
  10a3a9:	89 e5                	mov    %esp,%ebp                      
  10a3ab:	56                   	push   %esi                           
  10a3ac:	53                   	push   %ebx                           
  10a3ad:	83 ec 10             	sub    $0x10,%esp                     
  10a3b0:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10a3b3:	8b 75 10             	mov    0x10(%ebp),%esi                
  register Thread_Control *the_thread;                                
  Objects_Locations               location;                           
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
  10a3b6:	85 db                	test   %ebx,%ebx                      
  10a3b8:	74 10                	je     10a3ca <rtems_task_set_priority+0x22>
  10a3ba:	0f b6 05 24 d0 11 00 	movzbl 0x11d024,%eax                  
  10a3c1:	ba 13 00 00 00       	mov    $0x13,%edx                     
  10a3c6:	39 c3                	cmp    %eax,%ebx                      
  10a3c8:	77 52                	ja     10a41c <rtems_task_set_priority+0x74>
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
  10a3ca:	ba 09 00 00 00       	mov    $0x9,%edx                      
  10a3cf:	85 f6                	test   %esi,%esi                      
  10a3d1:	74 49                	je     10a41c <rtems_task_set_priority+0x74><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  10a3d3:	52                   	push   %edx                           
  10a3d4:	52                   	push   %edx                           
  10a3d5:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10a3d8:	50                   	push   %eax                           
  10a3d9:	ff 75 08             	pushl  0x8(%ebp)                      
  10a3dc:	e8 93 1a 00 00       	call   10be74 <_Thread_Get>           
  10a3e1:	89 c1                	mov    %eax,%ecx                      
  switch ( location ) {                                               
  10a3e3:	83 c4 10             	add    $0x10,%esp                     
  10a3e6:	ba 04 00 00 00       	mov    $0x4,%edx                      
  10a3eb:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10a3ef:	75 2b                	jne    10a41c <rtems_task_set_priority+0x74>
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
  10a3f1:	8b 40 14             	mov    0x14(%eax),%eax                
  10a3f4:	89 06                	mov    %eax,(%esi)                    
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
  10a3f6:	85 db                	test   %ebx,%ebx                      
  10a3f8:	74 1b                	je     10a415 <rtems_task_set_priority+0x6d>
        the_thread->real_priority = new_priority;                     
  10a3fa:	89 59 18             	mov    %ebx,0x18(%ecx)                
        if ( the_thread->resource_count == 0 ||                       
  10a3fd:	83 79 1c 00          	cmpl   $0x0,0x1c(%ecx)                
  10a401:	74 05                	je     10a408 <rtems_task_set_priority+0x60>
  10a403:	39 59 14             	cmp    %ebx,0x14(%ecx)                
  10a406:	76 0d                	jbe    10a415 <rtems_task_set_priority+0x6d><== ALWAYS TAKEN
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, FALSE ); 
  10a408:	50                   	push   %eax                           
  10a409:	6a 00                	push   $0x0                           
  10a40b:	53                   	push   %ebx                           
  10a40c:	51                   	push   %ecx                           
  10a40d:	e8 a2 15 00 00       	call   10b9b4 <_Thread_Change_priority>
  10a412:	83 c4 10             	add    $0x10,%esp                     
      }                                                               
      _Thread_Enable_dispatch();                                      
  10a415:	e8 3a 1a 00 00       	call   10be54 <_Thread_Enable_dispatch>
  10a41a:	31 d2                	xor    %edx,%edx                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10a41c:	89 d0                	mov    %edx,%eax                      
  10a41e:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a421:	5b                   	pop    %ebx                           
  10a422:	5e                   	pop    %esi                           
  10a423:	c9                   	leave                                 
  10a424:	c3                   	ret                                   
                                                                      

0010a268 <rtems_task_variable_add>: rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) {
  10a268:	55                   	push   %ebp                           
  10a269:	89 e5                	mov    %esp,%ebp                      
  10a26b:	57                   	push   %edi                           
  10a26c:	56                   	push   %esi                           
  10a26d:	53                   	push   %ebx                           
  10a26e:	83 ec 1c             	sub    $0x1c,%esp                     
  10a271:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  10a274:	8b 7d 10             	mov    0x10(%ebp),%edi                
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *new;                                   
                                                                      
  if ( !ptr )                                                         
  10a277:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10a27c:	85 f6                	test   %esi,%esi                      
  10a27e:	74 75                	je     10a2f5 <rtems_task_variable_add+0x8d><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
  10a280:	50                   	push   %eax                           
  10a281:	50                   	push   %eax                           
  10a282:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10a285:	50                   	push   %eax                           
  10a286:	ff 75 08             	pushl  0x8(%ebp)                      
  10a289:	e8 86 1a 00 00       	call   10bd14 <_Thread_Get>           
  10a28e:	89 c3                	mov    %eax,%ebx                      
  switch (location) {                                                 
  10a290:	83 c4 10             	add    $0x10,%esp                     
  10a293:	b8 04 00 00 00       	mov    $0x4,%eax                      
  10a298:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10a29c:	75 57                	jne    10a2f5 <rtems_task_variable_add+0x8d><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is already in this task's list.  
       */                                                             
      tvp = the_thread->task_variables;                               
  10a29e:	8b 83 04 01 00 00    	mov    0x104(%ebx),%eax               
  10a2a4:	eb 0c                	jmp    10a2b2 <rtems_task_variable_add+0x4a>
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
  10a2a6:	39 70 04             	cmp    %esi,0x4(%eax)                 
  10a2a9:	75 05                	jne    10a2b0 <rtems_task_variable_add+0x48>
          tvp->dtor = dtor;                                           
  10a2ab:	89 78 10             	mov    %edi,0x10(%eax)                
  10a2ae:	eb 3e                	jmp    10a2ee <rtems_task_variable_add+0x86>
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
  10a2b0:	8b 00                	mov    (%eax),%eax                    
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is already in this task's list.  
       */                                                             
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
  10a2b2:	85 c0                	test   %eax,%eax                      
  10a2b4:	75 f0                	jne    10a2a6 <rtems_task_variable_add+0x3e>
      }                                                               
                                                                      
      /*                                                              
       *  Now allocate memory for this task variable.                 
       */                                                             
      new = (rtems_task_variable_t *)                                 
  10a2b6:	83 ec 0c             	sub    $0xc,%esp                      
  10a2b9:	6a 14                	push   $0x14                          
  10a2bb:	e8 d1 29 00 00       	call   10cc91 <_Workspace_Allocate>   
  10a2c0:	89 c2                	mov    %eax,%edx                      
         _Workspace_Allocate(sizeof(rtems_task_variable_t));          
      if (new == NULL) {                                              
  10a2c2:	83 c4 10             	add    $0x10,%esp                     
  10a2c5:	85 c0                	test   %eax,%eax                      
  10a2c7:	75 0c                	jne    10a2d5 <rtems_task_variable_add+0x6d>
        _Thread_Enable_dispatch();                                    
  10a2c9:	e8 26 1a 00 00       	call   10bcf4 <_Thread_Enable_dispatch>
  10a2ce:	b8 1a 00 00 00       	mov    $0x1a,%eax                     
  10a2d3:	eb 20                	jmp    10a2f5 <rtems_task_variable_add+0x8d>
        return RTEMS_NO_MEMORY;                                       
      }                                                               
      new->gval = *ptr;                                               
  10a2d5:	8b 06                	mov    (%esi),%eax                    
  10a2d7:	89 42 08             	mov    %eax,0x8(%edx)                 
      new->ptr = ptr;                                                 
  10a2da:	89 72 04             	mov    %esi,0x4(%edx)                 
      new->dtor = dtor;                                               
  10a2dd:	89 7a 10             	mov    %edi,0x10(%edx)                
                                                                      
      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
  10a2e0:	8b 83 04 01 00 00    	mov    0x104(%ebx),%eax               
  10a2e6:	89 02                	mov    %eax,(%edx)                    
      the_thread->task_variables = new;                               
  10a2e8:	89 93 04 01 00 00    	mov    %edx,0x104(%ebx)               
      _Thread_Enable_dispatch();                                      
  10a2ee:	e8 01 1a 00 00       	call   10bcf4 <_Thread_Enable_dispatch>
  10a2f3:	31 c0                	xor    %eax,%eax                      
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10a2f5:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a2f8:	5b                   	pop    %ebx                           
  10a2f9:	5e                   	pop    %esi                           
  10a2fa:	5f                   	pop    %edi                           
  10a2fb:	c9                   	leave                                 
  10a2fc:	c3                   	ret                                   
                                                                      

0010a300 <rtems_task_variable_delete>: rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) {
  10a300:	55                   	push   %ebp                           
  10a301:	89 e5                	mov    %esp,%ebp                      
  10a303:	56                   	push   %esi                           
  10a304:	53                   	push   %ebx                           
  10a305:	83 ec 10             	sub    $0x10,%esp                     
  10a308:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
  10a30b:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10a310:	85 f6                	test   %esi,%esi                      
  10a312:	74 64                	je     10a378 <rtems_task_variable_delete+0x78>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  prev = NULL;                                                        
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
  10a314:	52                   	push   %edx                           
  10a315:	52                   	push   %edx                           
  10a316:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10a319:	50                   	push   %eax                           
  10a31a:	ff 75 08             	pushl  0x8(%ebp)                      
  10a31d:	e8 f2 19 00 00       	call   10bd14 <_Thread_Get>           
  10a322:	89 c3                	mov    %eax,%ebx                      
  switch (location) {                                                 
  10a324:	83 c4 10             	add    $0x10,%esp                     
  10a327:	b8 04 00 00 00       	mov    $0x4,%eax                      
  10a32c:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10a330:	75 46                	jne    10a378 <rtems_task_variable_delete+0x78><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
  10a332:	8b 93 04 01 00 00    	mov    0x104(%ebx),%edx               
  10a338:	31 c0                	xor    %eax,%eax                      
  10a33a:	eb 2e                	jmp    10a36a <rtems_task_variable_delete+0x6a>
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
  10a33c:	39 72 04             	cmp    %esi,0x4(%edx)                 
  10a33f:	75 25                	jne    10a366 <rtems_task_variable_delete+0x66>
          if (prev)                                                   
  10a341:	85 c0                	test   %eax,%eax                      
  10a343:	8b 0a                	mov    (%edx),%ecx                    
  10a345:	74 04                	je     10a34b <rtems_task_variable_delete+0x4b>
            prev->next = tvp->next;                                   
  10a347:	89 08                	mov    %ecx,(%eax)                    
  10a349:	eb 06                	jmp    10a351 <rtems_task_variable_delete+0x51>
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
  10a34b:	89 8b 04 01 00 00    	mov    %ecx,0x104(%ebx)               
                                                                      
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
  10a351:	50                   	push   %eax                           
  10a352:	50                   	push   %eax                           
  10a353:	52                   	push   %edx                           
  10a354:	53                   	push   %ebx                           
  10a355:	e8 8e 00 00 00       	call   10a3e8 <_RTEMS_Tasks_Invoke_task_variable_dtor>
          _Thread_Enable_dispatch();                                  
  10a35a:	e8 95 19 00 00       	call   10bcf4 <_Thread_Enable_dispatch>
  10a35f:	31 c0                	xor    %eax,%eax                      
  10a361:	83 c4 10             	add    $0x10,%esp                     
  10a364:	eb 12                	jmp    10a378 <rtems_task_variable_delete+0x78>
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
  10a366:	89 d0                	mov    %edx,%eax                      
  10a368:	8b 12                	mov    (%edx),%edx                    
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
  10a36a:	85 d2                	test   %edx,%edx                      
  10a36c:	75 ce                	jne    10a33c <rtems_task_variable_delete+0x3c>
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
  10a36e:	e8 81 19 00 00       	call   10bcf4 <_Thread_Enable_dispatch>
  10a373:	b8 09 00 00 00       	mov    $0x9,%eax                      
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10a378:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a37b:	5b                   	pop    %ebx                           
  10a37c:	5e                   	pop    %esi                           
  10a37d:	c9                   	leave                                 
  10a37e:	c3                   	ret                                   
                                                                      

0010a380 <rtems_task_variable_get>: rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) {
  10a380:	55                   	push   %ebp                           
  10a381:	89 e5                	mov    %esp,%ebp                      
  10a383:	56                   	push   %esi                           
  10a384:	53                   	push   %ebx                           
  10a385:	83 ec 10             	sub    $0x10,%esp                     
  10a388:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  10a38b:	8b 75 10             	mov    0x10(%ebp),%esi                
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp;                                         
                                                                      
  if ( !ptr )                                                         
  10a38e:	85 db                	test   %ebx,%ebx                      
  10a390:	74 48                	je     10a3da <rtems_task_variable_get+0x5a>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !result )                                                      
  10a392:	85 f6                	test   %esi,%esi                      
  10a394:	74 44                	je     10a3da <rtems_task_variable_get+0x5a>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
  10a396:	50                   	push   %eax                           
  10a397:	50                   	push   %eax                           
  10a398:	8d 45 f4             	lea    -0xc(%ebp),%eax                
  10a39b:	50                   	push   %eax                           
  10a39c:	ff 75 08             	pushl  0x8(%ebp)                      
  10a39f:	e8 70 19 00 00       	call   10bd14 <_Thread_Get>           
  10a3a4:	89 c2                	mov    %eax,%edx                      
  switch (location) {                                                 
  10a3a6:	83 c4 10             	add    $0x10,%esp                     
  10a3a9:	b8 04 00 00 00       	mov    $0x4,%eax                      
  10a3ae:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)                
  10a3b2:	75 2b                	jne    10a3df <rtems_task_variable_get+0x5f><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is in this task's list.          
       */                                                             
      tvp = the_thread->task_variables;                               
  10a3b4:	8b 82 04 01 00 00    	mov    0x104(%edx),%eax               
  10a3ba:	eb 15                	jmp    10a3d1 <rtems_task_variable_get+0x51>
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
  10a3bc:	39 58 04             	cmp    %ebx,0x4(%eax)                 
  10a3bf:	75 0e                	jne    10a3cf <rtems_task_variable_get+0x4f>
	  /*                                                                 
	   * Should this return the current (i.e not the                     
	   * saved) value if `tid' is the current task?                      
	   */                                                                
          *result = tvp->tval;                                        
  10a3c1:	8b 40 0c             	mov    0xc(%eax),%eax                 
  10a3c4:	89 06                	mov    %eax,(%esi)                    
          _Thread_Enable_dispatch();                                  
  10a3c6:	e8 29 19 00 00       	call   10bcf4 <_Thread_Enable_dispatch>
  10a3cb:	31 c0                	xor    %eax,%eax                      
  10a3cd:	eb 10                	jmp    10a3df <rtems_task_variable_get+0x5f>
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
  10a3cf:	8b 00                	mov    (%eax),%eax                    
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is in this task's list.          
       */                                                             
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
  10a3d1:	85 c0                	test   %eax,%eax                      
  10a3d3:	75 e7                	jne    10a3bc <rtems_task_variable_get+0x3c>
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
  10a3d5:	e8 1a 19 00 00       	call   10bcf4 <_Thread_Enable_dispatch>
      return RTEMS_INVALID_ADDRESS;                                   
  10a3da:	b8 09 00 00 00       	mov    $0x9,%eax                      
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10a3df:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a3e2:	5b                   	pop    %ebx                           
  10a3e3:	5e                   	pop    %esi                           
  10a3e4:	c9                   	leave                                 
  10a3e5:	c3                   	ret                                   
                                                                      

0010a150 <rtems_task_wake_when>: */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) {
  10a150:	55                   	push   %ebp                           
  10a151:	89 e5                	mov    %esp,%ebp                      
  10a153:	53                   	push   %ebx                           
  10a154:	83 ec 04             	sub    $0x4,%esp                      
  10a157:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  Watchdog_Interval   seconds;                                        
                                                                      
  if ( !_TOD_Is_set )                                                 
  10a15a:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  10a15f:	80 3d d0 0d 12 00 00 	cmpb   $0x0,0x120dd0                  
  10a166:	0f 84 9e 00 00 00    	je     10a20a <rtems_task_wake_when+0xba>
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !time_buffer )                                                 
  10a16c:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10a171:	85 db                	test   %ebx,%ebx                      
  10a173:	0f 84 91 00 00 00    	je     10a20a <rtems_task_wake_when+0xba><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  time_buffer->ticks = 0;                                             
  10a179:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
                                                                      
  if ( !_TOD_Validate( time_buffer ) )                                
  10a180:	83 ec 0c             	sub    $0xc,%esp                      
  10a183:	53                   	push   %ebx                           
  10a184:	e8 d7 f4 ff ff       	call   109660 <_TOD_Validate>         
  10a189:	83 c4 10             	add    $0x10,%esp                     
  10a18c:	84 c0                	test   %al,%al                        
  10a18e:	74 75                	je     10a205 <rtems_task_wake_when+0xb5>
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( time_buffer );                           
  10a190:	83 ec 0c             	sub    $0xc,%esp                      
  10a193:	53                   	push   %ebx                           
  10a194:	e8 5f f4 ff ff       	call   1095f8 <_TOD_To_seconds>       
  10a199:	89 c3                	mov    %eax,%ebx                      
                                                                      
  if ( seconds <= _TOD_Seconds_since_epoch )                          
  10a19b:	83 c4 10             	add    $0x10,%esp                     
  10a19e:	3b 05 4c 0e 12 00    	cmp    0x120e4c,%eax                  
  10a1a4:	76 5f                	jbe    10a205 <rtems_task_wake_when+0xb5>
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10a1a6:	a1 bc 0d 12 00       	mov    0x120dbc,%eax                  
  10a1ab:	40                   	inc    %eax                           
  10a1ac:	a3 bc 0d 12 00       	mov    %eax,0x120dbc                  
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  _Thread_Disable_dispatch();                                         
    _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );  
  10a1b1:	50                   	push   %eax                           
  10a1b2:	50                   	push   %eax                           
  10a1b3:	6a 10                	push   $0x10                          
  10a1b5:	ff 35 7c 0e 12 00    	pushl  0x120e7c                       
  10a1bb:	e8 24 21 00 00       	call   10c2e4 <_Thread_Set_state>     
    _Watchdog_Initialize(                                             
  10a1c0:	a1 7c 0e 12 00       	mov    0x120e7c,%eax                  
  10a1c5:	8b 50 08             	mov    0x8(%eax),%edx                 
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10a1c8:	c7 40 50 00 00 00 00 	movl   $0x0,0x50(%eax)                
 *  @param[in] the_heap is the heap to operate upon                   
  10a1cf:	c7 40 64 78 b9 10 00 	movl   $0x10b978,0x64(%eax)           
 *  @param[in] starting_address is the starting address of the memory for
  10a1d6:	89 50 68             	mov    %edx,0x68(%eax)                
 *         the heap                                                   
  10a1d9:	c7 40 6c 00 00 00 00 	movl   $0x0,0x6c(%eax)                
 *  @return TRUE if successfully able to resize the block.            
 *          FALSE if the block can't be resized in place.             
 */                                                                   
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  10a1e0:	2b 1d 4c 0e 12 00    	sub    0x120e4c,%ebx                  
  10a1e6:	89 58 54             	mov    %ebx,0x54(%eax)                
  size_t        size                                                  
);                                                                    
  10a1e9:	5a                   	pop    %edx                           
  10a1ea:	59                   	pop    %ecx                           
  10a1eb:	83 c0 48             	add    $0x48,%eax                     
  10a1ee:	50                   	push   %eax                           
  10a1ef:	68 90 0e 12 00       	push   $0x120e90                      
  10a1f4:	e8 03 27 00 00       	call   10c8fc <_Watchdog_Insert>      
    );                                                                
    _Watchdog_Insert_seconds(                                         
      &_Thread_Executing->Timer,                                      
      seconds - _TOD_Seconds_since_epoch                              
    );                                                                
  _Thread_Enable_dispatch();                                          
  10a1f9:	e8 f6 18 00 00       	call   10baf4 <_Thread_Enable_dispatch>
  10a1fe:	31 c0                	xor    %eax,%eax                      
  10a200:	83 c4 10             	add    $0x10,%esp                     
  10a203:	eb 05                	jmp    10a20a <rtems_task_wake_when+0xba>
  return RTEMS_SUCCESSFUL;                                            
  10a205:	b8 14 00 00 00       	mov    $0x14,%eax                     
}                                                                     
  10a20a:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10a20d:	c9                   	leave                                 
  10a20e:	c3                   	ret                                   
                                                                      

001071a0 <rtems_termios_bufsize>: rtems_status_code rtems_termios_bufsize ( int cbufsize, int raw_input, int raw_output ) {
  1071a0:	55                   	push   %ebp                           <== NOT EXECUTED
  1071a1:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  rtems_termios_cbufsize        = cbufsize;                           
  1071a3:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  1071a6:	a3 3c b6 11 00       	mov    %eax,0x11b63c                  <== NOT EXECUTED
  rtems_termios_raw_input_size  = raw_input;                          
  1071ab:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  1071ae:	a3 40 b6 11 00       	mov    %eax,0x11b640                  <== NOT EXECUTED
  rtems_termios_raw_output_size = raw_output;                         
  1071b3:	8b 45 10             	mov    0x10(%ebp),%eax                <== NOT EXECUTED
  1071b6:	a3 44 b6 11 00       	mov    %eax,0x11b644                  <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  1071bb:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  1071bd:	c9                   	leave                                 <== NOT EXECUTED
  1071be:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010833e <rtems_termios_close>: } } rtems_status_code rtems_termios_close (void *arg) {
  10833e:	55                   	push   %ebp                           
  10833f:	89 e5                	mov    %esp,%ebp                      
  108341:	56                   	push   %esi                           
  108342:	53                   	push   %ebx                           
  108343:	8b 75 08             	mov    0x8(%ebp),%esi                 
	rtems_libio_open_close_args_t *args = arg;                           
	struct rtems_termios_tty *tty = args->iop->data1;                    
  108346:	8b 06                	mov    (%esi),%eax                    
  108348:	8b 58 28             	mov    0x28(%eax),%ebx                
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  10834b:	50                   	push   %eax                           
  10834c:	6a 00                	push   $0x0                           
  10834e:	6a 00                	push   $0x0                           
  108350:	ff 35 d4 d6 11 00    	pushl  0x11d6d4                       
  108356:	e8 19 0e 00 00       	call   109174 <rtems_semaphore_obtain>
	if (sc != RTEMS_SUCCESSFUL)                                          
  10835b:	83 c4 10             	add    $0x10,%esp                     
  10835e:	85 c0                	test   %eax,%eax                      
  108360:	75 69                	jne    1083cb <rtems_termios_close+0x8d><== NEVER TAKEN
		rtems_fatal_error_occurred (sc);                                    
	if (--tty->refcount == 0) {                                          
  108362:	8b 43 08             	mov    0x8(%ebx),%eax                 
  108365:	48                   	dec    %eax                           
  108366:	89 43 08             	mov    %eax,0x8(%ebx)                 
  108369:	85 c0                	test   %eax,%eax                      
  10836b:	0f 85 1f 01 00 00    	jne    108490 <rtems_termios_close+0x152>
                if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
  108371:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                
  108377:	c1 e0 05             	shl    $0x5,%eax                      
  10837a:	8b 80 50 d4 11 00    	mov    0x11d450(%eax),%eax            
  108380:	85 c0                	test   %eax,%eax                      
  108382:	74 0b                	je     10838f <rtems_termios_close+0x51><== ALWAYS TAKEN
			/*                                                                 
			 * call discipline-specific close                                  
			 */                                                                
			sc = rtems_termios_linesw[tty->t_line].l_close(tty);               
  108384:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108387:	53                   	push   %ebx                           <== NOT EXECUTED
  108388:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10838a:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10838d:	eb 07                	jmp    108396 <rtems_termios_close+0x58><== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * default: just flush output buffer                               
			 */                                                                
		        drainOutput (tty);                                          
  10838f:	89 d8                	mov    %ebx,%eax                      
  108391:	e8 ec f8 ff ff       	call   107c82 <drainOutput>           
		}                                                                   
                                                                      
		if (tty->device.outputUsesInterrupts                                
  108396:	83 bb b4 00 00 00 02 	cmpl   $0x2,0xb4(%ebx)                
  10839d:	75 35                	jne    1083d4 <rtems_termios_close+0x96><== ALWAYS TAKEN
		    == TERMIOS_TASK_DRIVEN) {                                       
			/*                                                                 
			 * send "terminate" to I/O tasks                                   
			 */                                                                
			sc = rtems_event_send(                                             
  10839f:	50                   	push   %eax                           <== NOT EXECUTED
  1083a0:	50                   	push   %eax                           <== NOT EXECUTED
  1083a1:	6a 01                	push   $0x1                           <== NOT EXECUTED
  1083a3:	ff b3 c4 00 00 00    	pushl  0xc4(%ebx)                     <== NOT EXECUTED
  1083a9:	e8 36 09 00 00       	call   108ce4 <rtems_event_send>      <== NOT EXECUTED
                                  tty->rxTaskId,                      
				  TERMIOS_RX_TERMINATE_EVENT);                                    
			if (sc != RTEMS_SUCCESSFUL)                                        
  1083ae:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1083b1:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1083b3:	75 16                	jne    1083cb <rtems_termios_close+0x8d><== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
			sc = rtems_event_send(                                             
  1083b5:	51                   	push   %ecx                           <== NOT EXECUTED
  1083b6:	51                   	push   %ecx                           <== NOT EXECUTED
  1083b7:	6a 01                	push   $0x1                           <== NOT EXECUTED
  1083b9:	ff b3 c8 00 00 00    	pushl  0xc8(%ebx)                     <== NOT EXECUTED
  1083bf:	e8 20 09 00 00       	call   108ce4 <rtems_event_send>      <== NOT EXECUTED
                                  tty->txTaskId,                      
				  TERMIOS_TX_TERMINATE_EVENT);                                    
			if (sc != RTEMS_SUCCESSFUL)                                        
  1083c4:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1083c7:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1083c9:	74 09                	je     1083d4 <rtems_termios_close+0x96><== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
  1083cb:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1083ce:	50                   	push   %eax                           <== NOT EXECUTED
  1083cf:	e8 c0 13 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
		}                                                                   
		if (tty->device.lastClose)                                          
  1083d4:	8b 83 9c 00 00 00    	mov    0x9c(%ebx),%eax                
  1083da:	85 c0                	test   %eax,%eax                      
  1083dc:	74 0d                	je     1083eb <rtems_termios_close+0xad><== NEVER TAKEN
			 (*tty->device.lastClose)(tty->major, tty->minor, arg);            
  1083de:	52                   	push   %edx                           
  1083df:	56                   	push   %esi                           
  1083e0:	ff 73 10             	pushl  0x10(%ebx)                     
  1083e3:	ff 73 0c             	pushl  0xc(%ebx)                      
  1083e6:	ff d0                	call   *%eax                          
  1083e8:	83 c4 10             	add    $0x10,%esp                     
		if (tty->forw == NULL) {                                            
  1083eb:	8b 13                	mov    (%ebx),%edx                    
  1083ed:	85 d2                	test   %edx,%edx                      
  1083ef:	8b 43 04             	mov    0x4(%ebx),%eax                 
  1083f2:	75 11                	jne    108405 <rtems_termios_close+0xc7><== NEVER TAKEN
			rtems_termios_ttyTail = tty->back;                                 
  1083f4:	a3 d8 d6 11 00       	mov    %eax,0x11d6d8                  
			if ( rtems_termios_ttyTail != NULL ) {                             
  1083f9:	85 c0                	test   %eax,%eax                      
  1083fb:	74 0b                	je     108408 <rtems_termios_close+0xca><== ALWAYS TAKEN
				rtems_termios_ttyTail->forw = NULL;                               
  1083fd:	c7 00 00 00 00 00    	movl   $0x0,(%eax)                    <== NOT EXECUTED
  108403:	eb 03                	jmp    108408 <rtems_termios_close+0xca><== NOT EXECUTED
			}                                                                  
		}                                                                   
		else {                                                              
			tty->forw->back = tty->back;                                       
  108405:	89 42 04             	mov    %eax,0x4(%edx)                 <== NOT EXECUTED
		}                                                                   
		if (tty->back == NULL) {                                            
  108408:	8b 53 04             	mov    0x4(%ebx),%edx                 
  10840b:	85 d2                	test   %edx,%edx                      
  10840d:	8b 03                	mov    (%ebx),%eax                    
  10840f:	75 12                	jne    108423 <rtems_termios_close+0xe5><== NEVER TAKEN
			rtems_termios_ttyHead = tty->forw;                                 
  108411:	a3 dc d6 11 00       	mov    %eax,0x11d6dc                  
			if ( rtems_termios_ttyHead != NULL ) {                             
  108416:	85 c0                	test   %eax,%eax                      
  108418:	74 0b                	je     108425 <rtems_termios_close+0xe7><== ALWAYS TAKEN
				rtems_termios_ttyHead->back = NULL;                               
  10841a:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)                 <== NOT EXECUTED
  108421:	eb 02                	jmp    108425 <rtems_termios_close+0xe7><== NOT EXECUTED
			}                                                                  
		}                                                                   
		else {                                                              
			tty->back->forw = tty->forw;                                       
  108423:	89 02                	mov    %eax,(%edx)                    <== NOT EXECUTED
		}                                                                   
		rtems_semaphore_delete (tty->isem);                                 
  108425:	83 ec 0c             	sub    $0xc,%esp                      
  108428:	ff 73 14             	pushl  0x14(%ebx)                     
  10842b:	e8 b4 0c 00 00       	call   1090e4 <rtems_semaphore_delete>
		rtems_semaphore_delete (tty->osem);                                 
  108430:	58                   	pop    %eax                           
  108431:	ff 73 18             	pushl  0x18(%ebx)                     
  108434:	e8 ab 0c 00 00       	call   1090e4 <rtems_semaphore_delete>
		rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                  
  108439:	58                   	pop    %eax                           
  10843a:	ff b3 8c 00 00 00    	pushl  0x8c(%ebx)                     
  108440:	e8 9f 0c 00 00       	call   1090e4 <rtems_semaphore_delete>
		if ((tty->device.pollRead == NULL) ||                               
  108445:	83 c4 10             	add    $0x10,%esp                     
  108448:	83 bb a0 00 00 00 00 	cmpl   $0x0,0xa0(%ebx)                
  10844f:	74 09                	je     10845a <rtems_termios_close+0x11c><== ALWAYS TAKEN
  108451:	83 bb b4 00 00 00 02 	cmpl   $0x2,0xb4(%ebx)                <== NOT EXECUTED
  108458:	75 0e                	jne    108468 <rtems_termios_close+0x12a><== NOT EXECUTED
		    (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))      
			rtems_semaphore_delete (tty->rawInBuf.Semaphore);                  
  10845a:	83 ec 0c             	sub    $0xc,%esp                      
  10845d:	ff 73 68             	pushl  0x68(%ebx)                     
  108460:	e8 7f 0c 00 00       	call   1090e4 <rtems_semaphore_delete>
  108465:	83 c4 10             	add    $0x10,%esp                     
		free (tty->rawInBuf.theBuf);                                        
  108468:	83 ec 0c             	sub    $0xc,%esp                      
  10846b:	ff 73 58             	pushl  0x58(%ebx)                     
  10846e:	e8 05 e0 ff ff       	call   106478 <free>                  
		free (tty->rawOutBuf.theBuf);                                       
  108473:	5e                   	pop    %esi                           
  108474:	ff 73 7c             	pushl  0x7c(%ebx)                     
  108477:	e8 fc df ff ff       	call   106478 <free>                  
		free (tty->cbuf);                                                   
  10847c:	59                   	pop    %ecx                           
  10847d:	ff 73 1c             	pushl  0x1c(%ebx)                     
  108480:	e8 f3 df ff ff       	call   106478 <free>                  
		free (tty);                                                         
  108485:	89 1c 24             	mov    %ebx,(%esp)                    
  108488:	e8 eb df ff ff       	call   106478 <free>                  
  10848d:	83 c4 10             	add    $0x10,%esp                     
	}                                                                    
	rtems_semaphore_release (rtems_termios_ttyMutex);                    
  108490:	83 ec 0c             	sub    $0xc,%esp                      
  108493:	ff 35 d4 d6 11 00    	pushl  0x11d6d4                       
  108499:	e8 be 0d 00 00       	call   10925c <rtems_semaphore_release>
	return RTEMS_SUCCESSFUL;                                             
}                                                                     
  10849e:	31 c0                	xor    %eax,%eax                      
  1084a0:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1084a3:	5b                   	pop    %ebx                           
  1084a4:	5e                   	pop    %esi                           
  1084a5:	c9                   	leave                                 
  1084a6:	c3                   	ret                                   
                                                                      

001073a7 <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) {
  1073a7:	55                   	push   %ebp                           
  1073a8:	89 e5                	mov    %esp,%ebp                      
  1073aa:	83 ec 08             	sub    $0x8,%esp                      
  1073ad:	8b 55 08             	mov    0x8(%ebp),%edx                 
	rtems_status_code sc;                                                
                                                                      
	/*                                                                   
	 * sum up character count already sent                               
	 */                                                                  
	tty->t_dqlen += len;                                                 
  1073b0:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1073b3:	01 82 90 00 00 00    	add    %eax,0x90(%edx)                
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {       
  1073b9:	83 ba b4 00 00 00 02 	cmpl   $0x2,0xb4(%edx)                
  1073c0:	75 1f                	jne    1073e1 <rtems_termios_dequeue_characters+0x3a><== ALWAYS TAKEN
		/*                                                                  
		 * send wake up to transmitter task                                 
		 */                                                                 
		sc = rtems_event_send(tty->txTaskId,                                
  1073c2:	50                   	push   %eax                           <== NOT EXECUTED
  1073c3:	50                   	push   %eax                           <== NOT EXECUTED
  1073c4:	6a 02                	push   $0x2                           <== NOT EXECUTED
  1073c6:	ff b2 c8 00 00 00    	pushl  0xc8(%edx)                     <== NOT EXECUTED
  1073cc:	e8 13 19 00 00       	call   108ce4 <rtems_event_send>      <== NOT EXECUTED
				      TERMIOS_TX_START_EVENT);                                    
		if (sc != RTEMS_SUCCESSFUL)                                         
  1073d1:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1073d4:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1073d6:	74 2f                	je     107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
			rtems_fatal_error_occurred (sc);                                   
  1073d8:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1073db:	50                   	push   %eax                           <== NOT EXECUTED
  1073dc:	e8 b3 23 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
		return 0; /* nothing to output in IRQ... */                         
	}                                                                    
	else if (tty->t_line == PPPDISC ) {                                  
  1073e1:	83 ba cc 00 00 00 05 	cmpl   $0x5,0xcc(%edx)                
  1073e8:	75 14                	jne    1073fe <rtems_termios_dequeue_characters+0x57><== ALWAYS TAKEN
		/*                                                                  
		 * call any line discipline start function                          
		 */                                                                 
		if (rtems_termios_linesw[tty->t_line].l_start != NULL) {            
  1073ea:	a1 00 d5 11 00       	mov    0x11d500,%eax                  <== NOT EXECUTED
  1073ef:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1073f1:	74 14                	je     107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
			rtems_termios_linesw[tty->t_line].l_start(tty);                    
  1073f3:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1073f6:	52                   	push   %edx                           <== NOT EXECUTED
  1073f7:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1073f9:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1073fc:	eb 09                	jmp    107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
		}                                                                   
		return 0; /* nothing to output in IRQ... */                         
	}                                                                    
	else {                                                               
		return rtems_termios_refill_transmitter(tty);                       
  1073fe:	89 55 08             	mov    %edx,0x8(%ebp)                 
	}                                                                    
}                                                                     
  107401:	c9                   	leave                                 
			rtems_termios_linesw[tty->t_line].l_start(tty);                    
		}                                                                   
		return 0; /* nothing to output in IRQ... */                         
	}                                                                    
	else {                                                               
		return rtems_termios_refill_transmitter(tty);                       
  107402:	e9 d3 fd ff ff       	jmp    1071da <rtems_termios_refill_transmitter>
	}                                                                    
}                                                                     
  107407:	31 c0                	xor    %eax,%eax                      
  107409:	c9                   	leave                                 <== NOT EXECUTED
  10740a:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010740b <rtems_termios_enqueue_raw_characters>: * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len) {
  10740b:	55                   	push   %ebp                           <== NOT EXECUTED
  10740c:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10740e:	57                   	push   %edi                           <== NOT EXECUTED
  10740f:	56                   	push   %esi                           <== NOT EXECUTED
  107410:	53                   	push   %ebx                           <== NOT EXECUTED
  107411:	83 ec 1c             	sub    $0x1c,%esp                     <== NOT EXECUTED
  107414:	8b 5d 08             	mov    0x8(%ebp),%ebx                 <== NOT EXECUTED
	char c;                                                              
	int dropped = 0;                                                     
	bool flow_rcv = false; /* true, if flow control char received */     
	rtems_interrupt_level level;                                         
                                                                      
	if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {              
  107417:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                <== NOT EXECUTED
  10741d:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  107420:	83 b8 5c d4 11 00 00 	cmpl   $0x0,0x11d45c(%eax)            <== NOT EXECUTED
  107427:	75 37                	jne    107460 <rtems_termios_enqueue_raw_characters+0x55><== NOT EXECUTED
		    if ((tty->flow_ctrl & FL_OSTOP) ||                              
			(tty->rawOutBufState == rob_idle)) {                               
		      /* if tx is stopped due to XOFF or out of data */             
		      /*    call write function here                 */             
		      tty->flow_ctrl |= FL_ISNTXOF;                                 
		      (*tty->device.write)(tty->minor,                              
  107429:	8d 43 4a             	lea    0x4a(%ebx),%eax                <== NOT EXECUTED
  10742c:	89 45 e4             	mov    %eax,-0x1c(%ebp)               <== NOT EXECUTED
                                                                      
			/*                                                                 
			 * check to see if rcv wakeup callback was set                     
			 */                                                                
			if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {  
			  (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);      
  10742f:	8d 53 30             	lea    0x30(%ebx),%edx                <== NOT EXECUTED
  107432:	89 55 f0             	mov    %edx,-0x10(%ebp)               <== NOT EXECUTED
  107435:	31 ff                	xor    %edi,%edi                      <== NOT EXECUTED
  107437:	c6 45 ea 00          	movb   $0x0,-0x16(%ebp)               <== NOT EXECUTED
  10743b:	e9 27 02 00 00       	jmp    107667 <rtems_termios_enqueue_raw_characters+0x25c><== NOT EXECUTED
	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++;                                                      
  107440:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 <== NOT EXECUTED
  107443:	0f be 11             	movsbl (%ecx),%edx                    <== NOT EXECUTED
  107446:	41                   	inc    %ecx                           <== NOT EXECUTED
  107447:	89 4d 0c             	mov    %ecx,0xc(%ebp)                 <== NOT EXECUTED
	    rtems_termios_linesw[tty->t_line].l_rint(c,tty);                 
  10744a:	56                   	push   %esi                           <== NOT EXECUTED
  10744b:	56                   	push   %esi                           <== NOT EXECUTED
  10744c:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                <== NOT EXECUTED
  107452:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  107455:	53                   	push   %ebx                           <== NOT EXECUTED
  107456:	52                   	push   %edx                           <== NOT EXECUTED
  107457:	ff 90 5c d4 11 00    	call   *0x11d45c(%eax)                <== NOT EXECUTED
  10745d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
	int dropped = 0;                                                     
	bool flow_rcv = false; /* true, if flow control char received */     
	rtems_interrupt_level level;                                         
                                                                      
	if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {              
	  while (len--) {                                                    
  107460:	ff 4d 10             	decl   0x10(%ebp)                     <== NOT EXECUTED
  107463:	83 7d 10 ff          	cmpl   $0xffffffff,0x10(%ebp)         <== NOT EXECUTED
  107467:	75 d7                	jne    107440 <rtems_termios_enqueue_raw_characters+0x35><== NOT EXECUTED
	  }                                                                  
                                                                      
	  /*                                                                 
	   * check to see if rcv wakeup callback was set                     
	   */                                                                
	  if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {  
  107469:	83 bb e4 00 00 00 00 	cmpl   $0x0,0xe4(%ebx)                <== NOT EXECUTED
  107470:	0f 85 11 02 00 00    	jne    107687 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
  107476:	8b 93 dc 00 00 00    	mov    0xdc(%ebx),%edx                <== NOT EXECUTED
  10747c:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  10747e:	0f 84 03 02 00 00    	je     107687 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
	    (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);      
  107484:	51                   	push   %ecx                           <== NOT EXECUTED
  107485:	51                   	push   %ecx                           <== NOT EXECUTED
  107486:	ff b3 e0 00 00 00    	pushl  0xe0(%ebx)                     <== NOT EXECUTED
  10748c:	8d 43 30             	lea    0x30(%ebx),%eax                <== NOT EXECUTED
  10748f:	50                   	push   %eax                           <== NOT EXECUTED
  107490:	ff d2                	call   *%edx                          <== NOT EXECUTED
	    tty->tty_rcvwakeup = 1;                                          
  107492:	c7 83 e4 00 00 00 01 	movl   $0x1,0xe4(%ebx)                <== NOT EXECUTED
  107499:	00 00 00                                                    
  10749c:	31 ff                	xor    %edi,%edi                      <== NOT EXECUTED
  10749e:	e9 df 01 00 00       	jmp    107682 <rtems_termios_enqueue_raw_characters+0x277><== NOT EXECUTED
    	  }                                                              
	  return 0;                                                          
	}                                                                    
                                                                      
	while (len--) {                                                      
	  c = *buf++;                                                        
  1074a3:	8b 45 0c             	mov    0xc(%ebp),%eax                 <== NOT EXECUTED
  1074a6:	8a 00                	mov    (%eax),%al                     <== NOT EXECUTED
  1074a8:	88 45 eb             	mov    %al,-0x15(%ebp)                <== NOT EXECUTED
	  /* FIXME: implement IXANY: any character restarts output */        
	  /* if incoming XON/XOFF controls outgoing stream: */               
	  if (tty->flow_ctrl & FL_MDXON) {                                   
  1074ab:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1074b1:	f6 c4 02             	test   $0x2,%ah                       <== NOT EXECUTED
  1074b4:	74 43                	je     1074f9 <rtems_termios_enqueue_raw_characters+0xee><== NOT EXECUTED
	    /* if received char is V_STOP and V_START (both are equal value) */
	    if (c == tty->termios.c_cc[VSTOP]) {                             
  1074b6:	0f be 55 eb          	movsbl -0x15(%ebp),%edx               <== NOT EXECUTED
  1074ba:	0f b6 43 4a          	movzbl 0x4a(%ebx),%eax                <== NOT EXECUTED
  1074be:	39 c2                	cmp    %eax,%edx                      <== NOT EXECUTED
  1074c0:	75 1e                	jne    1074e0 <rtems_termios_enqueue_raw_characters+0xd5><== NOT EXECUTED
	      if (c == tty->termios.c_cc[VSTART]) {                          
  1074c2:	0f b6 43 49          	movzbl 0x49(%ebx),%eax                <== NOT EXECUTED
  1074c6:	39 c2                	cmp    %eax,%edx                      <== NOT EXECUTED
  1074c8:	75 0b                	jne    1074d5 <rtems_termios_enqueue_raw_characters+0xca><== NOT EXECUTED
		/* received VSTOP and VSTART==VSTOP? */                             
		/* then toggle "stop output" status  */                             
		tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;                       
  1074ca:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1074d0:	83 f0 10             	xor    $0x10,%eax                     <== NOT EXECUTED
  1074d3:	eb 1c                	jmp    1074f1 <rtems_termios_enqueue_raw_characters+0xe6><== NOT EXECUTED
	      }                                                              
	      else {                                                         
		/* VSTOP received (other code than VSTART) */                       
		/* stop output                             */                       
		tty->flow_ctrl |= FL_ORCVXOF;                                       
  1074d5:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1074db:	83 c8 10             	or     $0x10,%eax                     <== NOT EXECUTED
  1074de:	eb 11                	jmp    1074f1 <rtems_termios_enqueue_raw_characters+0xe6><== NOT EXECUTED
	      }                                                              
	      flow_rcv = true;                                               
	    }                                                                
	    else if (c == tty->termios.c_cc[VSTART]) {                       
  1074e0:	0f b6 43 49          	movzbl 0x49(%ebx),%eax                <== NOT EXECUTED
  1074e4:	39 c2                	cmp    %eax,%edx                      <== NOT EXECUTED
  1074e6:	75 11                	jne    1074f9 <rtems_termios_enqueue_raw_characters+0xee><== NOT EXECUTED
	      /* VSTART received */                                          
	      /* restart output  */                                          
	      tty->flow_ctrl &= ~FL_ORCVXOF;                                 
  1074e8:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1074ee:	83 e0 ef             	and    $0xffffffef,%eax               <== NOT EXECUTED
  1074f1:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
  1074f7:	eb 06                	jmp    1074ff <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
	      flow_rcv = true;                                               
	    }                                                                
	  }                                                                  
	  if (flow_rcv) {                                                    
  1074f9:	80 7d ea 00          	cmpb   $0x0,-0x16(%ebp)               <== NOT EXECUTED
  1074fd:	74 55                	je     107554 <rtems_termios_enqueue_raw_characters+0x149><== NOT EXECUTED
	    /* restart output according to FL_ORCVXOF flag */                
	    if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {    
  1074ff:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  107505:	83 e0 30             	and    $0x30,%eax                     <== NOT EXECUTED
  107508:	c6 45 ea 01          	movb   $0x1,-0x16(%ebp)               <== NOT EXECUTED
  10750c:	83 f8 20             	cmp    $0x20,%eax                     <== NOT EXECUTED
  10750f:	0f 85 4f 01 00 00    	jne    107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
	      /* disable interrupts    */                                    
	      rtems_interrupt_disable(level);                                
  107515:	9c                   	pushf                                 <== NOT EXECUTED
  107516:	fa                   	cli                                   <== NOT EXECUTED
  107517:	5e                   	pop    %esi                           <== NOT EXECUTED
	      tty->flow_ctrl &= ~FL_OSTOP;                                   
  107518:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  10751e:	83 e0 df             	and    $0xffffffdf,%eax               <== NOT EXECUTED
  107521:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
	      /* check for chars in output buffer (or rob_state?) */         
	      if (tty->rawOutBufState != rob_idle) {                         
  107527:	83 bb 94 00 00 00 00 	cmpl   $0x0,0x94(%ebx)                <== NOT EXECUTED
  10752e:	74 19                	je     107549 <rtems_termios_enqueue_raw_characters+0x13e><== NOT EXECUTED
	      /* if chars available, call write function... */               
		(*tty->device.write)(tty->minor,                                    
  107530:	8b 83 84 00 00 00    	mov    0x84(%ebx),%eax                <== NOT EXECUTED
  107536:	52                   	push   %edx                           <== NOT EXECUTED
  107537:	6a 01                	push   $0x1                           <== NOT EXECUTED
  107539:	03 43 7c             	add    0x7c(%ebx),%eax                <== NOT EXECUTED
  10753c:	50                   	push   %eax                           <== NOT EXECUTED
  10753d:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  107540:	ff 93 a4 00 00 00    	call   *0xa4(%ebx)                    <== NOT EXECUTED
  107546:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
		     &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);               
	      }                                                              
	      /* reenable interrupts */                                      
	      rtems_interrupt_enable(level);                                 
  107549:	56                   	push   %esi                           <== NOT EXECUTED
  10754a:	9d                   	popf                                  <== NOT EXECUTED
  10754b:	c6 45 ea 01          	movb   $0x1,-0x16(%ebp)               <== NOT EXECUTED
  10754f:	e9 10 01 00 00       	jmp    107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
	    }                                                                
	  }                                                                  
	  else {                                                             
		newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;            
  107554:	8b 43 60             	mov    0x60(%ebx),%eax                <== NOT EXECUTED
  107557:	8b 4b 64             	mov    0x64(%ebx),%ecx                <== NOT EXECUTED
  10755a:	40                   	inc    %eax                           <== NOT EXECUTED
  10755b:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  10755d:	f7 f1                	div    %ecx                           <== NOT EXECUTED
  10755f:	89 d6                	mov    %edx,%esi                      <== NOT EXECUTED
		/* if chars_in_buffer > highwater                */                 
		rtems_interrupt_disable(level);                                     
  107561:	9c                   	pushf                                 <== NOT EXECUTED
  107562:	fa                   	cli                                   <== NOT EXECUTED
  107563:	8f 45 ec             	popl   -0x14(%ebp)                    <== NOT EXECUTED
		if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)           
  107566:	8b 4b 5c             	mov    0x5c(%ebx),%ecx                <== NOT EXECUTED
  107569:	8b 43 64             	mov    0x64(%ebx),%eax                <== NOT EXECUTED
  10756c:	8b 53 64             	mov    0x64(%ebx),%edx                <== NOT EXECUTED
  10756f:	29 c8                	sub    %ecx,%eax                      <== NOT EXECUTED
  107571:	01 f0                	add    %esi,%eax                      <== NOT EXECUTED
  107573:	89 d1                	mov    %edx,%ecx                      <== NOT EXECUTED
  107575:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  107577:	f7 f1                	div    %ecx                           <== NOT EXECUTED
  107579:	3b 93 c0 00 00 00    	cmp    0xc0(%ebx),%edx                <== NOT EXECUTED
  10757f:	0f 86 98 00 00 00    	jbe    10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
  107585:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  10758b:	a8 01                	test   $0x1,%al                       <== NOT EXECUTED
  10758d:	0f 85 8a 00 00 00    	jne    10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
		      % tty->rawInBuf.Size)                                         
		     > tty->highwater) &&                                           
		    !(tty->flow_ctrl & FL_IREQXOF)) {                               
		  /* incoming data stream should be stopped */                      
		  tty->flow_ctrl |= FL_IREQXOF;                                     
  107593:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  107599:	83 c8 01             	or     $0x1,%eax                      <== NOT EXECUTED
  10759c:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
		  if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                    
  1075a2:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1075a8:	25 02 04 00 00       	and    $0x402,%eax                    <== NOT EXECUTED
  1075ad:	3d 00 04 00 00       	cmp    $0x400,%eax                    <== NOT EXECUTED
  1075b2:	75 33                	jne    1075e7 <rtems_termios_enqueue_raw_characters+0x1dc><== NOT EXECUTED
		      ==                (FL_MDXOF             ) ){                  
		    if ((tty->flow_ctrl & FL_OSTOP) ||                              
  1075b4:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1075ba:	a8 20                	test   $0x20,%al                      <== NOT EXECUTED
  1075bc:	75 09                	jne    1075c7 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
  1075be:	83 bb 94 00 00 00 00 	cmpl   $0x0,0x94(%ebx)                <== NOT EXECUTED
  1075c5:	75 56                	jne    10761d <rtems_termios_enqueue_raw_characters+0x212><== 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;                                 
  1075c7:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1075cd:	83 c8 02             	or     $0x2,%eax                      <== NOT EXECUTED
  1075d0:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
		      (*tty->device.write)(tty->minor,                              
  1075d6:	51                   	push   %ecx                           <== NOT EXECUTED
  1075d7:	6a 01                	push   $0x1                           <== NOT EXECUTED
  1075d9:	ff 75 e4             	pushl  -0x1c(%ebp)                    <== NOT EXECUTED
  1075dc:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  1075df:	ff 93 a4 00 00 00    	call   *0xa4(%ebx)                    <== NOT EXECUTED
  1075e5:	eb 33                	jmp    10761a <rtems_termios_enqueue_raw_characters+0x20f><== NOT EXECUTED
			 (void *)&(tty->termios.c_cc[VSTOP]),                              
			 1);                                                               
		    }                                                               
		  }                                                                 
		  else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))               
  1075e7:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1075ed:	25 04 01 00 00       	and    $0x104,%eax                    <== NOT EXECUTED
  1075f2:	3d 00 01 00 00       	cmp    $0x100,%eax                    <== NOT EXECUTED
  1075f7:	75 24                	jne    10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
			   ==                (FL_MDRTS             ) ) {                   
		    tty->flow_ctrl |= FL_IRTSOFF;                                   
  1075f9:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1075ff:	83 c8 04             	or     $0x4,%eax                      <== NOT EXECUTED
  107602:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
		    /* deactivate RTS line */                                       
		    if (tty->device.stopRemoteTx != NULL) {                         
  107608:	8b 83 ac 00 00 00    	mov    0xac(%ebx),%eax                <== NOT EXECUTED
  10760e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107610:	74 0b                	je     10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
		      tty->device.stopRemoteTx(tty->minor);                         
  107612:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107615:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  107618:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10761a:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
		    }                                                               
		  }                                                                 
		}                                                                   
		/* reenable interrupts */                                           
		rtems_interrupt_enable(level);                                      
  10761d:	ff 75 ec             	pushl  -0x14(%ebp)                    <== NOT EXECUTED
  107620:	9d                   	popf                                  <== NOT EXECUTED
                                                                      
		if (newTail == tty->rawInBuf.Head) {                                
  107621:	8b 43 5c             	mov    0x5c(%ebx),%eax                <== NOT EXECUTED
  107624:	39 c6                	cmp    %eax,%esi                      <== NOT EXECUTED
  107626:	75 03                	jne    10762b <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
		        dropped++;                                                  
  107628:	47                   	inc    %edi                           <== NOT EXECUTED
  107629:	eb 39                	jmp    107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
		}                                                                   
		else {                                                              
		        tty->rawInBuf.theBuf[newTail] = c;                          
  10762b:	8b 43 58             	mov    0x58(%ebx),%eax                <== NOT EXECUTED
  10762e:	8a 55 eb             	mov    -0x15(%ebp),%dl                <== NOT EXECUTED
  107631:	88 14 30             	mov    %dl,(%eax,%esi,1)              <== NOT EXECUTED
		        tty->rawInBuf.Tail = newTail;                               
  107634:	89 73 60             	mov    %esi,0x60(%ebx)                <== NOT EXECUTED
                                                                      
			/*                                                                 
			 * check to see if rcv wakeup callback was set                     
			 */                                                                
			if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {  
  107637:	83 bb e4 00 00 00 00 	cmpl   $0x0,0xe4(%ebx)                <== NOT EXECUTED
  10763e:	75 24                	jne    107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
  107640:	8b 83 dc 00 00 00    	mov    0xdc(%ebx),%eax                <== NOT EXECUTED
  107646:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107648:	74 1a                	je     107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
			  (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);      
  10764a:	52                   	push   %edx                           <== NOT EXECUTED
  10764b:	52                   	push   %edx                           <== NOT EXECUTED
  10764c:	ff b3 e0 00 00 00    	pushl  0xe0(%ebx)                     <== NOT EXECUTED
  107652:	ff 75 f0             	pushl  -0x10(%ebp)                    <== NOT EXECUTED
  107655:	ff d0                	call   *%eax                          <== NOT EXECUTED
			  tty->tty_rcvwakeup = 1;                                          
  107657:	c7 83 e4 00 00 00 01 	movl   $0x1,0xe4(%ebx)                <== NOT EXECUTED
  10765e:	00 00 00                                                    
  107661:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    	  }                                                              
	  return 0;                                                          
	}                                                                    
                                                                      
	while (len--) {                                                      
	  c = *buf++;                                                        
  107664:	ff 45 0c             	incl   0xc(%ebp)                      <== NOT EXECUTED
	    tty->tty_rcvwakeup = 1;                                          
    	  }                                                              
	  return 0;                                                          
	}                                                                    
                                                                      
	while (len--) {                                                      
  107667:	ff 4d 10             	decl   0x10(%ebp)                     <== NOT EXECUTED
  10766a:	83 7d 10 ff          	cmpl   $0xffffffff,0x10(%ebp)         <== NOT EXECUTED
  10766e:	0f 85 2f fe ff ff    	jne    1074a3 <rtems_termios_enqueue_raw_characters+0x98><== NOT EXECUTED
			  tty->tty_rcvwakeup = 1;                                          
			}                                                                  
		}                                                                   
	  }                                                                  
	}                                                                    
	tty->rawInBufDropped += dropped;                                     
  107674:	01 7b 78             	add    %edi,0x78(%ebx)                <== NOT EXECUTED
	rtems_semaphore_release (tty->rawInBuf.Semaphore);                   
  107677:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10767a:	ff 73 68             	pushl  0x68(%ebx)                     <== NOT EXECUTED
  10767d:	e8 da 1b 00 00       	call   10925c <rtems_semaphore_release><== NOT EXECUTED
  107682:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107685:	eb 02                	jmp    107689 <rtems_termios_enqueue_raw_characters+0x27e><== NOT EXECUTED
	return dropped;                                                      
  107687:	31 ff                	xor    %edi,%edi                      <== NOT EXECUTED
}                                                                     
  107689:	89 f8                	mov    %edi,%eax                      <== NOT EXECUTED
  10768b:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  10768e:	5b                   	pop    %ebx                           <== NOT EXECUTED
  10768f:	5e                   	pop    %esi                           <== NOT EXECUTED
  107690:	5f                   	pop    %edi                           <== NOT EXECUTED
  107691:	c9                   	leave                                 <== NOT EXECUTED
  107692:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00107164 <rtems_termios_initialize>: struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) {
  107164:	55                   	push   %ebp                           
  107165:	89 e5                	mov    %esp,%ebp                      
  107167:	83 ec 08             	sub    $0x8,%esp                      
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * Create the mutex semaphore for the tty list                      
   */                                                                 
  if (!rtems_termios_ttyMutex) {                                      
  10716a:	83 3d d4 d6 11 00 00 	cmpl   $0x0,0x11d6d4                  
  107171:	75 28                	jne    10719b <rtems_termios_initialize+0x37><== NEVER TAKEN
    sc = rtems_semaphore_create (                                     
  107173:	83 ec 0c             	sub    $0xc,%esp                      
  107176:	68 d4 d6 11 00       	push   $0x11d6d4                      
  10717b:	6a 00                	push   $0x0                           
  10717d:	6a 54                	push   $0x54                          
  10717f:	6a 01                	push   $0x1                           
  107181:	68 69 6d 52 54       	push   $0x54526d69                    
  107186:	e8 b5 1d 00 00       	call   108f40 <rtems_semaphore_create>
      rtems_build_name ('T', 'R', 'm', 'i'),                          
      1,                                                              
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &rtems_termios_ttyMutex);                                       
    if (sc != RTEMS_SUCCESSFUL)                                       
  10718b:	83 c4 20             	add    $0x20,%esp                     
  10718e:	85 c0                	test   %eax,%eax                      
  107190:	74 09                	je     10719b <rtems_termios_initialize+0x37><== ALWAYS TAKEN
      rtems_fatal_error_occurred (sc);                                
  107192:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107195:	50                   	push   %eax                           <== NOT EXECUTED
  107196:	e8 f9 25 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
  }                                                                   
}                                                                     
  10719b:	c9                   	leave                                 
  10719c:	c3                   	ret                                   
                                                                      

00107fe9 <rtems_termios_ioctl>: } } rtems_status_code rtems_termios_ioctl (void *arg) {
  107fe9:	55                   	push   %ebp                           <== NOT EXECUTED
  107fea:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107fec:	57                   	push   %edi                           <== NOT EXECUTED
  107fed:	56                   	push   %esi                           <== NOT EXECUTED
  107fee:	53                   	push   %ebx                           <== NOT EXECUTED
  107fef:	83 ec 20             	sub    $0x20,%esp                     <== NOT EXECUTED
	rtems_libio_ioctl_args_t *args = arg;                                
	struct rtems_termios_tty *tty = args->iop->data1;                    
  107ff2:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  107ff5:	8b 02                	mov    (%edx),%eax                    <== NOT EXECUTED
  107ff7:	8b 58 28             	mov    0x28(%eax),%ebx                <== NOT EXECUTED
	struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer; 
  107ffa:	8b 72 08             	mov    0x8(%edx),%esi                 <== NOT EXECUTED
	rtems_status_code sc;                                                
                                                                      
 	args->ioctl_return = 0;                                             
  107ffd:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)                 <== NOT EXECUTED
	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  108004:	6a 00                	push   $0x0                           <== NOT EXECUTED
  108006:	6a 00                	push   $0x0                           <== NOT EXECUTED
  108008:	ff 73 18             	pushl  0x18(%ebx)                     <== NOT EXECUTED
  10800b:	e8 64 11 00 00       	call   109174 <rtems_semaphore_obtain><== NOT EXECUTED
  108010:	89 45 e0             	mov    %eax,-0x20(%ebp)               <== NOT EXECUTED
	if (sc != RTEMS_SUCCESSFUL) {                                        
  108013:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108016:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108018:	74 0b                	je     108025 <rtems_termios_ioctl+0x3c><== NOT EXECUTED
		args->ioctl_return = sc;                                            
  10801a:	8b 4d 08             	mov    0x8(%ebp),%ecx                 <== NOT EXECUTED
  10801d:	89 41 0c             	mov    %eax,0xc(%ecx)                 <== NOT EXECUTED
  108020:	e9 0e 03 00 00       	jmp    108333 <rtems_termios_ioctl+0x34a><== NOT EXECUTED
		return sc;                                                          
	}                                                                    
	switch (args->command) {                                             
  108025:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  108028:	8b 42 04             	mov    0x4(%edx),%eax                 <== NOT EXECUTED
  10802b:	83 f8 04             	cmp    $0x4,%eax                      <== NOT EXECUTED
  10802e:	0f 84 56 02 00 00    	je     10828a <rtems_termios_ioctl+0x2a1><== NOT EXECUTED
  108034:	77 10                	ja     108046 <rtems_termios_ioctl+0x5d><== NOT EXECUTED
  108036:	83 f8 02             	cmp    $0x2,%eax                      <== NOT EXECUTED
  108039:	74 75                	je     1080b0 <rtems_termios_ioctl+0xc7><== NOT EXECUTED
  10803b:	0f 87 27 02 00 00    	ja     108268 <rtems_termios_ioctl+0x27f><== NOT EXECUTED
  108041:	48                   	dec    %eax                           <== NOT EXECUTED
  108042:	75 2f                	jne    108073 <rtems_termios_ioctl+0x8a><== NOT EXECUTED
  108044:	eb 55                	jmp    10809b <rtems_termios_ioctl+0xb2><== NOT EXECUTED
  108046:	3d 7f 66 04 40       	cmp    $0x4004667f,%eax               <== NOT EXECUTED
  10804b:	0f 84 ae 02 00 00    	je     1082ff <rtems_termios_ioctl+0x316><== NOT EXECUTED
  108051:	77 0a                	ja     10805d <rtems_termios_ioctl+0x74><== NOT EXECUTED
  108053:	83 f8 05             	cmp    $0x5,%eax                      <== NOT EXECUTED
  108056:	75 1b                	jne    108073 <rtems_termios_ioctl+0x8a><== NOT EXECUTED
  108058:	e9 17 02 00 00       	jmp    108274 <rtems_termios_ioctl+0x28b><== NOT EXECUTED
  10805d:	3d 1a 74 04 40       	cmp    $0x4004741a,%eax               <== NOT EXECUTED
  108062:	0f 84 87 02 00 00    	je     1082ef <rtems_termios_ioctl+0x306><== NOT EXECUTED
  108068:	3d 1b 74 04 80       	cmp    $0x8004741b,%eax               <== NOT EXECUTED
  10806d:	0f 84 2a 02 00 00    	je     10829d <rtems_termios_ioctl+0x2b4><== NOT EXECUTED
	default:                                                             
		if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {            
  108073:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                <== NOT EXECUTED
  108079:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  10807c:	8b 80 64 d4 11 00    	mov    0x11d464(%eax),%eax            <== NOT EXECUTED
  108082:	c7 45 e0 0a 00 00 00 	movl   $0xa,-0x20(%ebp)               <== NOT EXECUTED
  108089:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10808b:	0f 84 8b 02 00 00    	je     10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
			sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);          
  108091:	52                   	push   %edx                           <== NOT EXECUTED
  108092:	52                   	push   %edx                           <== NOT EXECUTED
  108093:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  108096:	e9 49 02 00 00       	jmp    1082e4 <rtems_termios_ioctl+0x2fb><== NOT EXECUTED
			sc = RTEMS_INVALID_NUMBER;                                         
		}                                                                   
		break;                                                              
                                                                      
	case RTEMS_IO_GET_ATTRIBUTES:                                        
		*(struct termios *)args->buffer = tty->termios;                     
  10809b:	8b 4d 08             	mov    0x8(%ebp),%ecx                 <== NOT EXECUTED
  10809e:	8b 79 08             	mov    0x8(%ecx),%edi                 <== NOT EXECUTED
  1080a1:	8d 73 30             	lea    0x30(%ebx),%esi                <== NOT EXECUTED
  1080a4:	b9 09 00 00 00       	mov    $0x9,%ecx                      <== NOT EXECUTED
  1080a9:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       <== NOT EXECUTED
  1080ab:	e9 6c 02 00 00       	jmp    10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
		break;                                                              
                                                                      
	case RTEMS_IO_SET_ATTRIBUTES:                                        
		tty->termios = *(struct termios *)args->buffer;                     
  1080b0:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  1080b3:	8b 70 08             	mov    0x8(%eax),%esi                 <== NOT EXECUTED
  1080b6:	8d 7b 30             	lea    0x30(%ebx),%edi                <== NOT EXECUTED
  1080b9:	b9 09 00 00 00       	mov    $0x9,%ecx                      <== NOT EXECUTED
  1080be:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
  1080c0:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1080c6:	f6 c4 02             	test   $0x2,%ah                       <== NOT EXECUTED
  1080c9:	74 57                	je     108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
  1080cb:	f6 43 31 04          	testb  $0x4,0x31(%ebx)                <== NOT EXECUTED
  1080cf:	75 51                	jne    108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
      !(tty->termios.c_iflag & IXON)) {                               
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);                       
  1080d1:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1080d7:	25 ef fd ff ff       	and    $0xfffffdef,%eax               <== NOT EXECUTED
  1080dc:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
  1080e2:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1080e8:	a8 20                	test   $0x20,%al                      <== NOT EXECUTED
  1080ea:	74 36                	je     108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
  1080ec:	9c                   	pushf                                 <== NOT EXECUTED
  1080ed:	fa                   	cli                                   <== NOT EXECUTED
  1080ee:	5e                   	pop    %esi                           <== NOT EXECUTED
      tty->flow_ctrl &= ~FL_OSTOP;                                    
  1080ef:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1080f5:	83 e0 df             	and    $0xffffffdf,%eax               <== NOT EXECUTED
  1080f8:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
  1080fe:	83 bb 94 00 00 00 00 	cmpl   $0x0,0x94(%ebx)                <== NOT EXECUTED
  108105:	74 19                	je     108120 <rtems_termios_ioctl+0x137><== NOT EXECUTED
	/* if chars available, call write function... */                     
	(*tty->device.write)(tty->minor,                                     
  108107:	8b 83 84 00 00 00    	mov    0x84(%ebx),%eax                <== NOT EXECUTED
  10810d:	57                   	push   %edi                           <== NOT EXECUTED
  10810e:	6a 01                	push   $0x1                           <== NOT EXECUTED
  108110:	03 43 7c             	add    0x7c(%ebx),%eax                <== NOT EXECUTED
  108113:	50                   	push   %eax                           <== NOT EXECUTED
  108114:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  108117:	ff 93 a4 00 00 00    	call   *0xa4(%ebx)                    <== NOT EXECUTED
  10811d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
		     &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);                
      }                                                               
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
  108120:	56                   	push   %esi                           <== NOT EXECUTED
  108121:	9d                   	popf                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /* check for incoming XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXOF) &&                                 
  108122:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108128:	f6 c4 04             	test   $0x4,%ah                       <== NOT EXECUTED
  10812b:	74 24                	je     108151 <rtems_termios_ioctl+0x168><== NOT EXECUTED
  10812d:	f6 43 31 10          	testb  $0x10,0x31(%ebx)               <== NOT EXECUTED
  108131:	75 1e                	jne    108151 <rtems_termios_ioctl+0x168><== NOT EXECUTED
      !(tty->termios.c_iflag & IXOFF)) {                              
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXOF);                                    
  108133:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108139:	80 e4 fb             	and    $0xfb,%ah                      <== NOT EXECUTED
  10813c:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
    /* FIXME: what happens, if we had sent XOFF but not yet XON? */   
    tty->flow_ctrl &= ~(FL_ISNTXOF);                                  
  108142:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108148:	83 e0 fd             	and    $0xfffffffd,%eax               <== NOT EXECUTED
  10814b:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
  }                                                                   
                                                                      
  /* check for incoming RTS/CTS flow control switched off */          
  if (( tty->flow_ctrl & FL_MDRTS) &&                                 
  108151:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108157:	f6 c4 01             	test   $0x1,%ah                       <== NOT EXECUTED
  10815a:	74 43                	je     10819f <rtems_termios_ioctl+0x1b6><== NOT EXECUTED
  10815c:	83 7b 38 00          	cmpl   $0x0,0x38(%ebx)                <== NOT EXECUTED
  108160:	78 3d                	js     10819f <rtems_termios_ioctl+0x1b6><== NOT EXECUTED
      !(tty->termios.c_cflag & CRTSCTS)) {                            
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
  108162:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108168:	80 e4 fe             	and    $0xfe,%ah                      <== NOT EXECUTED
  10816b:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
                                                                      
    /* restart remote Tx, if it was stopped */                        
    if ((tty->flow_ctrl & FL_IRTSOFF) &&                              
  108171:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108177:	a8 04                	test   $0x4,%al                       <== NOT EXECUTED
  108179:	74 15                	je     108190 <rtems_termios_ioctl+0x1a7><== NOT EXECUTED
  10817b:	8b 83 b0 00 00 00    	mov    0xb0(%ebx),%eax                <== NOT EXECUTED
  108181:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108183:	74 0b                	je     108190 <rtems_termios_ioctl+0x1a7><== NOT EXECUTED
	(tty->device.startRemoteTx != NULL)) {                               
      tty->device.startRemoteTx(tty->minor);                          
  108185:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108188:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  10818b:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10818d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    }                                                                 
    tty->flow_ctrl &= ~(FL_IRTSOFF);                                  
  108190:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  108196:	83 e0 fb             	and    $0xfffffffb,%eax               <== NOT EXECUTED
  108199:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== 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) {                               
  10819f:	83 7b 38 00          	cmpl   $0x0,0x38(%ebx)                <== NOT EXECUTED
  1081a3:	79 0f                	jns    1081b4 <rtems_termios_ioctl+0x1cb><== NOT EXECUTED
    tty->flow_ctrl |= FL_MDRTS;                                       
  1081a5:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1081ab:	80 cc 01             	or     $0x1,%ah                       <== NOT EXECUTED
  1081ae:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
  }                                                                   
  /* check for incoming XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXOFF) {                                 
  1081b4:	f6 43 31 10          	testb  $0x10,0x31(%ebx)               <== NOT EXECUTED
  1081b8:	74 0f                	je     1081c9 <rtems_termios_ioctl+0x1e0><== NOT EXECUTED
    tty->flow_ctrl |= FL_MDXOF;                                       
  1081ba:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1081c0:	80 cc 04             	or     $0x4,%ah                       <== NOT EXECUTED
  1081c3:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
  1081c9:	f6 43 31 04          	testb  $0x4,0x31(%ebx)                <== NOT EXECUTED
  1081cd:	74 0f                	je     1081de <rtems_termios_ioctl+0x1f5><== NOT EXECUTED
    tty->flow_ctrl |= FL_MDXON;                                       
  1081cf:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  1081d5:	80 cc 02             	or     $0x2,%ah                       <== NOT EXECUTED
  1081d8:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
		tty->termios = *(struct termios *)args->buffer;                     
                                                                      
		/* check for and process change in flow control options */          
		termios_set_flowctrl(tty);                                          
                                                                      
		if (tty->termios.c_lflag & ICANON) {                                
  1081de:	f6 43 3c 02          	testb  $0x2,0x3c(%ebx)                <== NOT EXECUTED
  1081e2:	75 45                	jne    108229 <rtems_termios_ioctl+0x240><== NOT EXECUTED
			tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                  
			tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;             
		}                                                                   
		else {                                                              
			rtems_interval ticksPerSecond;                                     
			rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond);
  1081e4:	56                   	push   %esi                           <== NOT EXECUTED
  1081e5:	56                   	push   %esi                           <== NOT EXECUTED
  1081e6:	8d 45 f0             	lea    -0x10(%ebp),%eax               <== NOT EXECUTED
  1081e9:	50                   	push   %eax                           <== NOT EXECUTED
  1081ea:	6a 03                	push   $0x3                           <== NOT EXECUTED
  1081ec:	e8 93 07 00 00       	call   108984 <rtems_clock_get>       <== NOT EXECUTED
			tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;  
  1081f1:	0f b6 43 46          	movzbl 0x46(%ebx),%eax                <== NOT EXECUTED
  1081f5:	0f af 45 f0          	imul   -0x10(%ebp),%eax               <== NOT EXECUTED
  1081f9:	b9 0a 00 00 00       	mov    $0xa,%ecx                      <== NOT EXECUTED
  1081fe:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  108200:	f7 f1                	div    %ecx                           <== NOT EXECUTED
  108202:	89 43 54             	mov    %eax,0x54(%ebx)                <== NOT EXECUTED
			if (tty->termios.c_cc[VTIME]) {                                    
  108205:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108208:	80 7b 46 00          	cmpb   $0x0,0x46(%ebx)                <== NOT EXECUTED
  10820c:	74 15                	je     108223 <rtems_termios_ioctl+0x23a><== NOT EXECUTED
				tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                       
  10820e:	c7 43 6c 00 00 00 00 	movl   $0x0,0x6c(%ebx)                <== NOT EXECUTED
				tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;                  
  108215:	89 43 70             	mov    %eax,0x70(%ebx)                <== NOT EXECUTED
				if (tty->termios.c_cc[VMIN])                                      
  108218:	80 7b 47 00          	cmpb   $0x0,0x47(%ebx)                <== NOT EXECUTED
  10821c:	75 19                	jne    108237 <rtems_termios_ioctl+0x24e><== NOT EXECUTED
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
				else                                                              
					tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;            
  10821e:	89 43 74             	mov    %eax,0x74(%ebx)                <== NOT EXECUTED
  108221:	eb 24                	jmp    108247 <rtems_termios_ioctl+0x25e><== NOT EXECUTED
			}                                                                  
			else {                                                             
				if (tty->termios.c_cc[VMIN]) {                                    
  108223:	80 7b 47 00          	cmpb   $0x0,0x47(%ebx)                <== NOT EXECUTED
  108227:	74 17                	je     108240 <rtems_termios_ioctl+0x257><== NOT EXECUTED
					tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                      
  108229:	c7 43 6c 00 00 00 00 	movl   $0x0,0x6c(%ebx)                <== NOT EXECUTED
					tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                
  108230:	c7 43 70 00 00 00 00 	movl   $0x0,0x70(%ebx)                <== NOT EXECUTED
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
  108237:	c7 43 74 00 00 00 00 	movl   $0x0,0x74(%ebx)                <== NOT EXECUTED
  10823e:	eb 07                	jmp    108247 <rtems_termios_ioctl+0x25e><== NOT EXECUTED
				}                                                                 
				else {                                                            
					tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;                   
  108240:	c7 43 6c 01 00 00 00 	movl   $0x1,0x6c(%ebx)                <== NOT EXECUTED
				}                                                                 
			}                                                                  
		}                                                                   
		if (tty->device.setAttributes)                                      
  108247:	8b 93 a8 00 00 00    	mov    0xa8(%ebx),%edx                <== NOT EXECUTED
  10824d:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  10824f:	0f 84 c7 00 00 00    	je     10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
			(*tty->device.setAttributes)(tty->minor, &tty->termios);           
  108255:	51                   	push   %ecx                           <== NOT EXECUTED
  108256:	51                   	push   %ecx                           <== NOT EXECUTED
  108257:	8d 43 30             	lea    0x30(%ebx),%eax                <== NOT EXECUTED
  10825a:	50                   	push   %eax                           <== NOT EXECUTED
  10825b:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  10825e:	ff d2                	call   *%edx                          <== NOT EXECUTED
  108260:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108263:	e9 b4 00 00 00       	jmp    10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
		break;                                                              
                                                                      
	case RTEMS_IO_TCDRAIN:                                               
		drainOutput (tty);                                                  
  108268:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  10826a:	e8 13 fa ff ff       	call   107c82 <drainOutput>           <== NOT EXECUTED
  10826f:	e9 a8 00 00 00       	jmp    10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
		break;                                                              
                                                                      
	case RTEMS_IO_SNDWAKEUP:                                             
		tty->tty_snd = *wakeup;                                             
  108274:	8b 16                	mov    (%esi),%edx                    <== NOT EXECUTED
  108276:	8b 46 04             	mov    0x4(%esi),%eax                 <== NOT EXECUTED
  108279:	89 83 d8 00 00 00    	mov    %eax,0xd8(%ebx)                <== NOT EXECUTED
  10827f:	89 93 d4 00 00 00    	mov    %edx,0xd4(%ebx)                <== NOT EXECUTED
  108285:	e9 92 00 00 00       	jmp    10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
		break;                                                              
                                                                      
	case RTEMS_IO_RCVWAKEUP:                                             
		tty->tty_rcv = *wakeup;                                             
  10828a:	8b 16                	mov    (%esi),%edx                    <== NOT EXECUTED
  10828c:	8b 46 04             	mov    0x4(%esi),%eax                 <== NOT EXECUTED
  10828f:	89 83 e0 00 00 00    	mov    %eax,0xe0(%ebx)                <== NOT EXECUTED
  108295:	89 93 dc 00 00 00    	mov    %edx,0xdc(%ebx)                <== NOT EXECUTED
  10829b:	eb 7f                	jmp    10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
#if 1 /* FIXME */                                                     
	case TIOCSETD:                                                       
		/*                                                                  
		 * close old line discipline                                        
		 */                                                                 
		if (rtems_termios_linesw[tty->t_line].l_close != NULL) {            
  10829d:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                <== NOT EXECUTED
  1082a3:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  1082a6:	8b 80 50 d4 11 00    	mov    0x11d450(%eax),%eax            <== NOT EXECUTED
  1082ac:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1082ae:	74 0c                	je     1082bc <rtems_termios_ioctl+0x2d3><== NOT EXECUTED
			sc = rtems_termios_linesw[tty->t_line].l_close(tty);               
  1082b0:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1082b3:	53                   	push   %ebx                           <== NOT EXECUTED
  1082b4:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1082b6:	89 45 e0             	mov    %eax,-0x20(%ebp)               <== NOT EXECUTED
  1082b9:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
		}                                                                   
		tty->t_line=*(int*)(args->buffer);                                  
  1082bc:	8b 4d 08             	mov    0x8(%ebp),%ecx                 <== NOT EXECUTED
  1082bf:	8b 41 08             	mov    0x8(%ecx),%eax                 <== NOT EXECUTED
  1082c2:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
  1082c4:	89 83 cc 00 00 00    	mov    %eax,0xcc(%ebx)                <== NOT EXECUTED
		tty->t_sc = NULL; /* ensure that no more valid data */              
  1082ca:	c7 83 d0 00 00 00 00 	movl   $0x0,0xd0(%ebx)                <== NOT EXECUTED
  1082d1:	00 00 00                                                    
		/*                                                                  
		 * open new line discipline                                         
		 */                                                                 
		if (rtems_termios_linesw[tty->t_line].l_open != NULL) {             
  1082d4:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  1082d7:	8b 80 4c d4 11 00    	mov    0x11d44c(%eax),%eax            <== NOT EXECUTED
  1082dd:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1082df:	74 3b                	je     10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
			sc = rtems_termios_linesw[tty->t_line].l_open(tty);                
  1082e1:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1082e4:	53                   	push   %ebx                           <== NOT EXECUTED
  1082e5:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1082e7:	89 45 e0             	mov    %eax,-0x20(%ebp)               <== NOT EXECUTED
  1082ea:	e9 71 ff ff ff       	jmp    108260 <rtems_termios_ioctl+0x277><== NOT EXECUTED
		}                                                                   
		break;                                                              
	case TIOCGETD:                                                       
		*(int*)(args->buffer)=tty->t_line;                                  
  1082ef:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  1082f2:	8b 50 08             	mov    0x8(%eax),%edx                 <== NOT EXECUTED
  1082f5:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                <== NOT EXECUTED
  1082fb:	89 02                	mov    %eax,(%edx)                    <== NOT EXECUTED
  1082fd:	eb 1d                	jmp    10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
		break;                                                              
#endif                                                                
 	case FIONREAD:                                                      
		{                                                                   
		int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;                
  1082ff:	8b 53 60             	mov    0x60(%ebx),%edx                <== NOT EXECUTED
  108302:	8b 43 5c             	mov    0x5c(%ebx),%eax                <== NOT EXECUTED
		if ( rawnc < 0 )                                                    
  108305:	29 c2                	sub    %eax,%edx                      <== NOT EXECUTED
  108307:	79 05                	jns    10830e <rtems_termios_ioctl+0x325><== NOT EXECUTED
			rawnc += tty->rawInBuf.Size;                                       
  108309:	8b 43 64             	mov    0x64(%ebx),%eax                <== NOT EXECUTED
  10830c:	01 c2                	add    %eax,%edx                      <== NOT EXECUTED
		/* Half guess that this is the right operation */                   
		*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;           
  10830e:	8b 4d 08             	mov    0x8(%ebp),%ecx                 <== NOT EXECUTED
  108311:	8b 41 08             	mov    0x8(%ecx),%eax                 <== NOT EXECUTED
  108314:	03 53 20             	add    0x20(%ebx),%edx                <== NOT EXECUTED
  108317:	2b 53 24             	sub    0x24(%ebx),%edx                <== NOT EXECUTED
  10831a:	89 10                	mov    %edx,(%eax)                    <== NOT EXECUTED
		}                                                                   
		break;                                                              
	}                                                                    
	rtems_semaphore_release (tty->osem);                                 
  10831c:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10831f:	ff 73 18             	pushl  0x18(%ebx)                     <== NOT EXECUTED
  108322:	e8 35 0f 00 00       	call   10925c <rtems_semaphore_release><== NOT EXECUTED
	args->ioctl_return = sc;                                             
  108327:	8b 55 e0             	mov    -0x20(%ebp),%edx               <== NOT EXECUTED
  10832a:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  10832d:	89 50 0c             	mov    %edx,0xc(%eax)                 <== NOT EXECUTED
  108330:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
	return sc;                                                           
}                                                                     
  108333:	8b 45 e0             	mov    -0x20(%ebp),%eax               <== NOT EXECUTED
  108336:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  108339:	5b                   	pop    %ebx                           <== NOT EXECUTED
  10833a:	5e                   	pop    %esi                           <== NOT EXECUTED
  10833b:	5f                   	pop    %edi                           <== NOT EXECUTED
  10833c:	c9                   	leave                                 <== NOT EXECUTED
  10833d:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001084a7 <rtems_termios_open>: rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) {
  1084a7:	55                   	push   %ebp                           
  1084a8:	89 e5                	mov    %esp,%ebp                      
  1084aa:	57                   	push   %edi                           
  1084ab:	56                   	push   %esi                           
  1084ac:	53                   	push   %ebx                           
  1084ad:	83 ec 10             	sub    $0x10,%esp                     
	struct rtems_termios_tty *tty;                                       
                                                                      
	/*                                                                   
	 * See if the device has already been opened                         
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
  1084b0:	6a 00                	push   $0x0                           
  1084b2:	6a 00                	push   $0x0                           
  1084b4:	ff 35 d4 d6 11 00    	pushl  0x11d6d4                       
  1084ba:	e8 b5 0c 00 00       	call   109174 <rtems_semaphore_obtain>
  1084bf:	89 45 f0             	mov    %eax,-0x10(%ebp)               
				     RTEMS_WAIT, RTEMS_NO_TIMEOUT);                               
	if (sc != RTEMS_SUCCESSFUL)                                          
  1084c2:	83 c4 10             	add    $0x10,%esp                     
  1084c5:	85 c0                	test   %eax,%eax                      
  1084c7:	0f 85 c0 03 00 00    	jne    10888d <rtems_termios_open+0x3e6><== NEVER TAKEN
		return sc;                                                          
	for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {  
  1084cd:	a1 dc d6 11 00       	mov    0x11d6dc,%eax                  
  1084d2:	eb 1c                	jmp    1084f0 <rtems_termios_open+0x49>
		if ((tty->major == major) && (tty->minor == minor))                 
  1084d4:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  1084d7:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  1084da:	39 4a 0c             	cmp    %ecx,0xc(%edx)                 
  1084dd:	75 0c                	jne    1084eb <rtems_termios_open+0x44><== NEVER TAKEN
  1084df:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  1084e2:	39 72 10             	cmp    %esi,0x10(%edx)                
  1084e5:	0f 84 14 03 00 00    	je     1087ff <rtems_termios_open+0x358><== ALWAYS TAKEN
	 */                                                                  
	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) {  
  1084eb:	8b 45 e8             	mov    -0x18(%ebp),%eax               <== NOT EXECUTED
  1084ee:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
  1084f0:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  1084f3:	83 7d e8 00          	cmpl   $0x0,-0x18(%ebp)               
  1084f7:	75 db                	jne    1084d4 <rtems_termios_open+0x2d>
  1084f9:	e9 9a 03 00 00       	jmp    108898 <rtems_termios_open+0x3f1>
		/*                                                                  
		 * Create a new device                                              
		 */                                                                 
		tty = calloc (1, sizeof (struct rtems_termios_tty));                
		if (tty == NULL) {                                                  
			rtems_semaphore_release (rtems_termios_ttyMutex);                  
  1084fe:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108501:	e9 9d 00 00 00       	jmp    1085a3 <rtems_termios_open+0xfc><== NOT EXECUTED
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * allocate raw input buffer                                        
		 */                                                                 
		tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                         
  108506:	a1 40 b6 11 00       	mov    0x11b640,%eax                  
  10850b:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  10850e:	89 42 64             	mov    %eax,0x64(%edx)                
		tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);                 
  108511:	8b 42 64             	mov    0x64(%edx),%eax                
  108514:	83 ec 0c             	sub    $0xc,%esp                      
  108517:	50                   	push   %eax                           
  108518:	e8 57 e1 ff ff       	call   106674 <malloc>                
  10851d:	8b 4d e8             	mov    -0x18(%ebp),%ecx               
  108520:	89 41 58             	mov    %eax,0x58(%ecx)                
		if (tty->rawInBuf.theBuf == NULL) {                                 
  108523:	83 c4 10             	add    $0x10,%esp                     
  108526:	85 c0                	test   %eax,%eax                      
  108528:	75 06                	jne    108530 <rtems_termios_open+0x89><== ALWAYS TAKEN
		        free(tty);                                                  
  10852a:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10852d:	51                   	push   %ecx                           <== NOT EXECUTED
  10852e:	eb 6d                	jmp    10859d <rtems_termios_open+0xf6><== NOT EXECUTED
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * allocate raw output buffer                                       
		 */                                                                 
		tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                       
  108530:	a1 44 b6 11 00       	mov    0x11b644,%eax                  
  108535:	8b 75 e8             	mov    -0x18(%ebp),%esi               
  108538:	89 86 88 00 00 00    	mov    %eax,0x88(%esi)                
		tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);               
  10853e:	8b 86 88 00 00 00    	mov    0x88(%esi),%eax                
  108544:	83 ec 0c             	sub    $0xc,%esp                      
  108547:	50                   	push   %eax                           
  108548:	e8 27 e1 ff ff       	call   106674 <malloc>                
  10854d:	89 46 7c             	mov    %eax,0x7c(%esi)                
		if (tty->rawOutBuf.theBuf == NULL) {                                
  108550:	83 c4 10             	add    $0x10,%esp                     
  108553:	85 c0                	test   %eax,%eax                      
  108555:	75 10                	jne    108567 <rtems_termios_open+0xc0><== ALWAYS TAKEN
		        free((void *)(tty->rawInBuf.theBuf));                       
  108557:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10855a:	ff 76 58             	pushl  0x58(%esi)                     <== NOT EXECUTED
  10855d:	e8 16 df ff ff       	call   106478 <free>                  <== NOT EXECUTED
		        free(tty);                                                  
  108562:	89 34 24             	mov    %esi,(%esp)                    <== NOT EXECUTED
  108565:	eb 36                	jmp    10859d <rtems_termios_open+0xf6><== NOT EXECUTED
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * allocate cooked buffer                                           
		 */                                                                 
		tty->cbuf  = malloc (CBUFSIZE);                                     
  108567:	83 ec 0c             	sub    $0xc,%esp                      
  10856a:	ff 35 3c b6 11 00    	pushl  0x11b63c                       
  108570:	e8 ff e0 ff ff       	call   106674 <malloc>                
  108575:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  108578:	89 42 1c             	mov    %eax,0x1c(%edx)                
		if (tty->cbuf == NULL) {                                            
  10857b:	83 c4 10             	add    $0x10,%esp                     
  10857e:	85 c0                	test   %eax,%eax                      
  108580:	75 38                	jne    1085ba <rtems_termios_open+0x113><== ALWAYS TAKEN
		        free((void *)(tty->rawOutBuf.theBuf));                      
  108582:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108585:	ff 72 7c             	pushl  0x7c(%edx)                     <== NOT EXECUTED
  108588:	e8 eb de ff ff       	call   106478 <free>                  <== NOT EXECUTED
		        free((void *)(tty->rawInBuf.theBuf));                       
  10858d:	58                   	pop    %eax                           <== NOT EXECUTED
  10858e:	8b 4d e8             	mov    -0x18(%ebp),%ecx               <== NOT EXECUTED
  108591:	ff 71 58             	pushl  0x58(%ecx)                     <== NOT EXECUTED
  108594:	e8 df de ff ff       	call   106478 <free>                  <== NOT EXECUTED
		        free(tty);                                                  
  108599:	58                   	pop    %eax                           <== NOT EXECUTED
  10859a:	ff 75 e8             	pushl  -0x18(%ebp)                    <== NOT EXECUTED
  10859d:	e8 d6 de ff ff       	call   106478 <free>                  <== NOT EXECUTED
			rtems_semaphore_release (rtems_termios_ttyMutex);                  
  1085a2:	5f                   	pop    %edi                           <== NOT EXECUTED
  1085a3:	ff 35 d4 d6 11 00    	pushl  0x11d6d4                       <== NOT EXECUTED
  1085a9:	e8 ae 0c 00 00       	call   10925c <rtems_semaphore_release><== NOT EXECUTED
  1085ae:	c7 45 f0 1a 00 00 00 	movl   $0x1a,-0x10(%ebp)              <== NOT EXECUTED
  1085b5:	e9 d0 02 00 00       	jmp    10888a <rtems_termios_open+0x3e3><== NOT EXECUTED
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * Initialize wakeup callbacks                                      
		 */                                                                 
		tty->tty_snd.sw_pfn = NULL;                                         
  1085ba:	8b 75 e8             	mov    -0x18(%ebp),%esi               
  1085bd:	c7 86 d4 00 00 00 00 	movl   $0x0,0xd4(%esi)                
  1085c4:	00 00 00                                                    
		tty->tty_snd.sw_arg = NULL;                                         
  1085c7:	c7 86 d8 00 00 00 00 	movl   $0x0,0xd8(%esi)                
  1085ce:	00 00 00                                                    
		tty->tty_rcv.sw_pfn = NULL;                                         
  1085d1:	c7 86 dc 00 00 00 00 	movl   $0x0,0xdc(%esi)                
  1085d8:	00 00 00                                                    
		tty->tty_rcv.sw_arg = NULL;                                         
  1085db:	c7 86 e0 00 00 00 00 	movl   $0x0,0xe0(%esi)                
  1085e2:	00 00 00                                                    
		tty->tty_rcvwakeup  = 0;                                            
  1085e5:	c7 86 e4 00 00 00 00 	movl   $0x0,0xe4(%esi)                
  1085ec:	00 00 00                                                    
                                                                      
		/*                                                                  
		 * link tty                                                         
		 */                                                                 
		tty->forw = rtems_termios_ttyHead;                                  
  1085ef:	a1 dc d6 11 00       	mov    0x11d6dc,%eax                  
  1085f4:	89 06                	mov    %eax,(%esi)                    
		tty->back = NULL;                                                   
  1085f6:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)                 
		if (rtems_termios_ttyHead != NULL)                                  
  1085fd:	85 c0                	test   %eax,%eax                      
  1085ff:	74 03                	je     108604 <rtems_termios_open+0x15d><== ALWAYS TAKEN
			rtems_termios_ttyHead->back = tty;                                 
  108601:	89 70 04             	mov    %esi,0x4(%eax)                 <== NOT EXECUTED
		rtems_termios_ttyHead = tty;                                        
  108604:	89 1d dc d6 11 00    	mov    %ebx,0x11d6dc                  
		if (rtems_termios_ttyTail == NULL)                                  
  10860a:	83 3d d8 d6 11 00 00 	cmpl   $0x0,0x11d6d8                  
  108611:	75 06                	jne    108619 <rtems_termios_open+0x172><== NEVER TAKEN
			rtems_termios_ttyTail = tty;                                       
  108613:	89 1d d8 d6 11 00    	mov    %ebx,0x11d6d8                  
                                                                      
		tty->minor = minor;                                                 
  108619:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10861c:	89 43 10             	mov    %eax,0x10(%ebx)                
		tty->major = major;                                                 
  10861f:	8b 55 08             	mov    0x8(%ebp),%edx                 
  108622:	89 53 0c             	mov    %edx,0xc(%ebx)                 
                                                                      
		/*                                                                  
		 * Set up mutex semaphores                                          
		 */                                                                 
		sc = rtems_semaphore_create (                                       
  108625:	83 ec 0c             	sub    $0xc,%esp                      
  108628:	8d 43 14             	lea    0x14(%ebx),%eax                
  10862b:	50                   	push   %eax                           
  10862c:	6a 00                	push   $0x0                           
  10862e:	6a 54                	push   $0x54                          
  108630:	6a 01                	push   $0x1                           
  108632:	0f be 05 48 b6 11 00 	movsbl 0x11b648,%eax                  
  108639:	0d 00 69 52 54       	or     $0x54526900,%eax               
  10863e:	50                   	push   %eax                           
  10863f:	e8 fc 08 00 00       	call   108f40 <rtems_semaphore_create>
			rtems_build_name ('T', 'R', 'i', c),                               
			1,                                                                 
			RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,  
			RTEMS_NO_PRIORITY,                                                 
			&tty->isem);                                                       
		if (sc != RTEMS_SUCCESSFUL)                                         
  108644:	83 c4 20             	add    $0x20,%esp                     
  108647:	85 c0                	test   %eax,%eax                      
  108649:	0f 85 24 02 00 00    	jne    108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
			rtems_fatal_error_occurred (sc);                                   
		sc = rtems_semaphore_create (                                       
  10864f:	83 ec 0c             	sub    $0xc,%esp                      
  108652:	8d 43 18             	lea    0x18(%ebx),%eax                
  108655:	50                   	push   %eax                           
  108656:	6a 00                	push   $0x0                           
  108658:	6a 54                	push   $0x54                          
  10865a:	6a 01                	push   $0x1                           
  10865c:	0f be 05 48 b6 11 00 	movsbl 0x11b648,%eax                  
  108663:	0d 00 6f 52 54       	or     $0x54526f00,%eax               
  108668:	50                   	push   %eax                           
  108669:	e8 d2 08 00 00       	call   108f40 <rtems_semaphore_create>
			rtems_build_name ('T', 'R', 'o', c),                               
			1,                                                                 
			RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,  
			RTEMS_NO_PRIORITY,                                                 
			&tty->osem);                                                       
		if (sc != RTEMS_SUCCESSFUL)                                         
  10866e:	83 c4 20             	add    $0x20,%esp                     
  108671:	85 c0                	test   %eax,%eax                      
  108673:	0f 85 fa 01 00 00    	jne    108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
			rtems_fatal_error_occurred (sc);                                   
		sc = rtems_semaphore_create (                                       
  108679:	83 ec 0c             	sub    $0xc,%esp                      
  10867c:	8d 83 8c 00 00 00    	lea    0x8c(%ebx),%eax                
  108682:	50                   	push   %eax                           
  108683:	6a 00                	push   $0x0                           
  108685:	6a 20                	push   $0x20                          
  108687:	6a 00                	push   $0x0                           
  108689:	0f be 05 48 b6 11 00 	movsbl 0x11b648,%eax                  
  108690:	0d 00 78 52 54       	or     $0x54527800,%eax               
  108695:	50                   	push   %eax                           
  108696:	e8 a5 08 00 00       	call   108f40 <rtems_semaphore_create>
			rtems_build_name ('T', 'R', 'x', c),                               
			0,                                                                 
			RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,                        
			RTEMS_NO_PRIORITY,                                                 
			&tty->rawOutBuf.Semaphore);                                        
		if (sc != RTEMS_SUCCESSFUL)                                         
  10869b:	83 c4 20             	add    $0x20,%esp                     
  10869e:	85 c0                	test   %eax,%eax                      
  1086a0:	0f 85 cd 01 00 00    	jne    108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
			rtems_fatal_error_occurred (sc);                                   
		tty->rawOutBufState = rob_idle;                                     
  1086a6:	c7 83 94 00 00 00 00 	movl   $0x0,0x94(%ebx)                
  1086ad:	00 00 00                                                    
                                                                      
		/*                                                                  
		 * Set callbacks                                                    
		 */                                                                 
		tty->device = *callbacks;                                           
  1086b0:	8d bb 98 00 00 00    	lea    0x98(%ebx),%edi                
  1086b6:	b9 08 00 00 00       	mov    $0x8,%ecx                      
  1086bb:	8b 75 14             	mov    0x14(%ebp),%esi                
  1086be:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
		/*                                                                  
		 * Create I/O tasks                                                 
		 */                                                                 
		if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
  1086c0:	83 bb b4 00 00 00 02 	cmpl   $0x2,0xb4(%ebx)                
  1086c7:	75 68                	jne    108731 <rtems_termios_open+0x28a><== ALWAYS TAKEN
			sc = rtems_task_create (                                           
  1086c9:	56                   	push   %esi                           <== NOT EXECUTED
  1086ca:	56                   	push   %esi                           <== NOT EXECUTED
  1086cb:	8d 83 c8 00 00 00    	lea    0xc8(%ebx),%eax                <== NOT EXECUTED
  1086d1:	50                   	push   %eax                           <== NOT EXECUTED
  1086d2:	6a 00                	push   $0x0                           <== NOT EXECUTED
  1086d4:	68 00 05 00 00       	push   $0x500                         <== NOT EXECUTED
  1086d9:	68 00 04 00 00       	push   $0x400                         <== NOT EXECUTED
  1086de:	6a 0a                	push   $0xa                           <== NOT EXECUTED
  1086e0:	0f be 05 48 b6 11 00 	movsbl 0x11b648,%eax                  <== NOT EXECUTED
  1086e7:	0d 00 54 78 54       	or     $0x54785400,%eax               <== NOT EXECUTED
  1086ec:	50                   	push   %eax                           <== NOT EXECUTED
  1086ed:	e8 fa 0b 00 00       	call   1092ec <rtems_task_create>     <== NOT EXECUTED
				   TERMIOS_TXTASK_STACKSIZE,                                      
				   RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |                        
				   RTEMS_NO_ASR,                                                  
				   RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                         
				   &tty->txTaskId);                                               
			if (sc != RTEMS_SUCCESSFUL)                                        
  1086f2:	83 c4 20             	add    $0x20,%esp                     <== NOT EXECUTED
  1086f5:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1086f7:	0f 85 76 01 00 00    	jne    108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
			sc = rtems_task_create (                                           
  1086fd:	51                   	push   %ecx                           <== NOT EXECUTED
  1086fe:	51                   	push   %ecx                           <== NOT EXECUTED
  1086ff:	8d 83 c4 00 00 00    	lea    0xc4(%ebx),%eax                <== NOT EXECUTED
  108705:	50                   	push   %eax                           <== NOT EXECUTED
  108706:	6a 00                	push   $0x0                           <== NOT EXECUTED
  108708:	68 00 05 00 00       	push   $0x500                         <== NOT EXECUTED
  10870d:	68 00 04 00 00       	push   $0x400                         <== NOT EXECUTED
  108712:	6a 09                	push   $0x9                           <== NOT EXECUTED
  108714:	0f be 05 48 b6 11 00 	movsbl 0x11b648,%eax                  <== NOT EXECUTED
  10871b:	0d 00 54 78 52       	or     $0x52785400,%eax               <== NOT EXECUTED
  108720:	50                   	push   %eax                           <== NOT EXECUTED
  108721:	e8 c6 0b 00 00       	call   1092ec <rtems_task_create>     <== NOT EXECUTED
				   TERMIOS_RXTASK_STACKSIZE,                                      
				   RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |                        
				   RTEMS_NO_ASR,                                                  
				   RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                         
				   &tty->rxTaskId);                                               
			if (sc != RTEMS_SUCCESSFUL)                                        
  108726:	83 c4 20             	add    $0x20,%esp                     <== NOT EXECUTED
  108729:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10872b:	0f 85 42 01 00 00    	jne    108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
                                                                      
		}                                                                   
		if ((tty->device.pollRead == NULL) ||                               
  108731:	83 bb a0 00 00 00 00 	cmpl   $0x0,0xa0(%ebx)                
  108738:	74 09                	je     108743 <rtems_termios_open+0x29c><== ALWAYS TAKEN
  10873a:	83 bb b4 00 00 00 02 	cmpl   $0x2,0xb4(%ebx)                <== NOT EXECUTED
  108741:	75 2a                	jne    10876d <rtems_termios_open+0x2c6><== NOT EXECUTED
		    (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){     
			sc = rtems_semaphore_create (                                      
  108743:	83 ec 0c             	sub    $0xc,%esp                      
  108746:	8d 43 68             	lea    0x68(%ebx),%eax                
  108749:	50                   	push   %eax                           
  10874a:	6a 00                	push   $0x0                           
  10874c:	6a 24                	push   $0x24                          
  10874e:	6a 00                	push   $0x0                           
  108750:	0f be 05 48 b6 11 00 	movsbl 0x11b648,%eax                  
  108757:	0d 00 72 52 54       	or     $0x54527200,%eax               
  10875c:	50                   	push   %eax                           
  10875d:	e8 de 07 00 00       	call   108f40 <rtems_semaphore_create>
				rtems_build_name ('T', 'R', 'r', c),                              
				0,                                                                
				RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,                   
				RTEMS_NO_PRIORITY,                                                
				&tty->rawInBuf.Semaphore);                                        
			if (sc != RTEMS_SUCCESSFUL)                                        
  108762:	83 c4 20             	add    $0x20,%esp                     
  108765:	85 c0                	test   %eax,%eax                      
  108767:	0f 85 06 01 00 00    	jne    108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
		}                                                                   
                                                                      
		/*                                                                  
		 * Set default parameters                                           
		 */                                                                 
		tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;             
  10876d:	c7 43 30 02 25 00 00 	movl   $0x2502,0x30(%ebx)             
		tty->termios.c_oflag = OPOST | ONLCR | XTABS;                       
  108774:	c7 43 34 05 18 00 00 	movl   $0x1805,0x34(%ebx)             
		tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;                
  10877b:	c7 43 38 bd 08 00 00 	movl   $0x8bd,0x38(%ebx)              
		tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
  108782:	c7 43 3c 3b 82 00 00 	movl   $0x823b,0x3c(%ebx)             
                                                                      
		tty->termios.c_cc[VINTR] = '\003';                                  
  108789:	c6 43 41 03          	movb   $0x3,0x41(%ebx)                
		tty->termios.c_cc[VQUIT] = '\034';                                  
  10878d:	c6 43 42 1c          	movb   $0x1c,0x42(%ebx)               
		tty->termios.c_cc[VERASE] = '\177';                                 
  108791:	c6 43 43 7f          	movb   $0x7f,0x43(%ebx)               
		tty->termios.c_cc[VKILL] = '\025';                                  
  108795:	c6 43 44 15          	movb   $0x15,0x44(%ebx)               
		tty->termios.c_cc[VEOF] = '\004';                                   
  108799:	c6 43 45 04          	movb   $0x4,0x45(%ebx)                
		tty->termios.c_cc[VEOL] = '\000';                                   
  10879d:	c6 43 4c 00          	movb   $0x0,0x4c(%ebx)                
		tty->termios.c_cc[VEOL2] = '\000';                                  
  1087a1:	c6 43 51 00          	movb   $0x0,0x51(%ebx)                
		tty->termios.c_cc[VSTART] = '\021';                                 
  1087a5:	c6 43 49 11          	movb   $0x11,0x49(%ebx)               
		tty->termios.c_cc[VSTOP] = '\023';                                  
  1087a9:	c6 43 4a 13          	movb   $0x13,0x4a(%ebx)               
		tty->termios.c_cc[VSUSP] = '\032';                                  
  1087ad:	c6 43 4b 1a          	movb   $0x1a,0x4b(%ebx)               
		tty->termios.c_cc[VREPRINT] = '\022';                               
  1087b1:	c6 43 4d 12          	movb   $0x12,0x4d(%ebx)               
		tty->termios.c_cc[VDISCARD] = '\017';                               
  1087b5:	c6 43 4e 0f          	movb   $0xf,0x4e(%ebx)                
		tty->termios.c_cc[VWERASE] = '\027';                                
  1087b9:	c6 43 4f 17          	movb   $0x17,0x4f(%ebx)               
		tty->termios.c_cc[VLNEXT] = '\026';                                 
  1087bd:	c6 43 50 16          	movb   $0x16,0x50(%ebx)               
                                                                      
		/* start with no flow control, clear flow control flags */          
		tty->flow_ctrl = 0;                                                 
  1087c1:	c7 83 b8 00 00 00 00 	movl   $0x0,0xb8(%ebx)                
  1087c8:	00 00 00                                                    
		/*                                                                  
		 * set low/highwater mark for XON/XOFF support                      
		 */                                                                 
		tty->lowwater  = tty->rawInBuf.Size * 1/2;                          
  1087cb:	8b 43 64             	mov    0x64(%ebx),%eax                
  1087ce:	d1 e8                	shr    %eax                           
  1087d0:	89 83 bc 00 00 00    	mov    %eax,0xbc(%ebx)                
		tty->highwater = tty->rawInBuf.Size * 3/4;                          
  1087d6:	8b 43 64             	mov    0x64(%ebx),%eax                
  1087d9:	8d 04 40             	lea    (%eax,%eax,2),%eax             
  1087dc:	c1 e8 02             	shr    $0x2,%eax                      
  1087df:	89 83 c0 00 00 00    	mov    %eax,0xc0(%ebx)                
		/*                                                                  
		 * Bump name characer                                               
		 */                                                                 
		if (c++ == 'z')                                                     
  1087e5:	8a 15 48 b6 11 00    	mov    0x11b648,%dl                   
  1087eb:	8d 42 01             	lea    0x1(%edx),%eax                 
  1087ee:	a2 48 b6 11 00       	mov    %al,0x11b648                   
  1087f3:	80 fa 7a             	cmp    $0x7a,%dl                      
  1087f6:	75 07                	jne    1087ff <rtems_termios_open+0x358><== ALWAYS TAKEN
			c = 'a';                                                           
  1087f8:	c6 05 48 b6 11 00 61 	movb   $0x61,0x11b648                 <== NOT EXECUTED
                                                                      
	}                                                                    
	args->iop->data1 = tty;                                              
  1087ff:	8b 55 10             	mov    0x10(%ebp),%edx                
  108802:	8b 02                	mov    (%edx),%eax                    
  108804:	8b 4d e8             	mov    -0x18(%ebp),%ecx               
  108807:	89 48 28             	mov    %ecx,0x28(%eax)                
	if (!tty->refcount++) {                                              
  10880a:	8b 51 08             	mov    0x8(%ecx),%edx                 
  10880d:	8d 42 01             	lea    0x1(%edx),%eax                 
  108810:	89 41 08             	mov    %eax,0x8(%ecx)                 
  108813:	85 d2                	test   %edx,%edx                      
  108815:	75 65                	jne    10887c <rtems_termios_open+0x3d5>
	  if (tty->device.firstOpen)                                         
  108817:	8b 81 98 00 00 00    	mov    0x98(%ecx),%eax                
  10881d:	85 c0                	test   %eax,%eax                      
  10881f:	74 0f                	je     108830 <rtems_termios_open+0x389><== NEVER TAKEN
		(*tty->device.firstOpen)(major, minor, arg);                        
  108821:	52                   	push   %edx                           
  108822:	ff 75 10             	pushl  0x10(%ebp)                     
  108825:	ff 75 0c             	pushl  0xc(%ebp)                      
  108828:	ff 75 08             	pushl  0x8(%ebp)                      
  10882b:	ff d0                	call   *%eax                          
  10882d:	83 c4 10             	add    $0x10,%esp                     
	  /*                                                                 
	   * start I/O tasks, if needed                                      
	   */                                                                
	  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {     
  108830:	8b 75 e8             	mov    -0x18(%ebp),%esi               
  108833:	83 be b4 00 00 00 02 	cmpl   $0x2,0xb4(%esi)                
  10883a:	75 40                	jne    10887c <rtems_termios_open+0x3d5><== ALWAYS TAKEN
	    sc = rtems_task_start(tty->rxTaskId,                             
  10883c:	50                   	push   %eax                           <== NOT EXECUTED
  10883d:	56                   	push   %esi                           <== NOT EXECUTED
  10883e:	68 1e 89 10 00       	push   $0x10891e                      <== NOT EXECUTED
  108843:	ff b6 c4 00 00 00    	pushl  0xc4(%esi)                     <== NOT EXECUTED
  108849:	e8 0e 0d 00 00       	call   10955c <rtems_task_start>      <== NOT EXECUTED
				  rtems_termios_rxdaemon,                                         
				  (rtems_task_argument)tty);                                      
	    if (sc != RTEMS_SUCCESSFUL)                                      
  10884e:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108851:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108853:	75 1e                	jne    108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
	      rtems_fatal_error_occurred (sc);                               
                                                                      
	    sc = rtems_task_start(tty->txTaskId,                             
  108855:	50                   	push   %eax                           <== NOT EXECUTED
  108856:	ff 75 e8             	pushl  -0x18(%ebp)                    <== NOT EXECUTED
  108859:	68 bb 88 10 00       	push   $0x1088bb                      <== NOT EXECUTED
  10885e:	8b 45 e8             	mov    -0x18(%ebp),%eax               <== NOT EXECUTED
  108861:	ff b0 c8 00 00 00    	pushl  0xc8(%eax)                     <== NOT EXECUTED
  108867:	e8 f0 0c 00 00       	call   10955c <rtems_task_start>      <== NOT EXECUTED
				  rtems_termios_txdaemon,                                         
				  (rtems_task_argument)tty);                                      
	    if (sc != RTEMS_SUCCESSFUL)                                      
  10886c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10886f:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108871:	74 09                	je     10887c <rtems_termios_open+0x3d5><== NOT EXECUTED
	      rtems_fatal_error_occurred (sc);                               
  108873:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108876:	50                   	push   %eax                           <== NOT EXECUTED
  108877:	e8 18 0f 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
	  }                                                                  
	}                                                                    
	rtems_semaphore_release (rtems_termios_ttyMutex);                    
  10887c:	83 ec 0c             	sub    $0xc,%esp                      
  10887f:	ff 35 d4 d6 11 00    	pushl  0x11d6d4                       
  108885:	e8 d2 09 00 00       	call   10925c <rtems_semaphore_release>
  10888a:	83 c4 10             	add    $0x10,%esp                     
	return RTEMS_SUCCESSFUL;                                             
}                                                                     
  10888d:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  108890:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108893:	5b                   	pop    %ebx                           
  108894:	5e                   	pop    %esi                           
  108895:	5f                   	pop    %edi                           
  108896:	c9                   	leave                                 
  108897:	c3                   	ret                                   
		static char c = 'a';                                                
                                                                      
		/*                                                                  
		 * Create a new device                                              
		 */                                                                 
		tty = calloc (1, sizeof (struct rtems_termios_tty));                
  108898:	50                   	push   %eax                           
  108899:	50                   	push   %eax                           
  10889a:	68 e8 00 00 00       	push   $0xe8                          
  10889f:	6a 01                	push   $0x1                           
  1088a1:	e8 2a 44 00 00       	call   10ccd0 <calloc>                
  1088a6:	89 45 e8             	mov    %eax,-0x18(%ebp)               
  1088a9:	89 c3                	mov    %eax,%ebx                      
		if (tty == NULL) {                                                  
  1088ab:	83 c4 10             	add    $0x10,%esp                     
  1088ae:	85 c0                	test   %eax,%eax                      
  1088b0:	0f 85 50 fc ff ff    	jne    108506 <rtems_termios_open+0x5f><== ALWAYS TAKEN
  1088b6:	e9 43 fc ff ff       	jmp    1084fe <rtems_termios_open+0x57><== NOT EXECUTED
                                                                      

00107693 <rtems_termios_puts>: * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) {
  107693:	55                   	push   %ebp                           
  107694:	89 e5                	mov    %esp,%ebp                      
  107696:	57                   	push   %edi                           
  107697:	56                   	push   %esi                           
  107698:	53                   	push   %ebx                           
  107699:	83 ec 1c             	sub    $0x1c,%esp                     
  10769c:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10769f:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  1076a2:	89 55 e8             	mov    %edx,-0x18(%ebp)               
  1076a5:	8b 5d 10             	mov    0x10(%ebp),%ebx                
	const unsigned char *buf = _buf;                                     
  1076a8:	89 45 ec             	mov    %eax,-0x14(%ebp)               
	unsigned int newHead;                                                
	rtems_interrupt_level level;                                         
	rtems_status_code sc;                                                
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {            
  1076ab:	83 bb b4 00 00 00 00 	cmpl   $0x0,0xb4(%ebx)                
  1076b2:	75 1b                	jne    1076cf <rtems_termios_puts+0x3c><== ALWAYS TAKEN
		(*tty->device.write)(tty->minor, (void *)buf, len);                 
  1076b4:	89 55 10             	mov    %edx,0x10(%ebp)                <== NOT EXECUTED
  1076b7:	89 45 0c             	mov    %eax,0xc(%ebp)                 <== NOT EXECUTED
  1076ba:	8b 43 10             	mov    0x10(%ebx),%eax                <== NOT EXECUTED
  1076bd:	89 45 08             	mov    %eax,0x8(%ebp)                 <== NOT EXECUTED
  1076c0:	8b 8b a4 00 00 00    	mov    0xa4(%ebx),%ecx                <== NOT EXECUTED
		  tty->rawOutBufState = rob_busy;                                   
		}                                                                   
		rtems_interrupt_enable (level);                                     
		len--;                                                              
	}                                                                    
}                                                                     
  1076c6:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  1076c9:	5b                   	pop    %ebx                           <== NOT EXECUTED
  1076ca:	5e                   	pop    %esi                           <== NOT EXECUTED
  1076cb:	5f                   	pop    %edi                           <== NOT EXECUTED
  1076cc:	c9                   	leave                                 <== NOT EXECUTED
	unsigned int newHead;                                                
	rtems_interrupt_level level;                                         
	rtems_status_code sc;                                                
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {            
		(*tty->device.write)(tty->minor, (void *)buf, len);                 
  1076cd:	ff e1                	jmp    *%ecx                          <== NOT EXECUTED
		return;                                                             
	}                                                                    
	newHead = tty->rawOutBuf.Head;                                       
  1076cf:	8b 83 80 00 00 00    	mov    0x80(%ebx),%eax                
  1076d5:	89 45 f0             	mov    %eax,-0x10(%ebp)               
  1076d8:	e9 b9 00 00 00       	jmp    107796 <rtems_termios_puts+0x103>
		 *	len -= ncopy                                                     
		 *                                                                  
		 * To minimize latency, the memcpy should be done                   
		 * with interrupts enabled.                                         
		 */                                                                 
		newHead = (newHead + 1) % tty->rawOutBuf.Size;                      
  1076dd:	8b 75 f0             	mov    -0x10(%ebp),%esi               
  1076e0:	46                   	inc    %esi                           
  1076e1:	8b 8b 88 00 00 00    	mov    0x88(%ebx),%ecx                
  1076e7:	89 f0                	mov    %esi,%eax                      
  1076e9:	31 d2                	xor    %edx,%edx                      
  1076eb:	f7 f1                	div    %ecx                           
  1076ed:	89 d6                	mov    %edx,%esi                      
  1076ef:	89 55 f0             	mov    %edx,-0x10(%ebp)               
		rtems_interrupt_disable (level);                                    
  1076f2:	9c                   	pushf                                 
  1076f3:	fa                   	cli                                   
  1076f4:	5f                   	pop    %edi                           
  1076f5:	eb 2f                	jmp    107726 <rtems_termios_puts+0x93>
		while (newHead == tty->rawOutBuf.Tail) {                            
			tty->rawOutBufState = rob_wait;                                    
  1076f7:	c7 83 94 00 00 00 02 	movl   $0x2,0x94(%ebx)                
  1076fe:	00 00 00                                                    
			rtems_interrupt_enable (level);                                    
  107701:	57                   	push   %edi                           
  107702:	9d                   	popf                                  
			sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,             
  107703:	51                   	push   %ecx                           
  107704:	6a 00                	push   $0x0                           
  107706:	6a 00                	push   $0x0                           
  107708:	ff b3 8c 00 00 00    	pushl  0x8c(%ebx)                     
  10770e:	e8 61 1a 00 00       	call   109174 <rtems_semaphore_obtain>
							RTEMS_WAIT,                                                    
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
  107713:	83 c4 10             	add    $0x10,%esp                     
  107716:	85 c0                	test   %eax,%eax                      
  107718:	74 09                	je     107723 <rtems_termios_puts+0x90><== ALWAYS TAKEN
				rtems_fatal_error_occurred (sc);                                  
  10771a:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10771d:	50                   	push   %eax                           <== NOT EXECUTED
  10771e:	e8 71 20 00 00       	call   109794 <rtems_fatal_error_occurred><== NOT EXECUTED
			rtems_interrupt_disable (level);                                   
  107723:	9c                   	pushf                                 
  107724:	fa                   	cli                                   
  107725:	5f                   	pop    %edi                           
		 * 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) {                            
  107726:	8b 83 84 00 00 00    	mov    0x84(%ebx),%eax                
  10772c:	39 c6                	cmp    %eax,%esi                      
  10772e:	74 c7                	je     1076f7 <rtems_termios_puts+0x64>
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
				rtems_fatal_error_occurred (sc);                                  
			rtems_interrupt_disable (level);                                   
		}                                                                   
		tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;                
  107730:	8b 8b 80 00 00 00    	mov    0x80(%ebx),%ecx                
  107736:	8b 53 7c             	mov    0x7c(%ebx),%edx                
  107739:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10773c:	8a 00                	mov    (%eax),%al                     
  10773e:	88 04 0a             	mov    %al,(%edx,%ecx,1)              
		tty->rawOutBuf.Head = newHead;                                      
  107741:	89 b3 80 00 00 00    	mov    %esi,0x80(%ebx)                
		if (tty->rawOutBufState == rob_idle) {                              
  107747:	83 bb 94 00 00 00 00 	cmpl   $0x0,0x94(%ebx)                
  10774e:	75 3e                	jne    10778e <rtems_termios_puts+0xfb>
		  /* check, whether XOFF has been received */                       
		  if (!(tty->flow_ctrl & FL_ORCVXOF)) {                             
  107750:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                
  107756:	a8 10                	test   $0x10,%al                      
  107758:	75 1b                	jne    107775 <rtems_termios_puts+0xe2><== NEVER TAKEN
		    (*tty->device.write)(tty->minor,                                
  10775a:	8b 83 84 00 00 00    	mov    0x84(%ebx),%eax                
  107760:	52                   	push   %edx                           
  107761:	6a 01                	push   $0x1                           
  107763:	03 43 7c             	add    0x7c(%ebx),%eax                
  107766:	50                   	push   %eax                           
  107767:	ff 73 10             	pushl  0x10(%ebx)                     
  10776a:	ff 93 a4 00 00 00    	call   *0xa4(%ebx)                    
  107770:	83 c4 10             	add    $0x10,%esp                     
  107773:	eb 0f                	jmp    107784 <rtems_termios_puts+0xf1>
			(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);            
		  }                                                                 
		  else {                                                            
		    /* remember that output has been stopped due to flow ctrl*/     
		    tty->flow_ctrl |= FL_OSTOP;                                     
  107775:	8b 83 b8 00 00 00    	mov    0xb8(%ebx),%eax                <== NOT EXECUTED
  10777b:	83 c8 20             	or     $0x20,%eax                     <== NOT EXECUTED
  10777e:	89 83 b8 00 00 00    	mov    %eax,0xb8(%ebx)                <== NOT EXECUTED
		  }                                                                 
		  tty->rawOutBufState = rob_busy;                                   
  107784:	c7 83 94 00 00 00 01 	movl   $0x1,0x94(%ebx)                
  10778b:	00 00 00                                                    
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
				rtems_fatal_error_occurred (sc);                                  
			rtems_interrupt_disable (level);                                   
		}                                                                   
		tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;                
  10778e:	ff 45 ec             	incl   -0x14(%ebp)                    
		    /* remember that output has been stopped due to flow ctrl*/     
		    tty->flow_ctrl |= FL_OSTOP;                                     
		  }                                                                 
		  tty->rawOutBufState = rob_busy;                                   
		}                                                                   
		rtems_interrupt_enable (level);                                     
  107791:	57                   	push   %edi                           
  107792:	9d                   	popf                                  
		len--;                                                              
  107793:	ff 4d e8             	decl   -0x18(%ebp)                    
	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {            
		(*tty->device.write)(tty->minor, (void *)buf, len);                 
		return;                                                             
	}                                                                    
	newHead = tty->rawOutBuf.Head;                                       
	while (len) {                                                        
  107796:	83 7d e8 00          	cmpl   $0x0,-0x18(%ebp)               
  10779a:	0f 85 3d ff ff ff    	jne    1076dd <rtems_termios_puts+0x4a>
		  tty->rawOutBufState = rob_busy;                                   
		}                                                                   
		rtems_interrupt_enable (level);                                     
		len--;                                                              
	}                                                                    
}                                                                     
  1077a0:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1077a3:	5b                   	pop    %ebx                           
  1077a4:	5e                   	pop    %esi                           
  1077a5:	5f                   	pop    %edi                           
  1077a6:	c9                   	leave                                 
  1077a7:	c3                   	ret                                   
                                                                      

00107cdf <rtems_termios_read>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) {
  107cdf:	55                   	push   %ebp                           <== NOT EXECUTED
  107ce0:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107ce2:	57                   	push   %edi                           <== NOT EXECUTED
  107ce3:	56                   	push   %esi                           <== NOT EXECUTED
  107ce4:	53                   	push   %ebx                           <== NOT EXECUTED
  107ce5:	83 ec 30             	sub    $0x30,%esp                     <== NOT EXECUTED
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
  107ce8:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  107ceb:	8b 02                	mov    (%edx),%eax                    <== NOT EXECUTED
  107ced:	8b 70 28             	mov    0x28(%eax),%esi                <== NOT EXECUTED
	uint32_t   count = args->count;                                      
  107cf0:	8b 4a 0c             	mov    0xc(%edx),%ecx                 <== NOT EXECUTED
  107cf3:	89 4d d0             	mov    %ecx,-0x30(%ebp)               <== NOT EXECUTED
	char      *buffer = args->buffer;                                    
  107cf6:	8b 42 08             	mov    0x8(%edx),%eax                 <== NOT EXECUTED
  107cf9:	89 45 d4             	mov    %eax,-0x2c(%ebp)               <== NOT EXECUTED
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  107cfc:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107cfe:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107d00:	ff 76 14             	pushl  0x14(%esi)                     <== NOT EXECUTED
  107d03:	e8 6c 14 00 00       	call   109174 <rtems_semaphore_obtain><== NOT EXECUTED
  107d08:	89 45 d8             	mov    %eax,-0x28(%ebp)               <== NOT EXECUTED
	if (sc != RTEMS_SUCCESSFUL)                                          
  107d0b:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107d0e:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107d10:	0f 85 c8 02 00 00    	jne    107fde <rtems_termios_read+0x2ff><== NOT EXECUTED
		return sc;                                                          
	if (rtems_termios_linesw[tty->t_line].l_read != NULL) {              
  107d16:	8b 86 cc 00 00 00    	mov    0xcc(%esi),%eax                <== NOT EXECUTED
  107d1c:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  107d1f:	8b 80 54 d4 11 00    	mov    0x11d454(%eax),%eax            <== NOT EXECUTED
  107d25:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107d27:	74 1b                	je     107d44 <rtems_termios_read+0x65><== NOT EXECUTED
		sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);            
  107d29:	52                   	push   %edx                           <== NOT EXECUTED
  107d2a:	52                   	push   %edx                           <== NOT EXECUTED
  107d2b:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  107d2e:	56                   	push   %esi                           <== NOT EXECUTED
  107d2f:	ff d0                	call   *%eax                          <== NOT EXECUTED
  107d31:	89 45 d8             	mov    %eax,-0x28(%ebp)               <== NOT EXECUTED
		tty->tty_rcvwakeup = 0;                                             
  107d34:	c7 86 e4 00 00 00 00 	movl   $0x0,0xe4(%esi)                <== NOT EXECUTED
  107d3b:	00 00 00                                                    
		rtems_semaphore_release (tty->isem);                                
  107d3e:	58                   	pop    %eax                           <== NOT EXECUTED
  107d3f:	e9 8f 02 00 00       	jmp    107fd3 <rtems_termios_read+0x2f4><== NOT EXECUTED
		return sc;                                                          
	}                                                                    
	if (tty->cindex == tty->ccount) {                                    
  107d44:	8b 46 24             	mov    0x24(%esi),%eax                <== NOT EXECUTED
  107d47:	3b 46 20             	cmp    0x20(%esi),%eax                <== NOT EXECUTED
  107d4a:	0f 85 5c 02 00 00    	jne    107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
		tty->cindex = tty->ccount = 0;                                      
  107d50:	c7 46 20 00 00 00 00 	movl   $0x0,0x20(%esi)                <== NOT EXECUTED
  107d57:	c7 46 24 00 00 00 00 	movl   $0x0,0x24(%esi)                <== NOT EXECUTED
		tty->read_start_column = tty->column;                               
  107d5e:	8b 46 28             	mov    0x28(%esi),%eax                <== NOT EXECUTED
  107d61:	89 46 2c             	mov    %eax,0x2c(%esi)                <== NOT EXECUTED
		if (tty->device.pollRead != NULL                                    
  107d64:	83 be a0 00 00 00 00 	cmpl   $0x0,0xa0(%esi)                <== NOT EXECUTED
  107d6b:	0f 84 f8 00 00 00    	je     107e69 <rtems_termios_read+0x18a><== NOT EXECUTED
  107d71:	83 be b4 00 00 00 00 	cmpl   $0x0,0xb4(%esi)                <== NOT EXECUTED
  107d78:	0f 85 eb 00 00 00    	jne    107e69 <rtems_termios_read+0x18a><== NOT EXECUTED
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
	int n;                                                               
                                                                      
	if (tty->termios.c_lflag & ICANON) {                                 
  107d7e:	f6 46 3c 02          	testb  $0x2,0x3c(%esi)                <== NOT EXECUTED
  107d82:	74 35                	je     107db9 <rtems_termios_read+0xda><== NOT EXECUTED
		for (;;) {                                                          
			n = (*tty->device.pollRead)(tty->minor);                           
  107d84:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107d87:	ff 76 10             	pushl  0x10(%esi)                     <== NOT EXECUTED
  107d8a:	ff 96 a0 00 00 00    	call   *0xa0(%esi)                    <== NOT EXECUTED
			if (n < 0) {                                                       
  107d90:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107d93:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107d95:	79 0f                	jns    107da6 <rtems_termios_read+0xc7><== NOT EXECUTED
				rtems_task_wake_after (1);                                        
  107d97:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107d9a:	6a 01                	push   $0x1                           <== NOT EXECUTED
  107d9c:	e8 1f 18 00 00       	call   1095c0 <rtems_task_wake_after> <== NOT EXECUTED
  107da1:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107da4:	eb de                	jmp    107d84 <rtems_termios_read+0xa5><== NOT EXECUTED
			}                                                                  
			else {                                                             
				if  (siproc (n, tty))                                             
  107da6:	0f b6 c0             	movzbl %al,%eax                       <== NOT EXECUTED
  107da9:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107dab:	e8 db fd ff ff       	call   107b8b <siproc>                <== NOT EXECUTED
  107db0:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107db2:	74 d0                	je     107d84 <rtems_termios_read+0xa5><== NOT EXECUTED
  107db4:	e9 f3 01 00 00       	jmp    107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
			}                                                                  
		}                                                                   
	}                                                                    
	else {                                                               
		rtems_interval then, now;                                           
		if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])           
  107db9:	80 7e 47 00          	cmpb   $0x0,0x47(%esi)                <== NOT EXECUTED
  107dbd:	75 16                	jne    107dd5 <rtems_termios_read+0xf6><== NOT EXECUTED
  107dbf:	80 7e 46 00          	cmpb   $0x0,0x46(%esi)                <== NOT EXECUTED
  107dc3:	74 10                	je     107dd5 <rtems_termios_read+0xf6><== NOT EXECUTED
			rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);         
  107dc5:	50                   	push   %eax                           <== NOT EXECUTED
  107dc6:	50                   	push   %eax                           <== NOT EXECUTED
  107dc7:	8d 45 f0             	lea    -0x10(%ebp),%eax               <== NOT EXECUTED
  107dca:	50                   	push   %eax                           <== NOT EXECUTED
  107dcb:	6a 02                	push   $0x2                           <== NOT EXECUTED
  107dcd:	e8 b2 0b 00 00       	call   108984 <rtems_clock_get>       <== NOT EXECUTED
  107dd2:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
			else {                                                             
				siproc (n, tty);                                                  
				if (tty->ccount >= tty->termios.c_cc[VMIN])                       
					break;                                                           
				if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])          
					rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);       
  107dd5:	8d 7d f0             	lea    -0x10(%ebp),%edi               <== NOT EXECUTED
					}                                                                
				}                                                                 
				else {                                                            
					if (!tty->termios.c_cc[VTIME])                                   
						break;                                                          
					rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);        
  107dd8:	8d 5d ec             	lea    -0x14(%ebp),%ebx               <== NOT EXECUTED
	else {                                                               
		rtems_interval then, now;                                           
		if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])           
			rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);         
		for (;;) {                                                          
			n = (*tty->device.pollRead)(tty->minor);                           
  107ddb:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107dde:	ff 76 10             	pushl  0x10(%esi)                     <== NOT EXECUTED
  107de1:	ff 96 a0 00 00 00    	call   *0xa0(%esi)                    <== NOT EXECUTED
			if (n < 0) {                                                       
  107de7:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107dea:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107dec:	79 46                	jns    107e34 <rtems_termios_read+0x155><== NOT EXECUTED
				if (tty->termios.c_cc[VMIN]) {                                    
  107dee:	80 7e 47 00          	cmpb   $0x0,0x47(%esi)                <== NOT EXECUTED
  107df2:	74 0e                	je     107e02 <rtems_termios_read+0x123><== NOT EXECUTED
					if (tty->termios.c_cc[VTIME] && tty->ccount) {                   
  107df4:	80 7e 46 00          	cmpb   $0x0,0x46(%esi)                <== NOT EXECUTED
  107df8:	74 2e                	je     107e28 <rtems_termios_read+0x149><== NOT EXECUTED
  107dfa:	83 7e 20 00          	cmpl   $0x0,0x20(%esi)                <== NOT EXECUTED
  107dfe:	74 28                	je     107e28 <rtems_termios_read+0x149><== NOT EXECUTED
  107e00:	eb 0a                	jmp    107e0c <rtems_termios_read+0x12d><== NOT EXECUTED
							break;                                                         
						}                                                               
					}                                                                
				}                                                                 
				else {                                                            
					if (!tty->termios.c_cc[VTIME])                                   
  107e02:	80 7e 46 00          	cmpb   $0x0,0x46(%esi)                <== NOT EXECUTED
  107e06:	0f 84 a0 01 00 00    	je     107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
						break;                                                          
					rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);        
  107e0c:	50                   	push   %eax                           <== NOT EXECUTED
  107e0d:	50                   	push   %eax                           <== NOT EXECUTED
  107e0e:	53                   	push   %ebx                           <== NOT EXECUTED
  107e0f:	6a 02                	push   $0x2                           <== NOT EXECUTED
  107e11:	e8 6e 0b 00 00       	call   108984 <rtems_clock_get>       <== NOT EXECUTED
					if ((now - then) > tty->vtimeTicks) {                            
  107e16:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  107e19:	2b 45 f0             	sub    -0x10(%ebp),%eax               <== NOT EXECUTED
  107e1c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107e1f:	3b 46 54             	cmp    0x54(%esi),%eax                <== NOT EXECUTED
  107e22:	0f 87 84 01 00 00    	ja     107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
						break;                                                          
					}                                                                
				}                                                                 
				rtems_task_wake_after (1);                                        
  107e28:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107e2b:	6a 01                	push   $0x1                           <== NOT EXECUTED
  107e2d:	e8 8e 17 00 00       	call   1095c0 <rtems_task_wake_after> <== NOT EXECUTED
  107e32:	eb 2d                	jmp    107e61 <rtems_termios_read+0x182><== NOT EXECUTED
			}                                                                  
			else {                                                             
				siproc (n, tty);                                                  
  107e34:	0f b6 c0             	movzbl %al,%eax                       <== NOT EXECUTED
  107e37:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107e39:	e8 4d fd ff ff       	call   107b8b <siproc>                <== NOT EXECUTED
				if (tty->ccount >= tty->termios.c_cc[VMIN])                       
  107e3e:	8a 56 47             	mov    0x47(%esi),%dl                 <== NOT EXECUTED
  107e41:	0f b6 c2             	movzbl %dl,%eax                       <== NOT EXECUTED
  107e44:	39 46 20             	cmp    %eax,0x20(%esi)                <== NOT EXECUTED
  107e47:	0f 8d 5f 01 00 00    	jge    107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
					break;                                                           
				if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])          
  107e4d:	84 d2                	test   %dl,%dl                        <== NOT EXECUTED
  107e4f:	74 8a                	je     107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
  107e51:	80 7e 46 00          	cmpb   $0x0,0x46(%esi)                <== NOT EXECUTED
  107e55:	74 84                	je     107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
					rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);       
  107e57:	50                   	push   %eax                           <== NOT EXECUTED
  107e58:	50                   	push   %eax                           <== NOT EXECUTED
  107e59:	57                   	push   %edi                           <== NOT EXECUTED
  107e5a:	6a 02                	push   $0x2                           <== NOT EXECUTED
  107e5c:	e8 23 0b 00 00       	call   108984 <rtems_clock_get>       <== NOT EXECUTED
  107e61:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107e64:	e9 72 ff ff ff       	jmp    107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
 * Fill the input buffer from the raw input queue                     
 */                                                                   
static rtems_status_code                                              
fillBufferQueue (struct rtems_termios_tty *tty)                       
{                                                                     
	rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;         
  107e69:	8b 7e 74             	mov    0x74(%esi),%edi                <== NOT EXECUTED
			  if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))                  
			       ==                (FL_MDXON | FL_ISNTXOF))                  
			      && ((tty->rawOutBufState == rob_idle)                        
				  || (tty->flow_ctrl & FL_OSTOP))) {                              
			    /* XON should be sent now... */                                
			    (*tty->device.write)(tty->minor,                               
  107e6c:	8d 56 49             	lea    0x49(%esi),%edx                <== NOT EXECUTED
  107e6f:	89 55 e0             	mov    %edx,-0x20(%ebp)               <== NOT EXECUTED
  107e72:	bb 01 00 00 00       	mov    $0x1,%ebx                      <== NOT EXECUTED
  107e77:	e9 11 01 00 00       	jmp    107f8d <rtems_termios_read+0x2ae><== NOT EXECUTED
		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;           
  107e7c:	8b 46 5c             	mov    0x5c(%esi),%eax                <== NOT EXECUTED
  107e7f:	8b 56 64             	mov    0x64(%esi),%edx                <== NOT EXECUTED
  107e82:	40                   	inc    %eax                           <== NOT EXECUTED
  107e83:	89 d1                	mov    %edx,%ecx                      <== NOT EXECUTED
  107e85:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  107e87:	f7 f1                	div    %ecx                           <== NOT EXECUTED
			c = tty->rawInBuf.theBuf[newHead];                                 
  107e89:	8b 46 58             	mov    0x58(%esi),%eax                <== NOT EXECUTED
  107e8c:	0f b6 3c 10          	movzbl (%eax,%edx,1),%edi             <== NOT EXECUTED
			tty->rawInBuf.Head = newHead;                                      
  107e90:	89 56 5c             	mov    %edx,0x5c(%esi)                <== NOT EXECUTED
			if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)                
  107e93:	8b 5e 60             	mov    0x60(%esi),%ebx                <== NOT EXECUTED
  107e96:	8b 46 64             	mov    0x64(%esi),%eax                <== NOT EXECUTED
  107e99:	8b 4e 64             	mov    0x64(%esi),%ecx                <== NOT EXECUTED
  107e9c:	01 d8                	add    %ebx,%eax                      <== NOT EXECUTED
  107e9e:	29 d0                	sub    %edx,%eax                      <== NOT EXECUTED
  107ea0:	31 d2                	xor    %edx,%edx                      <== NOT EXECUTED
  107ea2:	f7 f1                	div    %ecx                           <== NOT EXECUTED
  107ea4:	3b 96 bc 00 00 00    	cmp    0xbc(%esi),%edx                <== NOT EXECUTED
  107eaa:	73 74                	jae    107f20 <rtems_termios_read+0x241><== NOT EXECUTED
			    % tty->rawInBuf.Size)                                          
			   < tty->lowwater) {                                              
			  tty->flow_ctrl &= ~FL_IREQXOF;                                   
  107eac:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107eb2:	83 e0 fe             	and    $0xfffffffe,%eax               <== NOT EXECUTED
  107eb5:	89 86 b8 00 00 00    	mov    %eax,0xb8(%esi)                <== NOT EXECUTED
			  /* if tx stopped and XON should be sent... */                    
			  if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))                  
  107ebb:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107ec1:	25 02 02 00 00       	and    $0x202,%eax                    <== NOT EXECUTED
  107ec6:	3d 02 02 00 00       	cmp    $0x202,%eax                    <== NOT EXECUTED
  107ecb:	75 24                	jne    107ef1 <rtems_termios_read+0x212><== NOT EXECUTED
  107ecd:	83 be 94 00 00 00 00 	cmpl   $0x0,0x94(%esi)                <== NOT EXECUTED
  107ed4:	74 0a                	je     107ee0 <rtems_termios_read+0x201><== NOT EXECUTED
  107ed6:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107edc:	a8 20                	test   $0x20,%al                      <== NOT EXECUTED
  107ede:	74 11                	je     107ef1 <rtems_termios_read+0x212><== NOT EXECUTED
			       ==                (FL_MDXON | FL_ISNTXOF))                  
			      && ((tty->rawOutBufState == rob_idle)                        
				  || (tty->flow_ctrl & FL_OSTOP))) {                              
			    /* XON should be sent now... */                                
			    (*tty->device.write)(tty->minor,                               
  107ee0:	50                   	push   %eax                           <== NOT EXECUTED
  107ee1:	6a 01                	push   $0x1                           <== NOT EXECUTED
  107ee3:	ff 75 e0             	pushl  -0x20(%ebp)                    <== NOT EXECUTED
  107ee6:	ff 76 10             	pushl  0x10(%esi)                     <== NOT EXECUTED
  107ee9:	ff 96 a4 00 00 00    	call   *0xa4(%esi)                    <== NOT EXECUTED
  107eef:	eb 2c                	jmp    107f1d <rtems_termios_read+0x23e><== NOT EXECUTED
				(void *)&(tty->termios.c_cc[VSTART]),                             
				1);                                                               
			  }                                                                
			  else if (tty->flow_ctrl & FL_MDRTS) {                            
  107ef1:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107ef7:	f6 c4 01             	test   $0x1,%ah                       <== NOT EXECUTED
  107efa:	74 24                	je     107f20 <rtems_termios_read+0x241><== NOT EXECUTED
			    tty->flow_ctrl &= ~FL_IRTSOFF;                                 
  107efc:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107f02:	83 e0 fb             	and    $0xfffffffb,%eax               <== NOT EXECUTED
  107f05:	89 86 b8 00 00 00    	mov    %eax,0xb8(%esi)                <== NOT EXECUTED
			    /* activate RTS line */                                        
			    if (tty->device.startRemoteTx != NULL) {                       
  107f0b:	8b 86 b0 00 00 00    	mov    0xb0(%esi),%eax                <== NOT EXECUTED
  107f11:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107f13:	74 0b                	je     107f20 <rtems_termios_read+0x241><== NOT EXECUTED
			      tty->device.startRemoteTx(tty->minor);                       
  107f15:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107f18:	ff 76 10             	pushl  0x10(%esi)                     <== NOT EXECUTED
  107f1b:	ff d0                	call   *%eax                          <== NOT EXECUTED
  107f1d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
			    }                                                              
			  }                                                                
			}                                                                  
                                                                      
			/* continue processing new character */                            
			if (tty->termios.c_lflag & ICANON) {                               
  107f20:	f6 46 3c 02          	testb  $0x2,0x3c(%esi)                <== NOT EXECUTED
  107f24:	74 12                	je     107f38 <rtems_termios_read+0x259><== NOT EXECUTED
				if  (siproc (c, tty))                                             
  107f26:	89 fa                	mov    %edi,%edx                      <== NOT EXECUTED
  107f28:	0f b6 c2             	movzbl %dl,%eax                       <== NOT EXECUTED
  107f2b:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107f2d:	e8 59 fc ff ff       	call   107b8b <siproc>                <== NOT EXECUTED
  107f32:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107f34:	75 17                	jne    107f4d <rtems_termios_read+0x26e><== NOT EXECUTED
  107f36:	eb 1c                	jmp    107f54 <rtems_termios_read+0x275><== NOT EXECUTED
					wait = 0;                                                        
			}                                                                  
			else {                                                             
				siproc (c, tty);                                                  
  107f38:	89 f9                	mov    %edi,%ecx                      <== NOT EXECUTED
  107f3a:	0f b6 c1             	movzbl %cl,%eax                       <== NOT EXECUTED
  107f3d:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107f3f:	e8 47 fc ff ff       	call   107b8b <siproc>                <== NOT EXECUTED
				if (tty->ccount >= tty->termios.c_cc[VMIN])                       
  107f44:	0f b6 46 47          	movzbl 0x47(%esi),%eax                <== NOT EXECUTED
  107f48:	39 46 20             	cmp    %eax,0x20(%esi)                <== NOT EXECUTED
  107f4b:	7c 07                	jl     107f54 <rtems_termios_read+0x275><== NOT EXECUTED
  107f4d:	c7 45 dc 00 00 00 00 	movl   $0x0,-0x24(%ebp)               <== NOT EXECUTED
					wait = 0;                                                        
			}                                                                  
			timeout = tty->rawInBufSemaphoreTimeout;                           
  107f54:	8b 4e 70             	mov    0x70(%esi),%ecx                <== NOT EXECUTED
                                                                      
	while ( wait ) {                                                     
		/*                                                                  
		 * Process characters read from raw queue                           
		 */                                                                 
		while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&                
  107f57:	8b 56 5c             	mov    0x5c(%esi),%edx                <== NOT EXECUTED
  107f5a:	8b 46 60             	mov    0x60(%esi),%eax                <== NOT EXECUTED
  107f5d:	39 c2                	cmp    %eax,%edx                      <== NOT EXECUTED
  107f5f:	74 0f                	je     107f70 <rtems_termios_read+0x291><== NOT EXECUTED
  107f61:	a1 3c b6 11 00       	mov    0x11b63c,%eax                  <== NOT EXECUTED
  107f66:	48                   	dec    %eax                           <== NOT EXECUTED
  107f67:	39 46 20             	cmp    %eax,0x20(%esi)                <== NOT EXECUTED
  107f6a:	0f 8c 0c ff ff ff    	jl     107e7c <rtems_termios_read+0x19d><== NOT EXECUTED
  107f70:	8b 5d dc             	mov    -0x24(%ebp),%ebx               <== NOT EXECUTED
  107f73:	89 cf                	mov    %ecx,%edi                      <== NOT EXECUTED
		}                                                                   
                                                                      
		/*                                                                  
		 * Wait for characters                                              
		 */                                                                 
		if ( wait ) {                                                       
  107f75:	85 db                	test   %ebx,%ebx                      <== NOT EXECUTED
  107f77:	74 33                	je     107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
			sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,              
  107f79:	50                   	push   %eax                           <== NOT EXECUTED
  107f7a:	51                   	push   %ecx                           <== NOT EXECUTED
  107f7b:	ff 76 6c             	pushl  0x6c(%esi)                     <== NOT EXECUTED
  107f7e:	ff 76 68             	pushl  0x68(%esi)                     <== NOT EXECUTED
  107f81:	e8 ee 11 00 00       	call   109174 <rtems_semaphore_obtain><== NOT EXECUTED
				tty->rawInBufSemaphoreOptions,                                    
				timeout);                                                         
			if (sc != RTEMS_SUCCESSFUL)                                        
  107f86:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107f89:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  107f8b:	75 1f                	jne    107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
{                                                                     
	rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;         
	rtems_status_code sc;                                                
	int               wait = (int)1;                                     
                                                                      
	while ( wait ) {                                                     
  107f8d:	89 5d dc             	mov    %ebx,-0x24(%ebp)               <== NOT EXECUTED
  107f90:	89 f9                	mov    %edi,%ecx                      <== NOT EXECUTED
  107f92:	eb c3                	jmp    107f57 <rtems_termios_read+0x278><== NOT EXECUTED
			sc = fillBufferQueue (tty);                                        
		if (sc != RTEMS_SUCCESSFUL)                                         
			tty->cindex = tty->ccount = 0;                                     
	}                                                                    
	while (count && (tty->cindex < tty->ccount)) {                       
		*buffer++ = tty->cbuf[tty->cindex++];                               
  107f94:	8b 46 1c             	mov    0x1c(%esi),%eax                <== NOT EXECUTED
  107f97:	8a 04 10             	mov    (%eax,%edx,1),%al              <== NOT EXECUTED
  107f9a:	8b 4d d4             	mov    -0x2c(%ebp),%ecx               <== NOT EXECUTED
  107f9d:	88 01                	mov    %al,(%ecx)                     <== NOT EXECUTED
  107f9f:	41                   	inc    %ecx                           <== NOT EXECUTED
  107fa0:	89 4d d4             	mov    %ecx,-0x2c(%ebp)               <== NOT EXECUTED
  107fa3:	8d 42 01             	lea    0x1(%edx),%eax                 <== NOT EXECUTED
  107fa6:	89 46 24             	mov    %eax,0x24(%esi)                <== NOT EXECUTED
		count--;                                                            
  107fa9:	ff 4d d0             	decl   -0x30(%ebp)                    <== NOT EXECUTED
		else                                                                
			sc = fillBufferQueue (tty);                                        
		if (sc != RTEMS_SUCCESSFUL)                                         
			tty->cindex = tty->ccount = 0;                                     
	}                                                                    
	while (count && (tty->cindex < tty->ccount)) {                       
  107fac:	83 7d d0 00          	cmpl   $0x0,-0x30(%ebp)               <== NOT EXECUTED
  107fb0:	74 08                	je     107fba <rtems_termios_read+0x2db><== NOT EXECUTED
  107fb2:	8b 56 24             	mov    0x24(%esi),%edx                <== NOT EXECUTED
  107fb5:	3b 56 20             	cmp    0x20(%esi),%edx                <== NOT EXECUTED
  107fb8:	7c da                	jl     107f94 <rtems_termios_read+0x2b5><== NOT EXECUTED
		*buffer++ = tty->cbuf[tty->cindex++];                               
		count--;                                                            
	}                                                                    
	args->bytes_moved = args->count - count;                             
  107fba:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  107fbd:	8b 42 0c             	mov    0xc(%edx),%eax                 <== NOT EXECUTED
  107fc0:	2b 45 d0             	sub    -0x30(%ebp),%eax               <== NOT EXECUTED
  107fc3:	89 42 14             	mov    %eax,0x14(%edx)                <== NOT EXECUTED
	tty->tty_rcvwakeup = 0;                                              
  107fc6:	c7 86 e4 00 00 00 00 	movl   $0x0,0xe4(%esi)                <== NOT EXECUTED
  107fcd:	00 00 00                                                    
	rtems_semaphore_release (tty->isem);                                 
  107fd0:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  107fd3:	ff 76 14             	pushl  0x14(%esi)                     <== NOT EXECUTED
  107fd6:	e8 81 12 00 00       	call   10925c <rtems_semaphore_release><== NOT EXECUTED
  107fdb:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
	return sc;                                                           
}                                                                     
  107fde:	8b 45 d8             	mov    -0x28(%ebp),%eax               <== NOT EXECUTED
  107fe1:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  107fe4:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107fe5:	5e                   	pop    %esi                           <== NOT EXECUTED
  107fe6:	5f                   	pop    %edi                           <== NOT EXECUTED
  107fe7:	c9                   	leave                                 <== NOT EXECUTED
  107fe8:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001071da <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 */ int rtems_termios_refill_transmitter (struct rtems_termios_tty *tty) {
  1071da:	55                   	push   %ebp                           
  1071db:	89 e5                	mov    %esp,%ebp                      
  1071dd:	57                   	push   %edi                           
  1071de:	56                   	push   %esi                           
  1071df:	53                   	push   %ebx                           
  1071e0:	83 ec 0c             	sub    $0xc,%esp                      
  1071e3:	8b 75 08             	mov    0x8(%ebp),%esi                 
	int nToSend;                                                         
	rtems_interrupt_level level;                                         
	int len;                                                             
                                                                      
	/* check for XOF/XON to send */                                      
	if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))          
  1071e6:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                
  1071ec:	25 03 04 00 00       	and    $0x403,%eax                    
  1071f1:	3d 01 04 00 00       	cmp    $0x401,%eax                    
  1071f6:	75 2c                	jne    107224 <rtems_termios_refill_transmitter+0x4a><== ALWAYS TAKEN
	    == (FL_MDXOF | FL_IREQXOF)) {                                    
	  /* XOFF should be sent now... */                                   
	  (*tty->device.write)(tty->minor,                                   
  1071f8:	57                   	push   %edi                           <== NOT EXECUTED
  1071f9:	6a 01                	push   $0x1                           <== NOT EXECUTED
  1071fb:	8d 46 4a             	lea    0x4a(%esi),%eax                <== NOT EXECUTED
  1071fe:	50                   	push   %eax                           <== NOT EXECUTED
  1071ff:	ff 76 10             	pushl  0x10(%esi)                     <== NOT EXECUTED
  107202:	ff 96 a4 00 00 00    	call   *0xa4(%esi)                    <== NOT EXECUTED
			       (void *)&(tty->termios.c_cc[VSTOP]), 1);                    
                                                                      
	  rtems_interrupt_disable(level);                                    
  107208:	9c                   	pushf                                 <== NOT EXECUTED
  107209:	fa                   	cli                                   <== NOT EXECUTED
  10720a:	5a                   	pop    %edx                           <== NOT EXECUTED
	  tty->t_dqlen--;                                                    
  10720b:	ff 8e 90 00 00 00    	decl   0x90(%esi)                     <== NOT EXECUTED
	  tty->flow_ctrl |= FL_ISNTXOF;                                      
  107211:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107217:	83 c8 02             	or     $0x2,%eax                      <== NOT EXECUTED
  10721a:	89 86 b8 00 00 00    	mov    %eax,0xb8(%esi)                <== NOT EXECUTED
	  rtems_interrupt_enable(level);                                     
  107220:	52                   	push   %edx                           <== NOT EXECUTED
  107221:	9d                   	popf                                  <== NOT EXECUTED
  107222:	eb 38                	jmp    10725c <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
                                                                      
	  nToSend = 1;                                                       
	}                                                                    
	else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))                
  107224:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                
  10722a:	83 e0 03             	and    $0x3,%eax                      
  10722d:	83 f8 02             	cmp    $0x2,%eax                      
  107230:	75 37                	jne    107269 <rtems_termios_refill_transmitter+0x8f><== ALWAYS TAKEN
		 * 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,                                   
  107232:	53                   	push   %ebx                           <== NOT EXECUTED
  107233:	6a 01                	push   $0x1                           <== NOT EXECUTED
  107235:	8d 46 49             	lea    0x49(%esi),%eax                <== NOT EXECUTED
  107238:	50                   	push   %eax                           <== NOT EXECUTED
  107239:	ff 76 10             	pushl  0x10(%esi)                     <== NOT EXECUTED
  10723c:	ff 96 a4 00 00 00    	call   *0xa4(%esi)                    <== NOT EXECUTED
			       (void *)&(tty->termios.c_cc[VSTART]), 1);                   
                                                                      
	  rtems_interrupt_disable(level);                                    
  107242:	9c                   	pushf                                 <== NOT EXECUTED
  107243:	fa                   	cli                                   <== NOT EXECUTED
  107244:	5a                   	pop    %edx                           <== NOT EXECUTED
	  tty->t_dqlen--;                                                    
  107245:	ff 8e 90 00 00 00    	decl   0x90(%esi)                     <== NOT EXECUTED
	  tty->flow_ctrl &= ~FL_ISNTXOF;                                     
  10724b:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107251:	83 e0 fd             	and    $0xfffffffd,%eax               <== NOT EXECUTED
  107254:	89 86 b8 00 00 00    	mov    %eax,0xb8(%esi)                <== NOT EXECUTED
	  rtems_interrupt_enable(level);                                     
  10725a:	52                   	push   %edx                           <== NOT EXECUTED
  10725b:	9d                   	popf                                  <== NOT EXECUTED
  10725c:	bb 01 00 00 00       	mov    $0x1,%ebx                      <== NOT EXECUTED
  107261:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  107264:	e9 34 01 00 00       	jmp    10739d <rtems_termios_refill_transmitter+0x1c3><== NOT EXECUTED
                                                                      
	  nToSend = 1;                                                       
	}                                                                    
	else {                                                               
	  if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {                
  107269:	8b 96 80 00 00 00    	mov    0x80(%esi),%edx                
  10726f:	8b 86 84 00 00 00    	mov    0x84(%esi),%eax                
  107275:	39 c2                	cmp    %eax,%edx                      
  107277:	75 21                	jne    10729a <rtems_termios_refill_transmitter+0xc0><== ALWAYS TAKEN
	    /*                                                               
	     * buffer was empty                                              
	     */                                                              
	    if (tty->rawOutBufState == rob_wait) {                           
  107279:	31 db                	xor    %ebx,%ebx                      
  10727b:	83 be 94 00 00 00 02 	cmpl   $0x2,0x94(%esi)                <== NOT EXECUTED
  107282:	0f 85 15 01 00 00    	jne    10739d <rtems_termios_refill_transmitter+0x1c3><== NOT EXECUTED
	      /*                                                             
	       * this should never happen...                                 
	       */                                                            
	      rtems_semaphore_release (tty->rawOutBuf.Semaphore);            
  107288:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10728b:	ff b6 8c 00 00 00    	pushl  0x8c(%esi)                     <== NOT EXECUTED
  107291:	e8 c6 1f 00 00       	call   10925c <rtems_semaphore_release><== NOT EXECUTED
  107296:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  107298:	eb c7                	jmp    107261 <rtems_termios_refill_transmitter+0x87><== NOT EXECUTED
	    }                                                                
	    return 0;                                                        
	  }                                                                  
                                                                      
	  rtems_interrupt_disable(level);                                    
  10729a:	9c                   	pushf                                 
  10729b:	fa                   	cli                                   
  10729c:	58                   	pop    %eax                           
	  len = tty->t_dqlen;                                                
  10729d:	8b 8e 90 00 00 00    	mov    0x90(%esi),%ecx                
	  tty->t_dqlen = 0;                                                  
  1072a3:	c7 86 90 00 00 00 00 	movl   $0x0,0x90(%esi)                
  1072aa:	00 00 00                                                    
	  rtems_interrupt_enable(level);                                     
  1072ad:	50                   	push   %eax                           
  1072ae:	9d                   	popf                                  
                                                                      
	  newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;       
  1072af:	8b 96 84 00 00 00    	mov    0x84(%esi),%edx                
  1072b5:	8b 9e 88 00 00 00    	mov    0x88(%esi),%ebx                
  1072bb:	01 d1                	add    %edx,%ecx                      
  1072bd:	89 c8                	mov    %ecx,%eax                      
  1072bf:	31 d2                	xor    %edx,%edx                      
  1072c1:	f7 f3                	div    %ebx                           
  1072c3:	89 d7                	mov    %edx,%edi                      
	  tty->rawOutBuf.Tail = newTail;                                     
  1072c5:	89 96 84 00 00 00    	mov    %edx,0x84(%esi)                
	  if (tty->rawOutBufState == rob_wait) {                             
  1072cb:	83 be 94 00 00 00 02 	cmpl   $0x2,0x94(%esi)                
  1072d2:	75 11                	jne    1072e5 <rtems_termios_refill_transmitter+0x10b>
	    /*                                                               
	     * wake up any pending writer task                               
	     */                                                              
	    rtems_semaphore_release (tty->rawOutBuf.Semaphore);              
  1072d4:	83 ec 0c             	sub    $0xc,%esp                      
  1072d7:	ff b6 8c 00 00 00    	pushl  0x8c(%esi)                     
  1072dd:	e8 7a 1f 00 00       	call   10925c <rtems_semaphore_release>
  1072e2:	83 c4 10             	add    $0x10,%esp                     
	  }                                                                  
	  if (newTail == tty->rawOutBuf.Head) {                              
  1072e5:	8b 86 80 00 00 00    	mov    0x80(%esi),%eax                
  1072eb:	39 c7                	cmp    %eax,%edi                      
  1072ed:	75 2c                	jne    10731b <rtems_termios_refill_transmitter+0x141>
	    /*                                                               
	     * Buffer has become empty                                       
	     */                                                              
	    tty->rawOutBufState = rob_idle;                                  
  1072ef:	c7 86 94 00 00 00 00 	movl   $0x0,0x94(%esi)                
  1072f6:	00 00 00                                                    
	    nToSend = 0;                                                     
                                                                      
	    /*                                                               
	     * check to see if snd wakeup callback was set                   
	     */                                                              
	    if ( tty->tty_snd.sw_pfn != NULL) {                              
  1072f9:	8b 96 d4 00 00 00    	mov    0xd4(%esi),%edx                
  1072ff:	31 db                	xor    %ebx,%ebx                      
  107301:	85 d2                	test   %edx,%edx                      
  107303:	0f 84 8e 00 00 00    	je     107397 <rtems_termios_refill_transmitter+0x1bd><== ALWAYS TAKEN
	      (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);    
  107309:	51                   	push   %ecx                           <== NOT EXECUTED
  10730a:	51                   	push   %ecx                           <== NOT EXECUTED
  10730b:	ff b6 d8 00 00 00    	pushl  0xd8(%esi)                     <== NOT EXECUTED
  107311:	8d 46 30             	lea    0x30(%esi),%eax                <== NOT EXECUTED
  107314:	50                   	push   %eax                           <== NOT EXECUTED
  107315:	ff d2                	call   *%edx                          <== NOT EXECUTED
  107317:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  107319:	eb 79                	jmp    107394 <rtems_termios_refill_transmitter+0x1ba><== NOT EXECUTED
	    }                                                                
	  }                                                                  
	  /* check, whether output should stop due to received XOFF */       
	  else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))                
  10731b:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                
  107321:	25 10 02 00 00       	and    $0x210,%eax                    
  107326:	3d 10 02 00 00       	cmp    $0x210,%eax                    
  10732b:	75 22                	jne    10734f <rtems_termios_refill_transmitter+0x175><== ALWAYS TAKEN
		   ==                (FL_MDXON | FL_ORCVXOF)) {                     
		  /* Buffer not empty, but output stops due to XOFF */              
		  /* set flag, that output has been stopped */                      
		  rtems_interrupt_disable(level);                                   
  10732d:	9c                   	pushf                                 <== NOT EXECUTED
  10732e:	fa                   	cli                                   <== NOT EXECUTED
  10732f:	5a                   	pop    %edx                           <== NOT EXECUTED
		  tty->flow_ctrl |= FL_OSTOP;                                       
  107330:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                <== NOT EXECUTED
  107336:	83 c8 20             	or     $0x20,%eax                     <== NOT EXECUTED
  107339:	89 86 b8 00 00 00    	mov    %eax,0xb8(%esi)                <== NOT EXECUTED
		  tty->rawOutBufState = rob_busy; /*apm*/                           
  10733f:	c7 86 94 00 00 00 01 	movl   $0x1,0x94(%esi)                <== NOT EXECUTED
  107346:	00 00 00                                                    
		  rtems_interrupt_enable(level);                                    
  107349:	52                   	push   %edx                           <== NOT EXECUTED
  10734a:	9d                   	popf                                  <== NOT EXECUTED
  10734b:	31 db                	xor    %ebx,%ebx                      <== NOT EXECUTED
  10734d:	eb 48                	jmp    107397 <rtems_termios_refill_transmitter+0x1bd><== NOT EXECUTED
	  }                                                                  
	  else {                                                             
	    /*                                                               
	     * Buffer not empty, start tranmitter                            
	     */                                                              
	    if (newTail > tty->rawOutBuf.Head)                               
  10734f:	8b 86 80 00 00 00    	mov    0x80(%esi),%eax                
  107355:	39 c7                	cmp    %eax,%edi                      
  107357:	76 08                	jbe    107361 <rtems_termios_refill_transmitter+0x187>
		    nToSend = tty->rawOutBuf.Size - newTail;                        
  107359:	8b 9e 88 00 00 00    	mov    0x88(%esi),%ebx                
  10735f:	eb 06                	jmp    107367 <rtems_termios_refill_transmitter+0x18d>
	    else                                                             
		    nToSend = tty->rawOutBuf.Head - newTail;                        
  107361:	8b 9e 80 00 00 00    	mov    0x80(%esi),%ebx                
  107367:	29 fb                	sub    %edi,%ebx                      
	    /* 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)) {                    
  107369:	8b 86 b8 00 00 00    	mov    0xb8(%esi),%eax                
  10736f:	f6 c4 06             	test   $0x6,%ah                       
  107372:	74 05                	je     107379 <rtems_termios_refill_transmitter+0x19f><== ALWAYS TAKEN
  107374:	bb 01 00 00 00       	mov    $0x1,%ebx                      <== NOT EXECUTED
		    nToSend = 1;                                                    
	    }                                                                
	    tty->rawOutBufState = rob_busy; /*apm*/                          
  107379:	c7 86 94 00 00 00 01 	movl   $0x1,0x94(%esi)                
  107380:	00 00 00                                                    
	    (*tty->device.write)(tty->minor,                                 
  107383:	50                   	push   %eax                           
  107384:	53                   	push   %ebx                           
  107385:	8b 46 7c             	mov    0x7c(%esi),%eax                
  107388:	01 f8                	add    %edi,%eax                      
  10738a:	50                   	push   %eax                           
  10738b:	ff 76 10             	pushl  0x10(%esi)                     
  10738e:	ff 96 a4 00 00 00    	call   *0xa4(%esi)                    
  107394:	83 c4 10             	add    $0x10,%esp                     
				 &tty->rawOutBuf.theBuf[newTail],                                 
				 nToSend);                                                        
	  }                                                                  
	  tty->rawOutBuf.Tail = newTail; /*apm*/                             
  107397:	89 be 84 00 00 00    	mov    %edi,0x84(%esi)                
	}                                                                    
	return nToSend;                                                      
}                                                                     
  10739d:	89 d8                	mov    %ebx,%eax                      
  10739f:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1073a2:	5b                   	pop    %ebx                           
  1073a3:	5e                   	pop    %esi                           
  1073a4:	5f                   	pop    %edi                           
  1073a5:	c9                   	leave                                 
  1073a6:	c3                   	ret                                   
                                                                      

0010891e <rtems_termios_rxdaemon>: /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) {
  10891e:	55                   	push   %ebp                           <== NOT EXECUTED
  10891f:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  108921:	57                   	push   %edi                           <== NOT EXECUTED
  108922:	56                   	push   %esi                           <== NOT EXECUTED
  108923:	53                   	push   %ebx                           <== NOT EXECUTED
  108924:	83 ec 1c             	sub    $0x1c,%esp                     <== NOT EXECUTED
  108927:	8b 5d 08             	mov    0x8(%ebp),%ebx                 <== NOT EXECUTED
	char c_buf;                                                          
	while (1) {                                                          
		/*                                                                  
		 * wait for rtems event                                             
		 */                                                                 
		rtems_event_receive((TERMIOS_RX_PROC_EVENT |                        
  10892a:	8d 7d ec             	lea    -0x14(%ebp),%edi               <== NOT EXECUTED
			if (c != EOF) {                                                    
				/*                                                                
				 * pollRead did call enqueue on its own                           
				 */                                                               
				c_buf = c;                                                        
				rtems_termios_enqueue_raw_characters (                            
  10892d:	8d 75 f3             	lea    -0xd(%ebp),%esi                <== NOT EXECUTED
	char c_buf;                                                          
	while (1) {                                                          
		/*                                                                  
		 * wait for rtems event                                             
		 */                                                                 
		rtems_event_receive((TERMIOS_RX_PROC_EVENT |                        
  108930:	57                   	push   %edi                           <== NOT EXECUTED
  108931:	6a 00                	push   $0x0                           <== NOT EXECUTED
  108933:	6a 02                	push   $0x2                           <== NOT EXECUTED
  108935:	6a 03                	push   $0x3                           <== NOT EXECUTED
  108937:	e8 38 02 00 00       	call   108b74 <rtems_event_receive>   <== NOT EXECUTED
				     TERMIOS_RX_TERMINATE_EVENT),                                 
				    RTEMS_EVENT_ANY | RTEMS_WAIT,                                 
				    RTEMS_NO_TIMEOUT,                                             
				    &the_event);                                                  
		if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {                
  10893c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10893f:	f6 45 ec 01          	testb  $0x1,-0x14(%ebp)               <== NOT EXECUTED
  108943:	74 16                	je     10895b <rtems_termios_rxdaemon+0x3d><== NOT EXECUTED
			tty->rxTaskId = 0;                                                 
  108945:	c7 83 c4 00 00 00 00 	movl   $0x0,0xc4(%ebx)                <== NOT EXECUTED
  10894c:	00 00 00                                                    
			rtems_task_delete(RTEMS_SELF);                                     
  10894f:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108952:	6a 00                	push   $0x0                           <== NOT EXECUTED
  108954:	e8 c3 0a 00 00       	call   10941c <rtems_task_delete>     <== NOT EXECUTED
  108959:	eb 21                	jmp    10897c <rtems_termios_rxdaemon+0x5e><== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * do something                                                    
			 */                                                                
			c = tty->device.pollRead(tty->minor);                              
  10895b:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10895e:	ff 73 10             	pushl  0x10(%ebx)                     <== NOT EXECUTED
  108961:	ff 93 a0 00 00 00    	call   *0xa0(%ebx)                    <== NOT EXECUTED
			if (c != EOF) {                                                    
  108967:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10896a:	83 f8 ff             	cmp    $0xffffffff,%eax               <== NOT EXECUTED
  10896d:	74 c1                	je     108930 <rtems_termios_rxdaemon+0x12><== NOT EXECUTED
				/*                                                                
				 * pollRead did call enqueue on its own                           
				 */                                                               
				c_buf = c;                                                        
  10896f:	88 45 f3             	mov    %al,-0xd(%ebp)                 <== NOT EXECUTED
				rtems_termios_enqueue_raw_characters (                            
  108972:	50                   	push   %eax                           <== NOT EXECUTED
  108973:	6a 01                	push   $0x1                           <== NOT EXECUTED
  108975:	56                   	push   %esi                           <== NOT EXECUTED
  108976:	53                   	push   %ebx                           <== NOT EXECUTED
  108977:	e8 8f ea ff ff       	call   10740b <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
  10897c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10897f:	eb af                	jmp    108930 <rtems_termios_rxdaemon+0x12><== NOT EXECUTED
                                                                      

001071bf <rtems_termios_rxirq_occured>: * signal receive interrupt to rx daemon * NOTE: This routine runs in the context of the * device receive interrupt handler. */ void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty) {
  1071bf:	55                   	push   %ebp                           <== NOT EXECUTED
  1071c0:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1071c2:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
	/*                                                                   
	 * send event to rx daemon task                                      
	 */                                                                  
	rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);               
  1071c5:	6a 02                	push   $0x2                           <== NOT EXECUTED
  1071c7:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  1071ca:	ff b0 c4 00 00 00    	pushl  0xc4(%eax)                     <== NOT EXECUTED
  1071d0:	e8 0f 1b 00 00       	call   108ce4 <rtems_event_send>      <== NOT EXECUTED
  1071d5:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
}                                                                     
  1071d8:	c9                   	leave                                 <== NOT EXECUTED
  1071d9:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

001088bb <rtems_termios_txdaemon>: /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) {
  1088bb:	55                   	push   %ebp                           <== NOT EXECUTED
  1088bc:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  1088be:	56                   	push   %esi                           <== NOT EXECUTED
  1088bf:	53                   	push   %ebx                           <== NOT EXECUTED
  1088c0:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
  1088c3:	8b 5d 08             	mov    0x8(%ebp),%ebx                 <== NOT EXECUTED
                                                                      
	while (1) {                                                          
		/*                                                                  
		 * wait for rtems event                                             
		 */                                                                 
		rtems_event_receive((TERMIOS_TX_START_EVENT |                       
  1088c6:	8d 75 f4             	lea    -0xc(%ebp),%esi                <== NOT EXECUTED
  1088c9:	56                   	push   %esi                           <== NOT EXECUTED
  1088ca:	6a 00                	push   $0x0                           <== NOT EXECUTED
  1088cc:	6a 02                	push   $0x2                           <== NOT EXECUTED
  1088ce:	6a 03                	push   $0x3                           <== NOT EXECUTED
  1088d0:	e8 9f 02 00 00       	call   108b74 <rtems_event_receive>   <== NOT EXECUTED
				     TERMIOS_TX_TERMINATE_EVENT),                                 
				    RTEMS_EVENT_ANY | RTEMS_WAIT,                                 
				    RTEMS_NO_TIMEOUT,                                             
				    &the_event);                                                  
		if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {                
  1088d5:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  1088d8:	f6 45 f4 01          	testb  $0x1,-0xc(%ebp)                <== NOT EXECUTED
  1088dc:	74 16                	je     1088f4 <rtems_termios_txdaemon+0x39><== NOT EXECUTED
			tty->txTaskId = 0;                                                 
  1088de:	c7 83 c8 00 00 00 00 	movl   $0x0,0xc8(%ebx)                <== NOT EXECUTED
  1088e5:	00 00 00                                                    
			rtems_task_delete(RTEMS_SELF);                                     
  1088e8:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1088eb:	6a 00                	push   $0x0                           <== NOT EXECUTED
  1088ed:	e8 2a 0b 00 00       	call   10941c <rtems_task_delete>     <== NOT EXECUTED
  1088f2:	eb 25                	jmp    108919 <rtems_termios_txdaemon+0x5e><== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * call any line discipline start function                         
			 */                                                                
			if (rtems_termios_linesw[tty->t_line].l_start != NULL) {           
  1088f4:	8b 83 cc 00 00 00    	mov    0xcc(%ebx),%eax                <== NOT EXECUTED
  1088fa:	c1 e0 05             	shl    $0x5,%eax                      <== NOT EXECUTED
  1088fd:	8b 80 60 d4 11 00    	mov    0x11d460(%eax),%eax            <== NOT EXECUTED
  108903:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108905:	74 09                	je     108910 <rtems_termios_txdaemon+0x55><== NOT EXECUTED
				rtems_termios_linesw[tty->t_line].l_start(tty);                   
  108907:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10890a:	53                   	push   %ebx                           <== NOT EXECUTED
  10890b:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10890d:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
			}                                                                  
			/*                                                                 
			 * try to push further characters to device                        
			 */                                                                
			rtems_termios_refill_transmitter(tty);                             
  108910:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108913:	53                   	push   %ebx                           <== NOT EXECUTED
  108914:	e8 c1 e8 ff ff       	call   1071da <rtems_termios_refill_transmitter><== NOT EXECUTED
  108919:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10891c:	eb ab                	jmp    1088c9 <rtems_termios_txdaemon+0xe><== NOT EXECUTED
                                                                      

00107bd9 <rtems_termios_write>: rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) {
  107bd9:	55                   	push   %ebp                           
  107bda:	89 e5                	mov    %esp,%ebp                      
  107bdc:	57                   	push   %edi                           
  107bdd:	56                   	push   %esi                           
  107bde:	53                   	push   %ebx                           
  107bdf:	83 ec 10             	sub    $0x10,%esp                     
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
  107be2:	8b 55 08             	mov    0x8(%ebp),%edx                 
  107be5:	8b 02                	mov    (%edx),%eax                    
  107be7:	8b 78 28             	mov    0x28(%eax),%edi                
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  107bea:	6a 00                	push   $0x0                           
  107bec:	6a 00                	push   $0x0                           
  107bee:	ff 77 18             	pushl  0x18(%edi)                     
  107bf1:	e8 7e 15 00 00       	call   109174 <rtems_semaphore_obtain>
  107bf6:	89 45 f0             	mov    %eax,-0x10(%ebp)               
	if (sc != RTEMS_SUCCESSFUL)                                          
  107bf9:	83 c4 10             	add    $0x10,%esp                     
  107bfc:	85 c0                	test   %eax,%eax                      
  107bfe:	75 77                	jne    107c77 <rtems_termios_write+0x9e><== NEVER TAKEN
		return sc;                                                          
	if (rtems_termios_linesw[tty->t_line].l_write != NULL) {             
  107c00:	8b 87 cc 00 00 00    	mov    0xcc(%edi),%eax                
  107c06:	c1 e0 05             	shl    $0x5,%eax                      
  107c09:	8b 80 58 d4 11 00    	mov    0x11d458(%eax),%eax            
  107c0f:	85 c0                	test   %eax,%eax                      
  107c11:	74 0e                	je     107c21 <rtems_termios_write+0x48><== ALWAYS TAKEN
		sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);           
  107c13:	52                   	push   %edx                           <== NOT EXECUTED
  107c14:	52                   	push   %edx                           <== NOT EXECUTED
  107c15:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  107c18:	57                   	push   %edi                           <== NOT EXECUTED
  107c19:	ff d0                	call   *%eax                          <== NOT EXECUTED
  107c1b:	89 45 f0             	mov    %eax,-0x10(%ebp)               <== NOT EXECUTED
		rtems_semaphore_release (tty->osem);                                
  107c1e:	5e                   	pop    %esi                           <== NOT EXECUTED
  107c1f:	eb 4b                	jmp    107c6c <rtems_termios_write+0x93><== NOT EXECUTED
		return sc;                                                          
	}                                                                    
	if (tty->termios.c_oflag & OPOST) {                                  
  107c21:	f6 47 34 01          	testb  $0x1,0x34(%edi)                
  107c25:	74 26                	je     107c4d <rtems_termios_write+0x74><== NEVER TAKEN
		uint32_t   count = args->count;                                     
  107c27:	8b 45 08             	mov    0x8(%ebp),%eax                 
  107c2a:	8b 70 0c             	mov    0xc(%eax),%esi                 
		char      *buffer = args->buffer;                                   
  107c2d:	8b 58 08             	mov    0x8(%eax),%ebx                 
  107c30:	eb 0c                	jmp    107c3e <rtems_termios_write+0x65>
		while (count--)                                                     
			oproc (*buffer++, tty);                                            
  107c32:	0f b6 03             	movzbl (%ebx),%eax                    
  107c35:	43                   	inc    %ebx                           
  107c36:	89 fa                	mov    %edi,%edx                      
  107c38:	e8 6b fb ff ff       	call   1077a8 <oproc>                 
  107c3d:	4e                   	dec    %esi                           
		return sc;                                                          
	}                                                                    
	if (tty->termios.c_oflag & OPOST) {                                  
		uint32_t   count = args->count;                                     
		char      *buffer = args->buffer;                                   
		while (count--)                                                     
  107c3e:	85 f6                	test   %esi,%esi                      
  107c40:	75 f0                	jne    107c32 <rtems_termios_write+0x59>
			oproc (*buffer++, tty);                                            
		args->bytes_moved = args->count;                                    
  107c42:	8b 55 08             	mov    0x8(%ebp),%edx                 
  107c45:	8b 42 0c             	mov    0xc(%edx),%eax                 
  107c48:	89 42 14             	mov    %eax,0x14(%edx)                
  107c4b:	eb 1c                	jmp    107c69 <rtems_termios_write+0x90>
	}                                                                    
	else {                                                               
		rtems_termios_puts (args->buffer, args->count, tty);                
  107c4d:	53                   	push   %ebx                           <== NOT EXECUTED
  107c4e:	57                   	push   %edi                           <== NOT EXECUTED
  107c4f:	8b 45 08             	mov    0x8(%ebp),%eax                 <== NOT EXECUTED
  107c52:	ff 70 0c             	pushl  0xc(%eax)                      <== NOT EXECUTED
  107c55:	ff 70 08             	pushl  0x8(%eax)                      <== NOT EXECUTED
  107c58:	e8 36 fa ff ff       	call   107693 <rtems_termios_puts>    <== NOT EXECUTED
		args->bytes_moved = args->count;                                    
  107c5d:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
  107c60:	8b 42 0c             	mov    0xc(%edx),%eax                 <== NOT EXECUTED
  107c63:	89 42 14             	mov    %eax,0x14(%edx)                <== NOT EXECUTED
  107c66:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
	}                                                                    
	rtems_semaphore_release (tty->osem);                                 
  107c69:	83 ec 0c             	sub    $0xc,%esp                      
  107c6c:	ff 77 18             	pushl  0x18(%edi)                     
  107c6f:	e8 e8 15 00 00       	call   10925c <rtems_semaphore_release>
  107c74:	83 c4 10             	add    $0x10,%esp                     
	return sc;                                                           
}                                                                     
  107c77:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  107c7a:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  107c7d:	5b                   	pop    %ebx                           
  107c7e:	5e                   	pop    %esi                           
  107c7f:	5f                   	pop    %edi                           
  107c80:	c9                   	leave                                 
  107c81:	c3                   	ret                                   
                                                                      

00112ad8 <rtems_timer_cancel>: */ rtems_status_code rtems_timer_cancel( Objects_Id id ) {
  112ad8:	55                   	push   %ebp                           
  112ad9:	89 e5                	mov    %esp,%ebp                      
  112adb:	83 ec 1c             	sub    $0x1c,%esp                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  112ade:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  112ae1:	50                   	push   %eax                           
  112ae2:	ff 75 08             	pushl  0x8(%ebp)                      
  112ae5:	68 78 4a 13 00       	push   $0x134a78                      
  112aea:	e8 09 25 00 00       	call   114ff8 <_Objects_Get>          
  112aef:	89 c2                	mov    %eax,%edx                      
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  112af1:	83 c4 10             	add    $0x10,%esp                     
  112af4:	b8 04 00 00 00       	mov    $0x4,%eax                      
  112af9:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  112afd:	75 1c                	jne    112b1b <rtems_timer_cancel+0x43>
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
  112aff:	83 7a 38 04          	cmpl   $0x4,0x38(%edx)                
  112b03:	74 0f                	je     112b14 <rtems_timer_cancel+0x3c><== NEVER TAKEN
        (void) _Watchdog_Remove( &the_timer->Ticker );                
  112b05:	83 ec 0c             	sub    $0xc,%esp                      
  112b08:	8d 42 10             	lea    0x10(%edx),%eax                
  112b0b:	50                   	push   %eax                           
  112b0c:	e8 db 3e 00 00       	call   1169ec <_Watchdog_Remove>      
  112b11:	83 c4 10             	add    $0x10,%esp                     
      _Thread_Enable_dispatch();                                      
  112b14:	e8 9f 2c 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112b19:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  112b1b:	c9                   	leave                                 
  112b1c:	c3                   	ret                                   
                                                                      

0010a038 <rtems_timer_create>: rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) {
  10a038:	55                   	push   %ebp                           
  10a039:	89 e5                	mov    %esp,%ebp                      
  10a03b:	57                   	push   %edi                           
  10a03c:	56                   	push   %esi                           
  10a03d:	53                   	push   %ebx                           
  10a03e:	83 ec 0c             	sub    $0xc,%esp                      
  10a041:	8b 75 08             	mov    0x8(%ebp),%esi                 
  10a044:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  Timer_Control *the_timer;                                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
  10a047:	b8 03 00 00 00       	mov    $0x3,%eax                      
  10a04c:	85 f6                	test   %esi,%esi                      
  10a04e:	74 73                	je     10a0c3 <rtems_timer_create+0x8b>
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
  10a050:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10a055:	85 ff                	test   %edi,%edi                      
  10a057:	74 6a                	je     10a0c3 <rtems_timer_create+0x8b><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10a059:	a1 98 0a 12 00       	mov    0x120a98,%eax                  
  10a05e:	40                   	inc    %eax                           
  10a05f:	a3 98 0a 12 00       	mov    %eax,0x120a98                  
                                                                      
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
  10a064:	83 ec 0c             	sub    $0xc,%esp                      
  10a067:	68 80 10 12 00       	push   $0x121080                      
  10a06c:	e8 f7 0d 00 00       	call   10ae68 <_Objects_Allocate>     
  10a071:	89 c3                	mov    %eax,%ebx                      
                                                                      
  _Thread_Disable_dispatch();         /* to prevent deletion */       
                                                                      
  the_timer = _Timer_Allocate();                                      
                                                                      
  if ( !the_timer ) {                                                 
  10a073:	83 c4 10             	add    $0x10,%esp                     
  10a076:	85 c0                	test   %eax,%eax                      
  10a078:	75 0c                	jne    10a086 <rtems_timer_create+0x4e>
    _Thread_Enable_dispatch();                                        
  10a07a:	e8 ed 19 00 00       	call   10ba6c <_Thread_Enable_dispatch>
  10a07f:	b8 05 00 00 00       	mov    $0x5,%eax                      
  10a084:	eb 3d                	jmp    10a0c3 <rtems_timer_create+0x8b>
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_timer->the_class = TIMER_DORMANT;                               
  10a086:	c7 40 38 04 00 00 00 	movl   $0x4,0x38(%eax)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10a08d:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)                
 *  @param[in] the_heap is the heap to operate upon                   
  10a094:	c7 40 2c 00 00 00 00 	movl   $0x0,0x2c(%eax)                
 *  @param[in] starting_address is the starting address of the memory for
  10a09b:	c7 40 30 00 00 00 00 	movl   $0x0,0x30(%eax)                
 *         the heap                                                   
  10a0a2:	c7 40 34 00 00 00 00 	movl   $0x0,0x34(%eax)                
  10a0a9:	8b 48 08             	mov    0x8(%eax),%ecx                 
  10a0ac:	0f b7 d1             	movzwl %cx,%edx                       
  10a0af:	a1 9c 10 12 00       	mov    0x12109c,%eax                  
  10a0b4:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  10a0b7:	89 73 0c             	mov    %esi,0xc(%ebx)                 
    &_Timer_Information,                                              
    &the_timer->Object,                                               
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_timer->Object.id;                                         
  10a0ba:	89 0f                	mov    %ecx,(%edi)                    
  _Thread_Enable_dispatch();                                          
  10a0bc:	e8 ab 19 00 00       	call   10ba6c <_Thread_Enable_dispatch>
  10a0c1:	31 c0                	xor    %eax,%eax                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
  10a0c3:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a0c6:	5b                   	pop    %ebx                           
  10a0c7:	5e                   	pop    %esi                           
  10a0c8:	5f                   	pop    %edi                           
  10a0c9:	c9                   	leave                                 
  10a0ca:	c3                   	ret                                   
                                                                      

0010a0cc <rtems_timer_fire_after>: Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) {
  10a0cc:	55                   	push   %ebp                           
  10a0cd:	89 e5                	mov    %esp,%ebp                      
  10a0cf:	57                   	push   %edi                           
  10a0d0:	56                   	push   %esi                           
  10a0d1:	53                   	push   %ebx                           
  10a0d2:	83 ec 1c             	sub    $0x1c,%esp                     
  10a0d5:	8b 7d 10             	mov    0x10(%ebp),%edi                
  Timer_Control      *the_timer;                                      
  Objects_Locations   location;                                       
  ISR_Level           level;                                          
                                                                      
  if ( ticks == 0 )                                                   
  10a0d8:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  10a0dd:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  10a0e1:	0f 84 8e 00 00 00    	je     10a175 <rtems_timer_fire_after+0xa9>
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  if ( !routine )                                                     
  10a0e7:	b8 09 00 00 00       	mov    $0x9,%eax                      
  10a0ec:	85 ff                	test   %edi,%edi                      
  10a0ee:	0f 84 81 00 00 00    	je     10a175 <rtems_timer_fire_after+0xa9><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  10a0f4:	52                   	push   %edx                           
  10a0f5:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10a0f8:	50                   	push   %eax                           
  10a0f9:	ff 75 08             	pushl  0x8(%ebp)                      
  10a0fc:	68 80 10 12 00       	push   $0x121080                      
  10a101:	e8 a6 11 00 00       	call   10b2ac <_Objects_Get>          
  10a106:	89 c3                	mov    %eax,%ebx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  10a108:	83 c4 10             	add    $0x10,%esp                     
  10a10b:	b8 04 00 00 00       	mov    $0x4,%eax                      
  10a110:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10a114:	75 5f                	jne    10a175 <rtems_timer_fire_after+0xa9>
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
  10a116:	8d 73 10             	lea    0x10(%ebx),%esi                
  10a119:	83 ec 0c             	sub    $0xc,%esp                      
  10a11c:	56                   	push   %esi                           
  10a11d:	e8 6a 28 00 00       	call   10c98c <_Watchdog_Remove>      
                                                                      
      _ISR_Disable( level );                                          
  10a122:	9c                   	pushf                                 
  10a123:	fa                   	cli                                   
  10a124:	5a                   	pop    %edx                           
        /*                                                            
         *  Check to see if the watchdog has just been inserted by a  
         *  higher priority interrupt.  If so, abandon this insert.   
         */                                                           
                                                                      
        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {         
  10a125:	83 c4 10             	add    $0x10,%esp                     
  10a128:	83 7b 18 00          	cmpl   $0x0,0x18(%ebx)                
  10a12c:	74 0b                	je     10a139 <rtems_timer_fire_after+0x6d><== ALWAYS TAKEN
          _ISR_Enable( level );                                       
  10a12e:	52                   	push   %edx                           <== NOT EXECUTED
  10a12f:	9d                   	popf                                  <== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
  10a130:	e8 37 19 00 00       	call   10ba6c <_Thread_Enable_dispatch><== NOT EXECUTED
  10a135:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  10a137:	eb 3c                	jmp    10a175 <rtems_timer_fire_after+0xa9><== NOT EXECUTED
        /*                                                            
         *  OK.  Now we now the timer was not rescheduled by an interrupt
         *  so we can atomically initialize it as in use.             
         */                                                           
                                                                      
        the_timer->the_class = TIMER_INTERVAL;                        
  10a139:	c7 43 38 00 00 00 00 	movl   $0x0,0x38(%ebx)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10a140:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  10a147:	89 7b 2c             	mov    %edi,0x2c(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  10a14a:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10a14d:	89 43 30             	mov    %eax,0x30(%ebx)                
 *         the heap                                                   
  10a150:	8b 45 14             	mov    0x14(%ebp),%eax                
  10a153:	89 43 34             	mov    %eax,0x34(%ebx)                
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _ISR_Enable( level );                                           
  10a156:	52                   	push   %edx                           
  10a157:	9d                   	popf                                  
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  10a158:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  10a15b:	89 43 1c             	mov    %eax,0x1c(%ebx)                
  void                *starting_address,                              
  size_t              *size                                           
  10a15e:	50                   	push   %eax                           
  10a15f:	50                   	push   %eax                           
  10a160:	56                   	push   %esi                           
  10a161:	68 78 0b 12 00       	push   $0x120b78                      
  10a166:	e8 09 27 00 00       	call   10c874 <_Watchdog_Insert>      
                                                                      
                                                                      
      _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );            
      _Thread_Enable_dispatch();                                      
  10a16b:	e8 fc 18 00 00       	call   10ba6c <_Thread_Enable_dispatch>
  10a170:	31 c0                	xor    %eax,%eax                      
  10a172:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  10a175:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a178:	5b                   	pop    %ebx                           
  10a179:	5e                   	pop    %esi                           
  10a17a:	5f                   	pop    %edi                           
  10a17b:	c9                   	leave                                 
  10a17c:	c3                   	ret                                   
                                                                      

00112cc4 <rtems_timer_fire_when>: Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
  112cc4:	55                   	push   %ebp                           
  112cc5:	89 e5                	mov    %esp,%ebp                      
  112cc7:	57                   	push   %edi                           
  112cc8:	56                   	push   %esi                           
  112cc9:	53                   	push   %ebx                           
  112cca:	83 ec 1c             	sub    $0x1c,%esp                     
  112ccd:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  Timer_Control       *the_timer;                                     
  Objects_Locations    location;                                      
  rtems_interval       seconds;                                       
                                                                      
  if ( !_TOD_Is_set )                                                 
  112cd0:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  112cd5:	80 3d 4c 41 13 00 00 	cmpb   $0x0,0x13414c                  
  112cdc:	0f 84 ae 00 00 00    	je     112d90 <rtems_timer_fire_when+0xcc>
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
  112ce2:	83 ec 0c             	sub    $0xc,%esp                      
  112ce5:	53                   	push   %ebx                           
  112ce6:	e8 85 da ff ff       	call   110770 <_TOD_Validate>         
  112ceb:	83 c4 10             	add    $0x10,%esp                     
  112cee:	84 c0                	test   %al,%al                        
  112cf0:	0f 84 95 00 00 00    	je     112d8b <rtems_timer_fire_when+0xc7>
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  if ( !routine )                                                     
  112cf6:	b8 09 00 00 00       	mov    $0x9,%eax                      
  112cfb:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  112cff:	0f 84 8b 00 00 00    	je     112d90 <rtems_timer_fire_when+0xcc><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
  112d05:	83 ec 0c             	sub    $0xc,%esp                      
  112d08:	53                   	push   %ebx                           
  112d09:	e8 fa d9 ff ff       	call   110708 <_TOD_To_seconds>       
  112d0e:	89 c7                	mov    %eax,%edi                      
  if ( seconds <= _TOD_Seconds_since_epoch )                          
  112d10:	83 c4 10             	add    $0x10,%esp                     
  112d13:	3b 05 c8 41 13 00    	cmp    0x1341c8,%eax                  
  112d19:	76 70                	jbe    112d8b <rtems_timer_fire_when+0xc7>
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  112d1b:	51                   	push   %ecx                           
  112d1c:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  112d1f:	50                   	push   %eax                           
  112d20:	ff 75 08             	pushl  0x8(%ebp)                      
  112d23:	68 78 4a 13 00       	push   $0x134a78                      
  112d28:	e8 cb 22 00 00       	call   114ff8 <_Objects_Get>          
  112d2d:	89 c6                	mov    %eax,%esi                      
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  112d2f:	83 c4 10             	add    $0x10,%esp                     
  112d32:	b8 04 00 00 00       	mov    $0x4,%eax                      
  112d37:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  112d3b:	75 53                	jne    112d90 <rtems_timer_fire_when+0xcc>
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
  112d3d:	8d 5e 10             	lea    0x10(%esi),%ebx                
  112d40:	83 ec 0c             	sub    $0xc,%esp                      
  112d43:	53                   	push   %ebx                           
  112d44:	e8 a3 3c 00 00       	call   1169ec <_Watchdog_Remove>      
      the_timer->the_class = TIMER_TIME_OF_DAY;                       
  112d49:	c7 46 38 02 00 00 00 	movl   $0x2,0x38(%esi)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  112d50:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)                
 *  @param[in] the_heap is the heap to operate upon                   
  112d57:	8b 45 10             	mov    0x10(%ebp),%eax                
  112d5a:	89 46 2c             	mov    %eax,0x2c(%esi)                
 *  @param[in] starting_address is the starting address of the memory for
  112d5d:	8b 45 08             	mov    0x8(%ebp),%eax                 
  112d60:	89 46 30             	mov    %eax,0x30(%esi)                
 *         the heap                                                   
  112d63:	8b 45 14             	mov    0x14(%ebp),%eax                
  112d66:	89 46 34             	mov    %eax,0x34(%esi)                
 *  @return TRUE if successfully able to resize the block.            
 *          FALSE if the block can't be resized in place.             
 */                                                                   
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  112d69:	2b 3d c8 41 13 00    	sub    0x1341c8,%edi                  
  112d6f:	89 7e 1c             	mov    %edi,0x1c(%esi)                
  size_t        size                                                  
);                                                                    
  112d72:	58                   	pop    %eax                           
  112d73:	5a                   	pop    %edx                           
  112d74:	53                   	push   %ebx                           
  112d75:	68 0c 42 13 00       	push   $0x13420c                      
  112d7a:	e8 55 3b 00 00       	call   1168d4 <_Watchdog_Insert>      
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _Watchdog_Insert_seconds(                                       
         &the_timer->Ticker,                                          
         seconds - _TOD_Seconds_since_epoch                           
       );                                                             
      _Thread_Enable_dispatch();                                      
  112d7f:	e8 34 2a 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112d84:	31 c0                	xor    %eax,%eax                      
  112d86:	83 c4 10             	add    $0x10,%esp                     
  112d89:	eb 05                	jmp    112d90 <rtems_timer_fire_when+0xcc>
      return RTEMS_SUCCESSFUL;                                        
  112d8b:	b8 14 00 00 00       	mov    $0x14,%eax                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  112d90:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  112d93:	5b                   	pop    %ebx                           
  112d94:	5e                   	pop    %esi                           
  112d95:	5f                   	pop    %edi                           
  112d96:	c9                   	leave                                 
  112d97:	c3                   	ret                                   
                                                                      

00112d98 <rtems_timer_get_information>: rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) {
  112d98:	55                   	push   %ebp                           
  112d99:	89 e5                	mov    %esp,%ebp                      
  112d9b:	53                   	push   %ebx                           
  112d9c:	83 ec 14             	sub    $0x14,%esp                     
  112d9f:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  if ( !the_info )                                                    
  112da2:	b8 09 00 00 00       	mov    $0x9,%eax                      
  112da7:	85 db                	test   %ebx,%ebx                      
  112da9:	74 40                	je     112deb <rtems_timer_get_information+0x53><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  112dab:	50                   	push   %eax                           
  112dac:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  112daf:	50                   	push   %eax                           
  112db0:	ff 75 08             	pushl  0x8(%ebp)                      
  112db3:	68 78 4a 13 00       	push   $0x134a78                      
  112db8:	e8 3b 22 00 00       	call   114ff8 <_Objects_Get>          
  112dbd:	89 c2                	mov    %eax,%edx                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  112dbf:	83 c4 10             	add    $0x10,%esp                     
  112dc2:	b8 04 00 00 00       	mov    $0x4,%eax                      
  112dc7:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  112dcb:	75 1e                	jne    112deb <rtems_timer_get_information+0x53>
                                                                      
    case OBJECTS_LOCAL:                                               
      the_info->the_class  = the_timer->the_class;                    
  112dcd:	8b 42 38             	mov    0x38(%edx),%eax                
  112dd0:	89 03                	mov    %eax,(%ebx)                    
      the_info->initial    = the_timer->Ticker.initial;               
  112dd2:	8b 42 1c             	mov    0x1c(%edx),%eax                
  112dd5:	89 43 04             	mov    %eax,0x4(%ebx)                 
      the_info->start_time = the_timer->Ticker.start_time;            
  112dd8:	8b 42 24             	mov    0x24(%edx),%eax                
  112ddb:	89 43 08             	mov    %eax,0x8(%ebx)                 
      the_info->stop_time  = the_timer->Ticker.stop_time;             
  112dde:	8b 42 28             	mov    0x28(%edx),%eax                
  112de1:	89 43 0c             	mov    %eax,0xc(%ebx)                 
      _Thread_Enable_dispatch();                                      
  112de4:	e8 cf 29 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112de9:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  112deb:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  112dee:	c9                   	leave                                 
  112def:	c3                   	ret                                   
                                                                      

00113048 <rtems_timer_initiate_server>: rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) {
  113048:	55                   	push   %ebp                           
  113049:	89 e5                	mov    %esp,%ebp                      
  11304b:	57                   	push   %edi                           
  11304c:	56                   	push   %esi                           
  11304d:	53                   	push   %ebx                           
  11304e:	83 ec 1c             	sub    $0x1c,%esp                     
  113051:	8b 55 08             	mov    0x8(%ebp),%edx                 
  113054:	8b 75 10             	mov    0x10(%ebp),%esi                
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size                                                  
);                                                                    
                                                                      
  113057:	31 c0                	xor    %eax,%eax                      
  113059:	85 d2                	test   %edx,%edx                      
  11305b:	74 0f                	je     11306c <rtems_timer_initiate_server+0x24>
  11305d:	0f b6 05 c4 b9 12 00 	movzbl 0x12b9c4,%eax                  
  113064:	39 c2                	cmp    %eax,%edx                      
  113066:	0f 96 c0             	setbe  %al                            
  113069:	0f b6 c0             	movzbl %al,%eax                       
   *  Make sure the requested priority is valid.  The if is           
   *  structured so we check it is invalid before looking for         
   *  a specific invalid value as the default.                        
   */                                                                 
  _priority = priority;                                               
  if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {                
  11306c:	89 d7                	mov    %edx,%edi                      
  11306e:	85 c0                	test   %eax,%eax                      
  113070:	75 0e                	jne    113080 <rtems_timer_initiate_server+0x38><== NEVER TAKEN
    if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )            
  113072:	b8 13 00 00 00       	mov    $0x13,%eax                     
  113077:	42                   	inc    %edx                           
  113078:	0f 85 31 01 00 00    	jne    1131af <rtems_timer_initiate_server+0x167>
  11307e:	31 ff                	xor    %edi,%edi                      
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  113080:	a1 38 41 13 00       	mov    0x134138,%eax                  
  113085:	40                   	inc    %eax                           
  113086:	a3 38 41 13 00       	mov    %eax,0x134138                  
                                                                      
  /*                                                                  
   *  Just to make sure this is only called once.                     
   */                                                                 
  _Thread_Disable_dispatch();                                         
    tmpInitialized  = initialized;                                    
  11308b:	8a 1d ac fb 12 00    	mov    0x12fbac,%bl                   
    initialized = true;                                               
  113091:	c6 05 ac fb 12 00 01 	movb   $0x1,0x12fbac                  
  _Thread_Enable_dispatch();                                          
  113098:	e8 1b 27 00 00       	call   1157b8 <_Thread_Enable_dispatch>
                                                                      
  if ( tmpInitialized )                                               
  11309d:	b8 0e 00 00 00       	mov    $0xe,%eax                      
  1130a2:	84 db                	test   %bl,%bl                        
  1130a4:	0f 85 05 01 00 00    	jne    1131af <rtems_timer_initiate_server+0x167>
  1130aa:	c7 05 cc 40 13 00 d0 	movl   $0x1340d0,0x1340cc             
  1130b1:	40 13 00                                                    
  1130b4:	c7 05 d0 40 13 00 00 	movl   $0x0,0x1340d0                  
  1130bb:	00 00 00                                                    
  1130be:	c7 05 d4 40 13 00 cc 	movl   $0x1340cc,0x1340d4             
  1130c5:	40 13 00                                                    
   *  other library rules.  For example, if using a TSR written in Ada the
   *  Server should run at the same priority as the priority Ada task.
   *  Otherwise, the priority ceiling for the mutex used to protect the
   *  GNAT run-time is violated.                                      
   */                                                                 
  status = rtems_task_create(                                         
  1130c8:	52                   	push   %edx                           
  1130c9:	52                   	push   %edx                           
  1130ca:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  1130cd:	50                   	push   %eax                           
  1130ce:	81 ce 00 80 00 00    	or     $0x8000,%esi                   
  1130d4:	56                   	push   %esi                           
  1130d5:	68 00 01 00 00       	push   $0x100                         
  1130da:	ff 75 0c             	pushl  0xc(%ebp)                      
  1130dd:	57                   	push   %edi                           
  1130de:	68 45 4d 49 54       	push   $0x54494d45                    
  1130e3:	e8 70 f3 ff ff       	call   112458 <rtems_task_create>     
                          /* user may want floating point but we need */
                          /*   system task specified for 0 priority */
    attribute_set | RTEMS_SYSTEM_TASK,                                
    &id                   /* get the id back */                       
  );                                                                  
  if (status) {                                                       
  1130e8:	83 c4 20             	add    $0x20,%esp                     
  1130eb:	85 c0                	test   %eax,%eax                      
  1130ed:	0f 85 b5 00 00 00    	jne    1131a8 <rtems_timer_initiate_server+0x160>
   *  to a TCB pointer from here out.                                 
   *                                                                  
   *  NOTE: Setting the pointer to the Timer Server TCB to a value other than
   *        NULL indicates that task-based timer support is initialized.
   */                                                                 
  _Timer_Server = (Thread_Control *)_Objects_Get_local_object(        
  1130f3:	8b 4d f0             	mov    -0x10(%ebp),%ecx               
bool _Protected_heap_Get_information(                                 
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
);                                                                    
                                                                      
/**                                                                   
  1130f6:	31 c0                	xor    %eax,%eax                      
  1130f8:	66 3b 0d 7c 40 13 00 	cmp    0x13407c,%cx                   
  1130ff:	77 0b                	ja     11310c <rtems_timer_initiate_server+0xc4><== NEVER TAKEN
 *  This heap routine returns information about the free blocks       
 *  in the specified heap.                                            
  113101:	0f b7 d1             	movzwl %cx,%edx                       
  113104:	a1 88 40 13 00       	mov    0x134088,%eax                  
  113109:	8b 04 90             	mov    (%eax,%edx,4),%eax             
  11310c:	a3 bc 4a 13 00       	mov    %eax,0x134abc                  
  113111:	c7 05 ac 40 13 00 b0 	movl   $0x1340b0,0x1340ac             
  113118:	40 13 00                                                    
  11311b:	c7 05 b0 40 13 00 00 	movl   $0x0,0x1340b0                  
  113122:	00 00 00                                                    
  113125:	c7 05 b4 40 13 00 ac 	movl   $0x1340ac,0x1340b4             
  11312c:	40 13 00                                                    
  11312f:	c7 05 c0 40 13 00 c4 	movl   $0x1340c4,0x1340c0             
  113136:	40 13 00                                                    
  113139:	c7 05 c4 40 13 00 00 	movl   $0x0,0x1340c4                  
  113140:	00 00 00                                                    
  113143:	c7 05 c8 40 13 00 c0 	movl   $0x1340c0,0x1340c8             
  11314a:	40 13 00                                                    
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  11314d:	c7 40 50 00 00 00 00 	movl   $0x0,0x50(%eax)                
 *  @param[in] the_heap is the heap to operate upon                   
  113154:	c7 40 64 3c 56 11 00 	movl   $0x11563c,0x64(%eax)           
 *  @param[in] starting_address is the starting address of the memory for
  11315b:	89 48 68             	mov    %ecx,0x68(%eax)                
 *         the heap                                                   
  11315e:	c7 40 6c 00 00 00 00 	movl   $0x0,0x6c(%eax)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  113165:	c7 05 e0 40 13 00 00 	movl   $0x0,0x1340e0                  
  11316c:	00 00 00                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  11316f:	c7 05 f4 40 13 00 3c 	movl   $0x11563c,0x1340f4             
  113176:	56 11 00                                                    
 *  @param[in] starting_address is the starting address of the memory for
  113179:	89 0d f8 40 13 00    	mov    %ecx,0x1340f8                  
 *         the heap                                                   
  11317f:	c7 05 fc 40 13 00 00 	movl   $0x0,0x1340fc                  
  113186:	00 00 00                                                    
                                                                      
  /*                                                                  
   *  Initialize the pointer to the timer reset method so applications
   *  that do not use the Timer Server do not have to pull it in.     
   */                                                                 
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;
  113189:	c7 05 b8 4a 13 00 b7 	movl   $0x1131b7,0x134ab8             
  113190:	31 11 00                                                    
                                                                      
  /*                                                                  
   *  Start the timer server                                          
   */                                                                 
  status = rtems_task_start(                                          
  113193:	50                   	push   %eax                           
  113194:	6a 00                	push   $0x0                           
  113196:	68 40 32 11 00       	push   $0x113240                      
  11319b:	51                   	push   %ecx                           
  11319c:	e8 53 f7 ff ff       	call   1128f4 <rtems_task_start>      
    id,                                    /* the id from create */   
    (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */
    0                                      /* there is no argument */ 
  );                                                                  
  if (status) {                                                       
  1131a1:	83 c4 10             	add    $0x10,%esp                     
  1131a4:	85 c0                	test   %eax,%eax                      
  1131a6:	74 07                	je     1131af <rtems_timer_initiate_server+0x167><== ALWAYS TAKEN
     *  but there is actually no way (in normal circumstances) that the
     *  start can fail.  The id and starting address are known to be  
     *  be good.  If this service fails, something is weirdly wrong on the
     *  target such as a stray write in an ISR or incorrect memory layout.
     */                                                               
    initialized = false;                                              
  1131a8:	c6 05 ac fb 12 00 00 	movb   $0x0,0x12fbac                  
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
  1131af:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  1131b2:	5b                   	pop    %ebx                           
  1131b3:	5e                   	pop    %esi                           
  1131b4:	5f                   	pop    %edi                           
  1131b5:	c9                   	leave                                 
  1131b6:	c3                   	ret                                   
                                                                      

00112e14 <rtems_timer_reset>: */ rtems_status_code rtems_timer_reset( Objects_Id id ) {
  112e14:	55                   	push   %ebp                           
  112e15:	89 e5                	mov    %esp,%ebp                      
  112e17:	53                   	push   %ebx                           
  112e18:	83 ec 18             	sub    $0x18,%esp                     
  112e1b:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  112e1e:	50                   	push   %eax                           
  112e1f:	ff 75 08             	pushl  0x8(%ebp)                      
  112e22:	68 78 4a 13 00       	push   $0x134a78                      
  112e27:	e8 cc 21 00 00       	call   114ff8 <_Objects_Get>          
  112e2c:	89 c3                	mov    %eax,%ebx                      
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  112e2e:	83 c4 10             	add    $0x10,%esp                     
  112e31:	b8 04 00 00 00       	mov    $0x4,%eax                      
  112e36:	83 7d f8 00          	cmpl   $0x0,-0x8(%ebp)                
  112e3a:	75 6e                	jne    112eaa <rtems_timer_reset+0x96>
                                                                      
    case OBJECTS_LOCAL:                                               
      switch ( the_timer->the_class ) {                               
  112e3c:	8b 43 38             	mov    0x38(%ebx),%eax                
  112e3f:	83 f8 01             	cmp    $0x1,%eax                      
  112e42:	74 24                	je     112e68 <rtems_timer_reset+0x54>
  112e44:	72 07                	jb     112e4d <rtems_timer_reset+0x39>
  112e46:	83 f8 04             	cmp    $0x4,%eax                      
  112e49:	77 58                	ja     112ea3 <rtems_timer_reset+0x8f><== NEVER TAKEN
  112e4b:	eb 4a                	jmp    112e97 <rtems_timer_reset+0x83>
        case TIMER_INTERVAL:                                          
          _Watchdog_Remove( &the_timer->Ticker );                     
  112e4d:	83 c3 10             	add    $0x10,%ebx                     
  112e50:	83 ec 0c             	sub    $0xc,%esp                      
  112e53:	53                   	push   %ebx                           
  112e54:	e8 93 3b 00 00       	call   1169ec <_Watchdog_Remove>      
          _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
  112e59:	58                   	pop    %eax                           
  112e5a:	5a                   	pop    %edx                           
  112e5b:	53                   	push   %ebx                           
  112e5c:	68 18 42 13 00       	push   $0x134218                      
  112e61:	e8 6e 3a 00 00       	call   1168d4 <_Watchdog_Insert>      
  112e66:	eb 2a                	jmp    112e92 <rtems_timer_reset+0x7e>
          break;                                                      
        case TIMER_INTERVAL_ON_TASK:                                  
          if ( !_Timer_Server_schedule_operation ) {                  
  112e68:	83 3d b8 4a 13 00 00 	cmpl   $0x0,0x134ab8                  
  112e6f:	75 0c                	jne    112e7d <rtems_timer_reset+0x69><== ALWAYS TAKEN
            _Thread_Enable_dispatch();                                
  112e71:	e8 42 29 00 00       	call   1157b8 <_Thread_Enable_dispatch><== NOT EXECUTED
  112e76:	b8 0e 00 00 00       	mov    $0xe,%eax                      <== NOT EXECUTED
  112e7b:	eb 2d                	jmp    112eaa <rtems_timer_reset+0x96><== NOT EXECUTED
            return RTEMS_INCORRECT_STATE;                             
          }                                                           
          _Watchdog_Remove( &the_timer->Ticker );                     
  112e7d:	83 ec 0c             	sub    $0xc,%esp                      
  112e80:	8d 43 10             	lea    0x10(%ebx),%eax                
  112e83:	50                   	push   %eax                           
  112e84:	e8 63 3b 00 00       	call   1169ec <_Watchdog_Remove>      
          (*_Timer_Server_schedule_operation)( the_timer );           
  112e89:	89 1c 24             	mov    %ebx,(%esp)                    
  112e8c:	ff 15 b8 4a 13 00    	call   *0x134ab8                      
  112e92:	83 c4 10             	add    $0x10,%esp                     
  112e95:	eb 0c                	jmp    112ea3 <rtems_timer_reset+0x8f>
          break;                                                      
        case TIMER_TIME_OF_DAY:                                       
        case TIMER_TIME_OF_DAY_ON_TASK:                               
        case TIMER_DORMANT:                                           
          _Thread_Enable_dispatch();                                  
  112e97:	e8 1c 29 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112e9c:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  112ea1:	eb 07                	jmp    112eaa <rtems_timer_reset+0x96>
          return RTEMS_NOT_DEFINED;                                   
      }                                                               
      _Thread_Enable_dispatch();                                      
  112ea3:	e8 10 29 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112ea8:	31 c0                	xor    %eax,%eax                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  112eaa:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  112ead:	c9                   	leave                                 
  112eae:	c3                   	ret                                   
                                                                      

00112eb0 <rtems_timer_server_fire_after>: Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) {
  112eb0:	55                   	push   %ebp                           
  112eb1:	89 e5                	mov    %esp,%ebp                      
  112eb3:	57                   	push   %edi                           
  112eb4:	56                   	push   %esi                           
  112eb5:	53                   	push   %ebx                           
  112eb6:	83 ec 1c             	sub    $0x1c,%esp                     
  112eb9:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  112ebc:	8b 75 10             	mov    0x10(%ebp),%esi                
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  ISR_Level             level;                                        
                                                                      
  if ( !_Timer_Server )                                               
  112ebf:	b8 0e 00 00 00       	mov    $0xe,%eax                      
  112ec4:	83 3d bc 4a 13 00 00 	cmpl   $0x0,0x134abc                  
  112ecb:	0f 84 91 00 00 00    	je     112f62 <rtems_timer_server_fire_after+0xb2>
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !routine )                                                     
  112ed1:	b8 09 00 00 00       	mov    $0x9,%eax                      
  112ed6:	85 f6                	test   %esi,%esi                      
  112ed8:	0f 84 84 00 00 00    	je     112f62 <rtems_timer_server_fire_after+0xb2><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( ticks == 0 )                                                   
  112ede:	b8 0a 00 00 00       	mov    $0xa,%eax                      
  112ee3:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  112ee7:	74 79                	je     112f62 <rtems_timer_server_fire_after+0xb2>
  112ee9:	50                   	push   %eax                           
  112eea:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  112eed:	50                   	push   %eax                           
  112eee:	57                   	push   %edi                           
  112eef:	68 78 4a 13 00       	push   $0x134a78                      
  112ef4:	e8 ff 20 00 00       	call   114ff8 <_Objects_Get>          
  112ef9:	89 c3                	mov    %eax,%ebx                      
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  112efb:	83 c4 10             	add    $0x10,%esp                     
  112efe:	b8 04 00 00 00       	mov    $0x4,%eax                      
  112f03:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  112f07:	75 59                	jne    112f62 <rtems_timer_server_fire_after+0xb2>
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
  112f09:	83 ec 0c             	sub    $0xc,%esp                      
  112f0c:	8d 43 10             	lea    0x10(%ebx),%eax                
  112f0f:	50                   	push   %eax                           
  112f10:	e8 d7 3a 00 00       	call   1169ec <_Watchdog_Remove>      
                                                                      
      _ISR_Disable( level );                                          
  112f15:	9c                   	pushf                                 
  112f16:	fa                   	cli                                   
  112f17:	5a                   	pop    %edx                           
        /*                                                            
         *  Check to see if the watchdog has just been inserted by a  
         *  higher priority interrupt.  If so, abandon this insert.   
         */                                                           
                                                                      
        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {         
  112f18:	83 c4 10             	add    $0x10,%esp                     
  112f1b:	83 7b 18 00          	cmpl   $0x0,0x18(%ebx)                
  112f1f:	74 0b                	je     112f2c <rtems_timer_server_fire_after+0x7c><== ALWAYS TAKEN
          _ISR_Enable( level );                                       
  112f21:	52                   	push   %edx                           <== NOT EXECUTED
  112f22:	9d                   	popf                                  <== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
  112f23:	e8 90 28 00 00       	call   1157b8 <_Thread_Enable_dispatch><== NOT EXECUTED
  112f28:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
  112f2a:	eb 36                	jmp    112f62 <rtems_timer_server_fire_after+0xb2><== NOT EXECUTED
        /*                                                            
         *  OK.  Now we now the timer was not rescheduled by an interrupt
         *  so we can atomically initialize it as in use.             
         */                                                           
                                                                      
        the_timer->the_class = TIMER_INTERVAL_ON_TASK;                
  112f2c:	c7 43 38 01 00 00 00 	movl   $0x1,0x38(%ebx)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  112f33:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  112f3a:	89 73 2c             	mov    %esi,0x2c(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  112f3d:	89 7b 30             	mov    %edi,0x30(%ebx)                
 *         the heap                                                   
  112f40:	8b 45 14             	mov    0x14(%ebp),%eax                
  112f43:	89 43 34             	mov    %eax,0x34(%ebx)                
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
        the_timer->Ticker.initial = ticks;                            
  112f46:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  112f49:	89 43 1c             	mov    %eax,0x1c(%ebx)                
      _ISR_Enable( level );                                           
  112f4c:	52                   	push   %edx                           
  112f4d:	9d                   	popf                                  
      /*                                                              
       * _Timer_Server_schedule_operation != NULL because we checked that
       * _Timer_Server was != NULL above.  Both are set at the same time.
       */                                                             
                                                                      
      (*_Timer_Server_schedule_operation)( the_timer );               
  112f4e:	83 ec 0c             	sub    $0xc,%esp                      
  112f51:	53                   	push   %ebx                           
  112f52:	ff 15 b8 4a 13 00    	call   *0x134ab8                      
                                                                      
      _Thread_Enable_dispatch();                                      
  112f58:	e8 5b 28 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  112f5d:	31 c0                	xor    %eax,%eax                      
  112f5f:	83 c4 10             	add    $0x10,%esp                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  112f62:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  112f65:	5b                   	pop    %ebx                           
  112f66:	5e                   	pop    %esi                           
  112f67:	5f                   	pop    %edi                           
  112f68:	c9                   	leave                                 
  112f69:	c3                   	ret                                   
                                                                      

00112f6c <rtems_timer_server_fire_when>: Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
  112f6c:	55                   	push   %ebp                           
  112f6d:	89 e5                	mov    %esp,%ebp                      
  112f6f:	57                   	push   %edi                           
  112f70:	56                   	push   %esi                           
  112f71:	53                   	push   %ebx                           
  112f72:	83 ec 1c             	sub    $0x1c,%esp                     
  112f75:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  112f78:	8b 7d 10             	mov    0x10(%ebp),%edi                
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
                                                                      
  if ( !_Timer_Server )                                               
  112f7b:	b8 0e 00 00 00       	mov    $0xe,%eax                      
  112f80:	83 3d bc 4a 13 00 00 	cmpl   $0x0,0x134abc                  
  112f87:	0f 84 b3 00 00 00    	je     113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
  112f8d:	b8 0b 00 00 00       	mov    $0xb,%eax                      
  112f92:	80 3d 4c 41 13 00 00 	cmpb   $0x0,0x13414c                  
  112f99:	0f 84 a1 00 00 00    	je     113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
  112f9f:	b8 09 00 00 00       	mov    $0x9,%eax                      
  112fa4:	85 ff                	test   %edi,%edi                      
  112fa6:	0f 84 94 00 00 00    	je     113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
  112fac:	83 ec 0c             	sub    $0xc,%esp                      
  112faf:	53                   	push   %ebx                           
  112fb0:	e8 bb d7 ff ff       	call   110770 <_TOD_Validate>         
  112fb5:	83 c4 10             	add    $0x10,%esp                     
  112fb8:	84 c0                	test   %al,%al                        
  112fba:	74 7f                	je     11303b <rtems_timer_server_fire_when+0xcf><== NEVER TAKEN
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
  112fbc:	83 ec 0c             	sub    $0xc,%esp                      
  112fbf:	53                   	push   %ebx                           
  112fc0:	e8 43 d7 ff ff       	call   110708 <_TOD_To_seconds>       
  112fc5:	89 c6                	mov    %eax,%esi                      
  if ( seconds <= _TOD_Seconds_since_epoch )                          
  112fc7:	83 c4 10             	add    $0x10,%esp                     
  112fca:	3b 05 c8 41 13 00    	cmp    0x1341c8,%eax                  
  112fd0:	76 69                	jbe    11303b <rtems_timer_server_fire_when+0xcf><== NEVER TAKEN
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
 *  begin at @a starting_address.                                     
 *                                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  112fd2:	50                   	push   %eax                           
  112fd3:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  112fd6:	50                   	push   %eax                           
  112fd7:	ff 75 08             	pushl  0x8(%ebp)                      
  112fda:	68 78 4a 13 00       	push   $0x134a78                      
  112fdf:	e8 14 20 00 00       	call   114ff8 <_Objects_Get>          
  112fe4:	89 c3                	mov    %eax,%ebx                      
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
  112fe6:	83 c4 10             	add    $0x10,%esp                     
  112fe9:	b8 04 00 00 00       	mov    $0x4,%eax                      
  112fee:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  112ff2:	75 4c                	jne    113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
  112ff4:	83 ec 0c             	sub    $0xc,%esp                      
  112ff7:	8d 43 10             	lea    0x10(%ebx),%eax                
  112ffa:	50                   	push   %eax                           
  112ffb:	e8 ec 39 00 00       	call   1169ec <_Watchdog_Remove>      
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
  113000:	c7 43 38 03 00 00 00 	movl   $0x3,0x38(%ebx)                
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  113007:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  11300e:	89 7b 2c             	mov    %edi,0x2c(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  113011:	8b 45 08             	mov    0x8(%ebp),%eax                 
  113014:	89 43 30             	mov    %eax,0x30(%ebx)                
 *         the heap                                                   
  113017:	8b 45 14             	mov    0x14(%ebp),%eax                
  11301a:	89 43 34             	mov    %eax,0x34(%ebx)                
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 
  11301d:	2b 35 c8 41 13 00    	sub    0x1341c8,%esi                  
  113023:	89 73 1c             	mov    %esi,0x1c(%ebx)                
      /*                                                              
       * _Timer_Server_schedule_operation != NULL because we checked that
       * _Timer_Server was != NULL above.  Both are set at the same time.
       */                                                             
                                                                      
      (*_Timer_Server_schedule_operation)( the_timer );               
  113026:	89 1c 24             	mov    %ebx,(%esp)                    
  113029:	ff 15 b8 4a 13 00    	call   *0x134ab8                      
                                                                      
      _Thread_Enable_dispatch();                                      
  11302f:	e8 84 27 00 00       	call   1157b8 <_Thread_Enable_dispatch>
  113034:	31 c0                	xor    %eax,%eax                      
  113036:	83 c4 10             	add    $0x10,%esp                     
  113039:	eb 05                	jmp    113040 <rtems_timer_server_fire_when+0xd4>
      return RTEMS_SUCCESSFUL;                                        
  11303b:	b8 14 00 00 00       	mov    $0x14,%eax                     
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
  113040:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  113043:	5b                   	pop    %ebx                           
  113044:	5e                   	pop    %esi                           
  113045:	5f                   	pop    %edi                           
  113046:	c9                   	leave                                 
  113047:	c3                   	ret                                   
                                                                      

00106ec1 <rtems_verror>: static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) {
  106ec1:	55                   	push   %ebp                           <== NOT EXECUTED
  106ec2:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  106ec4:	57                   	push   %edi                           <== NOT EXECUTED
  106ec5:	56                   	push   %esi                           <== NOT EXECUTED
  106ec6:	53                   	push   %ebx                           <== NOT EXECUTED
  106ec7:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106eca:	89 45 ec             	mov    %eax,-0x14(%ebp)               <== NOT EXECUTED
  106ecd:	89 55 e8             	mov    %edx,-0x18(%ebp)               <== NOT EXECUTED
  106ed0:	89 cb                	mov    %ecx,%ebx                      <== NOT EXECUTED
    int               local_errno = 0;                                
    int               chars_written = 0;                              
    rtems_status_code status;                                         
                                                                      
    if (error_flag & RTEMS_ERROR_PANIC)                               
  106ed2:	25 00 00 00 20       	and    $0x20000000,%eax               <== NOT EXECUTED
  106ed7:	89 45 f0             	mov    %eax,-0x10(%ebp)               <== NOT EXECUTED
  106eda:	74 2a                	je     106f06 <rtems_verror+0x45>     <== NOT EXECUTED
    {                                                                 
        if (rtems_panic_in_progress++)                                
  106edc:	8b 15 30 91 12 00    	mov    0x129130,%edx                  <== NOT EXECUTED
  106ee2:	8d 42 01             	lea    0x1(%edx),%eax                 <== NOT EXECUTED
  106ee5:	a3 30 91 12 00       	mov    %eax,0x129130                  <== NOT EXECUTED
  106eea:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  106eec:	74 0b                	je     106ef9 <rtems_verror+0x38>     <== NOT EXECUTED
  106eee:	a1 94 92 12 00       	mov    0x129294,%eax                  <== NOT EXECUTED
  106ef3:	40                   	inc    %eax                           <== NOT EXECUTED
  106ef4:	a3 94 92 12 00       	mov    %eax,0x129294                  <== NOT EXECUTED
            _Thread_Disable_dispatch();       /* disable task switches */
                                                                      
        /* don't aggravate things */                                  
        if (rtems_panic_in_progress > 2)                              
  106ef9:	83 3d 30 91 12 00 02 	cmpl   $0x2,0x129130                  <== NOT EXECUTED
  106f00:	0f 8f 18 01 00 00    	jg     10701e <rtems_verror+0x15d>    <== NOT EXECUTED
            return 0;                                                 
    }                                                                 
                                                                      
    (void) fflush(stdout);  	    /* in case stdout/stderr same */     
  106f06:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106f09:	a1 c0 f4 11 00       	mov    0x11f4c0,%eax                  <== NOT EXECUTED
  106f0e:	ff 70 08             	pushl  0x8(%eax)                      <== NOT EXECUTED
  106f11:	e8 b6 99 00 00       	call   1108cc <fflush>                <== NOT EXECUTED
                                                                      
    status = error_flag & ~RTEMS_ERROR_MASK;                          
  106f16:	8b 75 ec             	mov    -0x14(%ebp),%esi               <== NOT EXECUTED
  106f19:	81 e6 ff ff ff 8f    	and    $0x8fffffff,%esi               <== NOT EXECUTED
    if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */      
  106f1f:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106f22:	31 ff                	xor    %edi,%edi                      <== NOT EXECUTED
  106f24:	f7 45 ec 00 00 00 40 	testl  $0x40000000,-0x14(%ebp)        <== NOT EXECUTED
  106f2b:	74 07                	je     106f34 <rtems_verror+0x73>     <== NOT EXECUTED
        local_errno = errno;                                          
  106f2d:	e8 ea 96 00 00       	call   11061c <__errno>               <== NOT EXECUTED
  106f32:	8b 38                	mov    (%eax),%edi                    <== NOT EXECUTED
    #if defined(RTEMS_MULTIPROCESSING)                                
      if (_System_state_Is_multiprocessing)                           
        fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
    #endif                                                            
                                                                      
    chars_written += vfprintf(stderr, printf_format, arglist);        
  106f34:	50                   	push   %eax                           <== NOT EXECUTED
  106f35:	53                   	push   %ebx                           <== NOT EXECUTED
  106f36:	ff 75 e8             	pushl  -0x18(%ebp)                    <== NOT EXECUTED
  106f39:	a1 c0 f4 11 00       	mov    0x11f4c0,%eax                  <== NOT EXECUTED
  106f3e:	ff 70 0c             	pushl  0xc(%eax)                      <== NOT EXECUTED
  106f41:	e8 6e e3 00 00       	call   1152b4 <vfprintf>              <== NOT EXECUTED
  106f46:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
                                                                      
    if (status)                                                       
  106f48:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106f4b:	85 f6                	test   %esi,%esi                      <== NOT EXECUTED
  106f4d:	74 28                	je     106f77 <rtems_verror+0xb6>     <== NOT EXECUTED
const char *                                                          
rtems_status_text(                                                    
    rtems_status_code status                                          
)                                                                     
{                                                                     
    return rtems_assoc_name_by_local(rtems_status_assoc, status);     
  106f4f:	50                   	push   %eax                           <== NOT EXECUTED
  106f50:	50                   	push   %eax                           <== NOT EXECUTED
  106f51:	56                   	push   %esi                           <== NOT EXECUTED
  106f52:	68 18 a5 11 00       	push   $0x11a518                      <== NOT EXECUTED
  106f57:	e8 2c 73 00 00       	call   10e288 <rtems_assoc_name_by_local><== NOT EXECUTED
    #endif                                                            
                                                                      
    chars_written += vfprintf(stderr, printf_format, arglist);        
                                                                      
    if (status)                                                       
        chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
  106f5c:	83 c4 0c             	add    $0xc,%esp                      <== NOT EXECUTED
  106f5f:	50                   	push   %eax                           <== NOT EXECUTED
  106f60:	68 09 a2 11 00       	push   $0x11a209                      <== NOT EXECUTED
  106f65:	a1 c0 f4 11 00       	mov    0x11f4c0,%eax                  <== NOT EXECUTED
  106f6a:	ff 70 0c             	pushl  0xc(%eax)                      <== NOT EXECUTED
  106f6d:	e8 0a 9d 00 00       	call   110c7c <fprintf>               <== NOT EXECUTED
  106f72:	01 c3                	add    %eax,%ebx                      <== NOT EXECUTED
  106f74:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
                                                                      
    if (local_errno)                                                  
  106f77:	83 ff 00             	cmp    $0x0,%edi                      <== NOT EXECUTED
  106f7a:	74 40                	je     106fbc <rtems_verror+0xfb>     <== NOT EXECUTED
    {                                                                 
      if ((local_errno > 0) && *strerror(local_errno))                
  106f7c:	7e 25                	jle    106fa3 <rtems_verror+0xe2>     <== NOT EXECUTED
  106f7e:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106f81:	57                   	push   %edi                           <== NOT EXECUTED
  106f82:	e8 d1 a9 00 00       	call   111958 <strerror>              <== NOT EXECUTED
  106f87:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106f8a:	80 38 00             	cmpb   $0x0,(%eax)                    <== NOT EXECUTED
  106f8d:	74 14                	je     106fa3 <rtems_verror+0xe2>     <== NOT EXECUTED
        chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
  106f8f:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106f92:	57                   	push   %edi                           <== NOT EXECUTED
  106f93:	e8 c0 a9 00 00       	call   111958 <strerror>              <== NOT EXECUTED
  106f98:	83 c4 0c             	add    $0xc,%esp                      <== NOT EXECUTED
  106f9b:	50                   	push   %eax                           <== NOT EXECUTED
  106f9c:	68 17 a2 11 00       	push   $0x11a217                      <== NOT EXECUTED
  106fa1:	eb 07                	jmp    106faa <rtems_verror+0xe9>     <== NOT EXECUTED
      else                                                            
        chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
  106fa3:	50                   	push   %eax                           <== NOT EXECUTED
  106fa4:	57                   	push   %edi                           <== NOT EXECUTED
  106fa5:	68 24 a2 11 00       	push   $0x11a224                      <== NOT EXECUTED
  106faa:	a1 c0 f4 11 00       	mov    0x11f4c0,%eax                  <== NOT EXECUTED
  106faf:	ff 70 0c             	pushl  0xc(%eax)                      <== NOT EXECUTED
  106fb2:	e8 c5 9c 00 00       	call   110c7c <fprintf>               <== NOT EXECUTED
  106fb7:	01 c3                	add    %eax,%ebx                      <== NOT EXECUTED
  106fb9:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    }                                                                 
                                                                      
    chars_written += fprintf(stderr, "\n");                           
  106fbc:	56                   	push   %esi                           <== NOT EXECUTED
  106fbd:	56                   	push   %esi                           <== NOT EXECUTED
  106fbe:	68 f5 a9 11 00       	push   $0x11a9f5                      <== NOT EXECUTED
  106fc3:	a1 c0 f4 11 00       	mov    0x11f4c0,%eax                  <== NOT EXECUTED
  106fc8:	ff 70 0c             	pushl  0xc(%eax)                      <== NOT EXECUTED
  106fcb:	e8 ac 9c 00 00       	call   110c7c <fprintf>               <== NOT EXECUTED
  106fd0:	89 c6                	mov    %eax,%esi                      <== NOT EXECUTED
                                                                      
    (void) fflush(stderr);                                            
  106fd2:	59                   	pop    %ecx                           <== NOT EXECUTED
  106fd3:	a1 c0 f4 11 00       	mov    0x11f4c0,%eax                  <== NOT EXECUTED
  106fd8:	ff 70 0c             	pushl  0xc(%eax)                      <== NOT EXECUTED
  106fdb:	e8 ec 98 00 00       	call   1108cc <fflush>                <== NOT EXECUTED
                                                                      
    if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))         
  106fe0:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
        chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
      else                                                            
        chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
    }                                                                 
                                                                      
    chars_written += fprintf(stderr, "\n");                           
  106fe3:	8d 04 1e             	lea    (%esi,%ebx,1),%eax             <== NOT EXECUTED
                                                                      
    (void) fflush(stderr);                                            
                                                                      
    if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))         
  106fe6:	f7 45 ec 00 00 00 30 	testl  $0x30000000,-0x14(%ebp)        <== NOT EXECUTED
  106fed:	74 31                	je     107020 <rtems_verror+0x15f>    <== NOT EXECUTED
    {                                                                 
        if (error_flag & RTEMS_ERROR_PANIC)                           
  106fef:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               <== NOT EXECUTED
  106ff3:	74 16                	je     10700b <rtems_verror+0x14a>    <== NOT EXECUTED
        {                                                             
            rtems_error(0, "fatal error, exiting");                   
  106ff5:	52                   	push   %edx                           <== NOT EXECUTED
  106ff6:	52                   	push   %edx                           <== NOT EXECUTED
  106ff7:	68 38 a2 11 00       	push   $0x11a238                      <== NOT EXECUTED
  106ffc:	6a 00                	push   $0x0                           <== NOT EXECUTED
  106ffe:	e8 3d 00 00 00       	call   107040 <rtems_error>           <== NOT EXECUTED
            _exit(local_errno);                                       
  107003:	89 3c 24             	mov    %edi,(%esp)                    <== NOT EXECUTED
  107006:	e8 fb 05 00 00       	call   107606 <_exit>                 <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
            rtems_error(0, "fatal error, aborting");                  
  10700b:	50                   	push   %eax                           <== NOT EXECUTED
  10700c:	50                   	push   %eax                           <== NOT EXECUTED
  10700d:	68 4d a2 11 00       	push   $0x11a24d                      <== NOT EXECUTED
  107012:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107014:	e8 27 00 00 00       	call   107040 <rtems_error>           <== NOT EXECUTED
            abort();                                                  
  107019:	e8 ca 95 00 00       	call   1105e8 <abort>                 <== NOT EXECUTED
  10701e:	31 c0                	xor    %eax,%eax                      <== NOT EXECUTED
        }                                                             
    }                                                                 
    return chars_written;                                             
}                                                                     
  107020:	8d 65 f4             	lea    -0xc(%ebp),%esp                <== NOT EXECUTED
  107023:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107024:	5e                   	pop    %esi                           <== NOT EXECUTED
  107025:	5f                   	pop    %edi                           <== NOT EXECUTED
  107026:	c9                   	leave                                 <== NOT EXECUTED
  107027:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00109d5d <rtems_workspace_allocate>: */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) {
  109d5d:	55                   	push   %ebp                           
  109d5e:	89 e5                	mov    %esp,%ebp                      
  109d60:	53                   	push   %ebx                           
  109d61:	83 ec 04             	sub    $0x4,%esp                      
  109d64:	8b 45 08             	mov    0x8(%ebp),%eax                 
  109d67:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  void *ptr;                                                          
                                                                      
  /*                                                                  
   * check the arguments                                              
   */                                                                 
  if ( !pointer )                                                     
  109d6a:	85 db                	test   %ebx,%ebx                      
  109d6c:	74 1e                	je     109d8c <rtems_workspace_allocate+0x2f><== NEVER TAKEN
    return false;                                                     
                                                                      
  if ( !bytes )                                                       
  109d6e:	85 c0                	test   %eax,%eax                      
  109d70:	74 1a                	je     109d8c <rtems_workspace_allocate+0x2f><== NEVER TAKEN
    return false;                                                     
                                                                      
  /*                                                                  
   * Allocate the memory                                              
   */                                                                 
  ptr =  _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes );
  109d72:	52                   	push   %edx                           
  109d73:	52                   	push   %edx                           
  109d74:	50                   	push   %eax                           
  109d75:	68 c8 19 12 00       	push   $0x1219c8                      
  109d7a:	e8 c5 13 00 00       	call   10b144 <_Protected_heap_Allocate>
  if (!ptr)                                                           
  109d7f:	83 c4 10             	add    $0x10,%esp                     
  109d82:	85 c0                	test   %eax,%eax                      
  109d84:	74 06                	je     109d8c <rtems_workspace_allocate+0x2f><== NEVER TAKEN
    return false;                                                     
                                                                      
  *pointer = ptr;                                                     
  109d86:	89 03                	mov    %eax,(%ebx)                    
  109d88:	b0 01                	mov    $0x1,%al                       
  109d8a:	eb 02                	jmp    109d8e <rtems_workspace_allocate+0x31>
  return true;                                                        
  109d8c:	31 c0                	xor    %eax,%eax                      
}                                                                     
  109d8e:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109d91:	c9                   	leave                                 
  109d92:	c3                   	ret                                   
                                                                      

00109d48 <rtems_workspace_free>: * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) {
  109d48:	55                   	push   %ebp                           <== NOT EXECUTED
  109d49:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  109d4b:	83 ec 10             	sub    $0x10,%esp                     <== NOT EXECUTED
   return _Protected_heap_Free( &_Workspace_Area, pointer );          
  109d4e:	ff 75 08             	pushl  0x8(%ebp)                      <== NOT EXECUTED
  109d51:	68 c8 19 12 00       	push   $0x1219c8                      <== NOT EXECUTED
  109d56:	e8 1d 14 00 00       	call   10b178 <_Protected_heap_Free>  <== NOT EXECUTED
}                                                                     
  109d5b:	c9                   	leave                                 <== NOT EXECUTED
  109d5c:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

00109d93 <rtems_workspace_get_information>: #include <string.h> /* for memset */ bool rtems_workspace_get_information( Heap_Information_block *the_info ) {
  109d93:	55                   	push   %ebp                           
  109d94:	89 e5                	mov    %esp,%ebp                      
  109d96:	83 ec 08             	sub    $0x8,%esp                      
  109d99:	8b 55 08             	mov    0x8(%ebp),%edx                 
  if ( !the_info )                                                    
  109d9c:	31 c0                	xor    %eax,%eax                      
  109d9e:	85 d2                	test   %edx,%edx                      
  109da0:	74 10                	je     109db2 <rtems_workspace_get_information+0x1f><== NEVER TAKEN
    return false;                                                     
                                                                      
  return _Protected_heap_Get_information( &_Workspace_Area, the_info );
  109da2:	51                   	push   %ecx                           
  109da3:	51                   	push   %ecx                           
  109da4:	52                   	push   %edx                           
  109da5:	68 c8 19 12 00       	push   $0x1219c8                      
  109daa:	e8 fd 13 00 00       	call   10b1ac <_Protected_heap_Get_information>
  109daf:	83 c4 10             	add    $0x10,%esp                     
}                                                                     
  109db2:	c9                   	leave                                 
  109db3:	c3                   	ret                                   
                                                                      

00108e43 <scandir>: scandir( const char *dirname, struct dirent ***namelist, int (*select)(struct dirent *), int (*dcomp)(const struct dirent **, const struct dirent **)) {
  108e43:	55                   	push   %ebp                           
  108e44:	89 e5                	mov    %esp,%ebp                      
  108e46:	57                   	push   %edi                           
  108e47:	56                   	push   %esi                           
  108e48:	53                   	push   %ebx                           
  108e49:	83 ec 78             	sub    $0x78,%esp                     
	struct stat stb;                                                     
	long arraysz;                                                        
	DIR *dirp = NULL;                                                    
        int i;                                                        
                                                                      
	if ((dirp = opendir(dirname)) == NULL)                               
  108e4c:	ff 75 08             	pushl  0x8(%ebp)                      
  108e4f:	e8 f0 f8 ff ff       	call   108744 <opendir>               
  108e54:	89 45 a0             	mov    %eax,-0x60(%ebp)               
  108e57:	83 c4 10             	add    $0x10,%esp                     
  108e5a:	85 c0                	test   %eax,%eax                      
  108e5c:	0f 84 99 01 00 00    	je     108ffb <scandir+0x1b8>         <== NEVER TAKEN
		return(-1);                                                         
	if (fstat(dirp->dd_fd, &stb) < 0)                                    
  108e62:	51                   	push   %ecx                           
  108e63:	51                   	push   %ecx                           
  108e64:	8d 5d a8             	lea    -0x58(%ebp),%ebx               
  108e67:	53                   	push   %ebx                           
  108e68:	ff 30                	pushl  (%eax)                         
  108e6a:	e8 15 60 00 00       	call   10ee84 <fstat>                 
  108e6f:	83 c4 10             	add    $0x10,%esp                     
  108e72:	85 c0                	test   %eax,%eax                      
  108e74:	0f 88 3d 01 00 00    	js     108fb7 <scandir+0x174>         <== NEVER TAKEN
                                                                      
	/*                                                                   
	 * estimate the array size by taking the size of the directory file  
	 * and dividing it by a multiple of the minimum size entry.          
	 */                                                                  
	arraysz = (stb.st_size / 24);                                        
  108e7a:	8b 45 c8             	mov    -0x38(%ebp),%eax               
  108e7d:	b9 18 00 00 00       	mov    $0x18,%ecx                     
  108e82:	99                   	cltd                                  
  108e83:	f7 f9                	idiv   %ecx                           
  108e85:	89 45 9c             	mov    %eax,-0x64(%ebp)               
	names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 
  108e88:	83 ec 0c             	sub    $0xc,%esp                      
  108e8b:	c1 e0 02             	shl    $0x2,%eax                      
  108e8e:	50                   	push   %eax                           
  108e8f:	e8 f8 f0 ff ff       	call   107f8c <malloc>                
  108e94:	89 c6                	mov    %eax,%esi                      
	if (names == NULL)                                                   
  108e96:	83 c4 10             	add    $0x10,%esp                     
  108e99:	c7 45 98 00 00 00 00 	movl   $0x0,-0x68(%ebp)               
  108ea0:	85 c0                	test   %eax,%eax                      
  108ea2:	0f 85 c2 00 00 00    	jne    108f6a <scandir+0x127>         
  108ea8:	89 45 98             	mov    %eax,-0x68(%ebp)               
  108eab:	e9 10 01 00 00       	jmp    108fc0 <scandir+0x17d>         
		goto  cleanup_and_bail;                                             
                                                                      
	while ((d = readdir(dirp)) != NULL) {                                
		if (select != NULL && !(*select)(d))                                
  108eb0:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  108eb4:	74 12                	je     108ec8 <scandir+0x85>          <== NEVER TAKEN
  108eb6:	83 ec 0c             	sub    $0xc,%esp                      
  108eb9:	53                   	push   %ebx                           
  108eba:	ff 55 10             	call   *0x10(%ebp)                    
  108ebd:	83 c4 10             	add    $0x10,%esp                     
  108ec0:	85 c0                	test   %eax,%eax                      
  108ec2:	0f 84 a2 00 00 00    	je     108f6a <scandir+0x127>         
			continue;	/* just selected names */                                
		/*                                                                  
		 * Make a minimum size copy of the data                             
		 */                                                                 
		p = (struct dirent *)malloc(DIRSIZ(d));                             
  108ec8:	83 ec 0c             	sub    $0xc,%esp                      
  108ecb:	0f b7 43 0a          	movzwl 0xa(%ebx),%eax                 
  108ecf:	83 c0 04             	add    $0x4,%eax                      
  108ed2:	83 e0 fc             	and    $0xfffffffc,%eax               
  108ed5:	83 c0 0c             	add    $0xc,%eax                      
  108ed8:	50                   	push   %eax                           
  108ed9:	e8 ae f0 ff ff       	call   107f8c <malloc>                
  108ede:	89 c7                	mov    %eax,%edi                      
		if (p == NULL)                                                      
  108ee0:	83 c4 10             	add    $0x10,%esp                     
  108ee3:	85 c0                	test   %eax,%eax                      
  108ee5:	0f 84 d5 00 00 00    	je     108fc0 <scandir+0x17d>         <== NEVER TAKEN
		      goto  cleanup_and_bail;                                       
		p->d_ino = d->d_ino;                                                
  108eeb:	8b 03                	mov    (%ebx),%eax                    
  108eed:	89 07                	mov    %eax,(%edi)                    
		p->d_reclen = d->d_reclen;                                          
  108eef:	8b 43 08             	mov    0x8(%ebx),%eax                 
  108ef2:	66 89 47 08          	mov    %ax,0x8(%edi)                  
		p->d_namlen = d->d_namlen;                                          
  108ef6:	0f b7 43 0a          	movzwl 0xa(%ebx),%eax                 
  108efa:	66 89 47 0a          	mov    %ax,0xa(%edi)                  
		strncpy(p->d_name, d->d_name, p->d_namlen + 1);                     
  108efe:	52                   	push   %edx                           
  108eff:	40                   	inc    %eax                           
  108f00:	50                   	push   %eax                           
  108f01:	8d 43 0c             	lea    0xc(%ebx),%eax                 
  108f04:	50                   	push   %eax                           
  108f05:	8d 47 0c             	lea    0xc(%edi),%eax                 
  108f08:	50                   	push   %eax                           
  108f09:	e8 6e a9 00 00       	call   11387c <strncpy>               
		/*                                                                  
		 * Check to make sure the array has space left and                  
		 * realloc the maximum size.                                        
		 */                                                                 
		if (++nitems >= arraysz) {                                          
  108f0e:	ff 45 98             	incl   -0x68(%ebp)                    
  108f11:	83 c4 10             	add    $0x10,%esp                     
  108f14:	8b 45 9c             	mov    -0x64(%ebp),%eax               
  108f17:	39 45 98             	cmp    %eax,-0x68(%ebp)               
  108f1a:	72 40                	jb     108f5c <scandir+0x119>         <== ALWAYS TAKEN
			if (fstat(dirp->dd_fd, &stb) < 0)                                  
  108f1c:	51                   	push   %ecx                           <== NOT EXECUTED
  108f1d:	51                   	push   %ecx                           <== NOT EXECUTED
  108f1e:	8d 55 a8             	lea    -0x58(%ebp),%edx               <== NOT EXECUTED
  108f21:	52                   	push   %edx                           <== NOT EXECUTED
  108f22:	8b 45 a0             	mov    -0x60(%ebp),%eax               <== NOT EXECUTED
  108f25:	ff 30                	pushl  (%eax)                         <== NOT EXECUTED
  108f27:	e8 58 5f 00 00       	call   10ee84 <fstat>                 <== NOT EXECUTED
  108f2c:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108f2f:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108f31:	0f 88 89 00 00 00    	js     108fc0 <scandir+0x17d>         <== NOT EXECUTED
				goto  cleanup_and_bail;	/* just might have grown */               
			arraysz = stb.st_size / 12;                                        
  108f37:	8b 4d c8             	mov    -0x38(%ebp),%ecx               <== NOT EXECUTED
  108f3a:	bb 0c 00 00 00       	mov    $0xc,%ebx                      <== NOT EXECUTED
  108f3f:	89 c8                	mov    %ecx,%eax                      <== NOT EXECUTED
  108f41:	99                   	cltd                                  <== NOT EXECUTED
  108f42:	f7 fb                	idiv   %ebx                           <== NOT EXECUTED
  108f44:	89 45 9c             	mov    %eax,-0x64(%ebp)               <== NOT EXECUTED
			names = (struct dirent **)realloc((char *)names,                   
  108f47:	52                   	push   %edx                           <== NOT EXECUTED
  108f48:	52                   	push   %edx                           <== NOT EXECUTED
  108f49:	c1 e0 02             	shl    $0x2,%eax                      <== NOT EXECUTED
  108f4c:	50                   	push   %eax                           <== NOT EXECUTED
  108f4d:	56                   	push   %esi                           <== NOT EXECUTED
  108f4e:	e8 1d 61 00 00       	call   10f070 <realloc>               <== NOT EXECUTED
  108f53:	89 c6                	mov    %eax,%esi                      <== NOT EXECUTED
				arraysz * sizeof(struct dirent *));                               
			if (names == NULL)                                                 
  108f55:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108f58:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108f5a:	74 64                	je     108fc0 <scandir+0x17d>         <== NOT EXECUTED
		      goto  cleanup_and_bail;                                       
		}                                                                   
		names[nitems-1] = p;                                                
  108f5c:	b8 01 00 00 00       	mov    $0x1,%eax                      
  108f61:	2b 45 98             	sub    -0x68(%ebp),%eax               
  108f64:	6b c0 fc             	imul   $0xfffffffc,%eax,%eax          
  108f67:	89 3c 30             	mov    %edi,(%eax,%esi,1)             
	arraysz = (stb.st_size / 24);                                        
	names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 
	if (names == NULL)                                                   
		goto  cleanup_and_bail;                                             
                                                                      
	while ((d = readdir(dirp)) != NULL) {                                
  108f6a:	83 ec 0c             	sub    $0xc,%esp                      
  108f6d:	ff 75 a0             	pushl  -0x60(%ebp)                    
  108f70:	e8 1f fd ff ff       	call   108c94 <readdir>               
  108f75:	89 c3                	mov    %eax,%ebx                      
  108f77:	83 c4 10             	add    $0x10,%esp                     
  108f7a:	85 c0                	test   %eax,%eax                      
  108f7c:	0f 85 2e ff ff ff    	jne    108eb0 <scandir+0x6d>          
			if (names == NULL)                                                 
		      goto  cleanup_and_bail;                                       
		}                                                                   
		names[nitems-1] = p;                                                
	}                                                                    
	closedir(dirp);                                                      
  108f82:	83 ec 0c             	sub    $0xc,%esp                      
  108f85:	ff 75 a0             	pushl  -0x60(%ebp)                    
  108f88:	e8 f7 e6 ff ff       	call   107684 <closedir>              
	if (nitems && dcomp != NULL){                                        
  108f8d:	83 c4 10             	add    $0x10,%esp                     
  108f90:	83 7d 98 00          	cmpl   $0x0,-0x68(%ebp)               
  108f94:	74 17                	je     108fad <scandir+0x16a>         <== NEVER TAKEN
  108f96:	83 7d 14 00          	cmpl   $0x0,0x14(%ebp)                
  108f9a:	74 11                	je     108fad <scandir+0x16a>         
		qsort(names, nitems, sizeof(struct dirent *),                       
  108f9c:	ff 75 14             	pushl  0x14(%ebp)                     
  108f9f:	6a 04                	push   $0x4                           
  108fa1:	ff 75 98             	pushl  -0x68(%ebp)                    
  108fa4:	56                   	push   %esi                           
  108fa5:	e8 46 9d 00 00       	call   112cf0 <qsort>                 
  108faa:	83 c4 10             	add    $0x10,%esp                     
		(int (*)(const void *, const void *)) dcomp);                       
        }                                                             
	*namelist = names;                                                   
  108fad:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  108fb0:	89 30                	mov    %esi,(%eax)                    
	return(nitems);                                                      
  108fb2:	8b 45 98             	mov    -0x68(%ebp),%eax               
  108fb5:	eb 47                	jmp    108ffe <scandir+0x1bb>         
  108fb7:	31 f6                	xor    %esi,%esi                      
  108fb9:	c7 45 98 00 00 00 00 	movl   $0x0,-0x68(%ebp)               <== NOT EXECUTED
                                                                      
cleanup_and_bail:                                                     
                                                                      
	if ( dirp )                                                          
		closedir( dirp );                                                   
  108fc0:	83 ec 0c             	sub    $0xc,%esp                      
  108fc3:	ff 75 a0             	pushl  -0x60(%ebp)                    
  108fc6:	e8 b9 e6 ff ff       	call   107684 <closedir>              
                                                                      
	if ( names ) {                                                       
  108fcb:	83 c4 10             	add    $0x10,%esp                     
  108fce:	31 db                	xor    %ebx,%ebx                      
  108fd0:	85 f6                	test   %esi,%esi                      
  108fd2:	74 27                	je     108ffb <scandir+0x1b8>         <== ALWAYS TAKEN
  108fd4:	eb 0f                	jmp    108fe5 <scandir+0x1a2>         <== NOT EXECUTED
		for (i=0; i < nitems; i++ )                                         
			free( names[i] );                                                  
  108fd6:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108fd9:	ff 34 9e             	pushl  (%esi,%ebx,4)                  <== NOT EXECUTED
  108fdc:	e8 77 ea ff ff       	call   107a58 <free>                  <== NOT EXECUTED
                                                                      
	if ( dirp )                                                          
		closedir( dirp );                                                   
                                                                      
	if ( names ) {                                                       
		for (i=0; i < nitems; i++ )                                         
  108fe1:	43                   	inc    %ebx                           <== NOT EXECUTED
  108fe2:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108fe5:	3b 5d 98             	cmp    -0x68(%ebp),%ebx               <== NOT EXECUTED
  108fe8:	72 ec                	jb     108fd6 <scandir+0x193>         <== NOT EXECUTED
			free( names[i] );                                                  
		free( names );                                                      
  108fea:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108fed:	56                   	push   %esi                           <== NOT EXECUTED
  108fee:	e8 65 ea ff ff       	call   107a58 <free>                  <== NOT EXECUTED
  108ff3:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  108ff6:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  108ff9:	eb 03                	jmp    108ffe <scandir+0x1bb>         <== NOT EXECUTED
  108ffb:	83 c8 ff             	or     $0xffffffff,%eax               
	}                                                                    
                                                                      
	return(-1);                                                          
}                                                                     
  108ffe:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109001:	5b                   	pop    %ebx                           
  109002:	5e                   	pop    %esi                           
  109003:	5f                   	pop    %edi                           
  109004:	c9                   	leave                                 
  109005:	c3                   	ret                                   
                                                                      

0010a178 <sched_rr_get_interval>: int sched_rr_get_interval( pid_t pid, struct timespec *interval ) {
  10a178:	55                   	push   %ebp                           
  10a179:	89 e5                	mov    %esp,%ebp                      
  10a17b:	56                   	push   %esi                           
  10a17c:	53                   	push   %ebx                           
  10a17d:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  10a180:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid && pid != getpid() )                                       
  10a183:	85 db                	test   %ebx,%ebx                      
  10a185:	74 16                	je     10a19d <sched_rr_get_interval+0x25><== NEVER TAKEN
  10a187:	e8 54 d1 ff ff       	call   1072e0 <getpid>                
  10a18c:	39 c3                	cmp    %eax,%ebx                      
  10a18e:	74 0d                	je     10a19d <sched_rr_get_interval+0x25>
    rtems_set_errno_and_return_minus_one( ESRCH );                    
  10a190:	e8 6b 66 00 00       	call   110800 <__errno>               
  10a195:	c7 00 03 00 00 00    	movl   $0x3,(%eax)                    
  10a19b:	eb 0f                	jmp    10a1ac <sched_rr_get_interval+0x34>
                                                                      
  if ( !interval )                                                    
  10a19d:	85 f6                	test   %esi,%esi                      
  10a19f:	75 10                	jne    10a1b1 <sched_rr_get_interval+0x39>
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10a1a1:	e8 5a 66 00 00       	call   110800 <__errno>               
  10a1a6:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10a1ac:	83 c8 ff             	or     $0xffffffff,%eax               
  10a1af:	eb 13                	jmp    10a1c4 <sched_rr_get_interval+0x4c>
                                                                      
  _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );      
  10a1b1:	50                   	push   %eax                           
  10a1b2:	50                   	push   %eax                           
  10a1b3:	56                   	push   %esi                           
  10a1b4:	ff 35 bc 10 12 00    	pushl  0x1210bc                       
  10a1ba:	e8 45 32 00 00       	call   10d404 <_Timespec_From_ticks>  
  10a1bf:	31 c0                	xor    %eax,%eax                      
  10a1c1:	83 c4 10             	add    $0x10,%esp                     
  return 0;                                                           
}                                                                     
  10a1c4:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a1c7:	5b                   	pop    %ebx                           
  10a1c8:	5e                   	pop    %esi                           
  10a1c9:	c9                   	leave                                 
  10a1ca:	c3                   	ret                                   
                                                                      

00109008 <seekdir>: void seekdir( DIR *dirp, long loc ) {
  109008:	55                   	push   %ebp                           
  109009:	89 e5                	mov    %esp,%ebp                      
  10900b:	53                   	push   %ebx                           
  10900c:	83 ec 04             	sub    $0x4,%esp                      
  10900f:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  off_t status;                                                       
                                                                      
  if ( !dirp )                                                        
  109012:	85 db                	test   %ebx,%ebx                      
  109014:	74 1a                	je     109030 <seekdir+0x28>          
    return;                                                           
                                                                      
  status = lseek( dirp->dd_fd, loc, SEEK_SET );                       
  109016:	50                   	push   %eax                           
  109017:	6a 00                	push   $0x0                           
  109019:	ff 75 0c             	pushl  0xc(%ebp)                      
  10901c:	ff 33                	pushl  (%ebx)                         
  10901e:	e8 b9 ed ff ff       	call   107ddc <lseek>                 
                                                                      
  /*                                                                  
   * This is not a nice way to error out, but we have no choice here. 
   */                                                                 
                                                                      
  if ( status == -1 )                                                 
  109023:	83 c4 10             	add    $0x10,%esp                     
  109026:	40                   	inc    %eax                           
  109027:	74 07                	je     109030 <seekdir+0x28>          <== NEVER TAKEN
    return;                                                           
                                                                      
  dirp->dd_loc = 0;                                                   
  109029:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)                 
}                                                                     
  109030:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  109033:	c9                   	leave                                 
  109034:	c3                   	ret                                   
                                                                      

0010b5c4 <sem_destroy>: */ int sem_destroy( sem_t *sem ) {
  10b5c4:	55                   	push   %ebp                           
  10b5c5:	89 e5                	mov    %esp,%ebp                      
  10b5c7:	83 ec 1c             	sub    $0x1c,%esp                     
  10b5ca:	8d 45 fc             	lea    -0x4(%ebp),%eax                
  10b5cd:	50                   	push   %eax                           
  10b5ce:	8b 45 08             	mov    0x8(%ebp),%eax                 
  10b5d1:	ff 30                	pushl  (%eax)                         
  10b5d3:	68 00 38 12 00       	push   $0x123800                      
  10b5d8:	e8 4b 1f 00 00       	call   10d528 <_Objects_Get>          
  register POSIX_Semaphore_Control *the_semaphore;                    
  Objects_Locations                 location;                         
                                                                      
  the_semaphore = _POSIX_Semaphore_Get( sem, &location );             
  switch ( location ) {                                               
  10b5dd:	83 c4 10             	add    $0x10,%esp                     
  10b5e0:	83 7d fc 00          	cmpl   $0x0,-0x4(%ebp)                
  10b5e4:	75 22                	jne    10b608 <sem_destroy+0x44>      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Undefined operation on a named semaphore.                   
       */                                                             
                                                                      
      if ( the_semaphore->named == TRUE ) {                           
  10b5e6:	80 78 14 00          	cmpb   $0x0,0x14(%eax)                
  10b5ea:	74 07                	je     10b5f3 <sem_destroy+0x2f>      <== ALWAYS TAKEN
        _Thread_Enable_dispatch();                                    
  10b5ec:	e8 f7 26 00 00       	call   10dce8 <_Thread_Enable_dispatch><== NOT EXECUTED
  10b5f1:	eb 15                	jmp    10b608 <sem_destroy+0x44>      <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EINVAL );               
      }                                                               
                                                                      
      _POSIX_Semaphore_Delete( the_semaphore );                       
  10b5f3:	83 ec 0c             	sub    $0xc,%esp                      
  10b5f6:	50                   	push   %eax                           
  10b5f7:	e8 dc 55 00 00       	call   110bd8 <_POSIX_Semaphore_Delete>
      _Thread_Enable_dispatch();                                      
  10b5fc:	e8 e7 26 00 00       	call   10dce8 <_Thread_Enable_dispatch>
  10b601:	31 c0                	xor    %eax,%eax                      
  10b603:	83 c4 10             	add    $0x10,%esp                     
  10b606:	eb 0e                	jmp    10b616 <sem_destroy+0x52>      
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
  10b608:	e8 57 70 00 00       	call   112664 <__errno>               
  10b60d:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10b613:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  10b616:	c9                   	leave                                 
  10b617:	c3                   	ret                                   
                                                                      

0010b65c <sem_init>: int sem_init( sem_t *sem, int pshared, unsigned int value ) {
  10b65c:	55                   	push   %ebp                           
  10b65d:	89 e5                	mov    %esp,%ebp                      
  10b65f:	53                   	push   %ebx                           
  10b660:	83 ec 14             	sub    $0x14,%esp                     
  10b663:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  int                        status;                                  
  POSIX_Semaphore_Control   *the_semaphore;                           
                                                                      
  if ( !sem )                                                         
  10b666:	85 db                	test   %ebx,%ebx                      
  10b668:	75 10                	jne    10b67a <sem_init+0x1e>         <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  10b66a:	e8 f5 6f 00 00       	call   112664 <__errno>               <== NOT EXECUTED
  10b66f:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  10b675:	83 ca ff             	or     $0xffffffff,%edx               <== NOT EXECUTED
  10b678:	eb 23                	jmp    10b69d <sem_init+0x41>         <== NOT EXECUTED
                                                                      
  status = _POSIX_Semaphore_Create_support(                           
  10b67a:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  10b67d:	50                   	push   %eax                           
  10b67e:	ff 75 10             	pushl  0x10(%ebp)                     
  10b681:	ff 75 0c             	pushl  0xc(%ebp)                      
  10b684:	6a 00                	push   $0x0                           
  10b686:	e8 55 54 00 00       	call   110ae0 <_POSIX_Semaphore_Create_support>
  10b68b:	89 c2                	mov    %eax,%edx                      
    pshared,                                                          
    value,                                                            
    &the_semaphore                                                    
  );                                                                  
                                                                      
  if ( status != -1 )                                                 
  10b68d:	83 c4 10             	add    $0x10,%esp                     
  10b690:	83 f8 ff             	cmp    $0xffffffff,%eax               
  10b693:	74 08                	je     10b69d <sem_init+0x41>         
    *sem = the_semaphore->Object.id;                                  
  10b695:	8b 45 f8             	mov    -0x8(%ebp),%eax                
  10b698:	8b 40 08             	mov    0x8(%eax),%eax                 
  10b69b:	89 03                	mov    %eax,(%ebx)                    
                                                                      
  return status;                                                      
}                                                                     
  10b69d:	89 d0                	mov    %edx,%eax                      
  10b69f:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b6a2:	c9                   	leave                                 
  10b6a3:	c3                   	ret                                   
                                                                      

0010b6a4 <sem_open>: int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) {
  10b6a4:	55                   	push   %ebp                           
  10b6a5:	89 e5                	mov    %esp,%ebp                      
  10b6a7:	57                   	push   %edi                           
  10b6a8:	56                   	push   %esi                           
  10b6a9:	53                   	push   %ebx                           
  10b6aa:	83 ec 1c             	sub    $0x1c,%esp                     
  10b6ad:	8b 75 0c             	mov    0xc(%ebp),%esi                 
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10b6b0:	a1 10 35 12 00       	mov    0x123510,%eax                  
  10b6b5:	40                   	inc    %eax                           
  10b6b6:	a3 10 35 12 00       	mov    %eax,0x123510                  
  POSIX_Semaphore_Control   *the_semaphore;                           
  Objects_Locations          location;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
  10b6bb:	89 f0                	mov    %esi,%eax                      
  10b6bd:	25 00 02 00 00       	and    $0x200,%eax                    
  10b6c2:	89 45 e0             	mov    %eax,-0x20(%ebp)               
  10b6c5:	75 04                	jne    10b6cb <sem_open+0x27>         
  10b6c7:	31 ff                	xor    %edi,%edi                      
  10b6c9:	eb 03                	jmp    10b6ce <sem_open+0x2a>         
    va_start(arg, oflag);                                             
    mode = (mode_t) va_arg( arg, unsigned int );                      
    value = va_arg( arg, unsigned int );                              
  10b6cb:	8b 7d 14             	mov    0x14(%ebp),%edi                
    va_end(arg);                                                      
  }                                                                   
                                                                      
  status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );    
  10b6ce:	52                   	push   %edx                           
  10b6cf:	52                   	push   %edx                           
  10b6d0:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10b6d3:	50                   	push   %eax                           
  10b6d4:	ff 75 08             	pushl  0x8(%ebp)                      
  10b6d7:	e8 44 55 00 00       	call   110c20 <_POSIX_Semaphore_Name_to_id>
  10b6dc:	89 c3                	mov    %eax,%ebx                      
   *  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 ) {                                                     
  10b6de:	83 c4 10             	add    $0x10,%esp                     
  10b6e1:	85 c0                	test   %eax,%eax                      
  10b6e3:	74 19                	je     10b6fe <sem_open+0x5a>         
    /*                                                                
     * 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) ) ) {               
  10b6e5:	83 f8 02             	cmp    $0x2,%eax                      
  10b6e8:	75 06                	jne    10b6f0 <sem_open+0x4c>         <== NEVER TAKEN
  10b6ea:	83 7d e0 00          	cmpl   $0x0,-0x20(%ebp)               
  10b6ee:	75 5e                	jne    10b74e <sem_open+0xaa>         
      _Thread_Enable_dispatch();                                      
  10b6f0:	e8 f3 25 00 00       	call   10dce8 <_Thread_Enable_dispatch>
      rtems_set_errno_and_return_minus_one_cast( status, sem_t * );   
  10b6f5:	e8 6a 6f 00 00       	call   112664 <__errno>               
  10b6fa:	89 18                	mov    %ebx,(%eax)                    
  10b6fc:	eb 1e                	jmp    10b71c <sem_open+0x78>         
                                                                      
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
                                                                      
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
  10b6fe:	81 e6 00 0a 00 00    	and    $0xa00,%esi                    
  10b704:	81 fe 00 0a 00 00    	cmp    $0xa00,%esi                    
  10b70a:	75 15                	jne    10b721 <sem_open+0x7d>         
      _Thread_Enable_dispatch();                                      
  10b70c:	e8 d7 25 00 00       	call   10dce8 <_Thread_Enable_dispatch>
      rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );   
  10b711:	e8 4e 6f 00 00       	call   112664 <__errno>               
  10b716:	c7 00 11 00 00 00    	movl   $0x11,(%eax)                   
  10b71c:	83 c8 ff             	or     $0xffffffff,%eax               
  10b71f:	eb 52                	jmp    10b773 <sem_open+0xcf>         
 *         to add to the heap                                         
 *  @param[in] size is the size in bytes of the memory area to add    
 *  @return a status indicating success or the reason for failure     
 */                                                                   
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  10b721:	50                   	push   %eax                           
  10b722:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  10b725:	50                   	push   %eax                           
  10b726:	ff 75 f0             	pushl  -0x10(%ebp)                    
  10b729:	68 00 38 12 00       	push   $0x123800                      
  10b72e:	e8 f5 1d 00 00       	call   10d528 <_Objects_Get>          
    }                                                                 
                                                                      
    the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
  10b733:	89 45 ec             	mov    %eax,-0x14(%ebp)               
    the_semaphore->open_count += 1;                                   
  10b736:	ff 40 18             	incl   0x18(%eax)                     
    _Thread_Enable_dispatch();                                        
  10b739:	e8 aa 25 00 00       	call   10dce8 <_Thread_Enable_dispatch>
    _Thread_Enable_dispatch();                                        
  10b73e:	e8 a5 25 00 00       	call   10dce8 <_Thread_Enable_dispatch>
    id = &the_semaphore->Object.id;                                   
    return (sem_t *)id;                                               
  10b743:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10b746:	83 c0 08             	add    $0x8,%eax                      
  10b749:	83 c4 10             	add    $0x10,%esp                     
  10b74c:	eb 25                	jmp    10b773 <sem_open+0xcf>         
  /*                                                                  
   *  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(                            
  10b74e:	8d 45 ec             	lea    -0x14(%ebp),%eax               
  10b751:	50                   	push   %eax                           
  10b752:	57                   	push   %edi                           
  10b753:	6a 00                	push   $0x0                           
  10b755:	ff 75 08             	pushl  0x8(%ebp)                      
  10b758:	e8 83 53 00 00       	call   110ae0 <_POSIX_Semaphore_Create_support>
  10b75d:	89 c3                	mov    %eax,%ebx                      
                                                                      
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
                                                                      
  _Thread_Enable_dispatch();                                          
  10b75f:	e8 84 25 00 00       	call   10dce8 <_Thread_Enable_dispatch>
                                                                      
  if ( status == -1 )                                                 
  10b764:	83 c4 10             	add    $0x10,%esp                     
  10b767:	83 c8 ff             	or     $0xffffffff,%eax               
  10b76a:	43                   	inc    %ebx                           
  10b76b:	74 06                	je     10b773 <sem_open+0xcf>         <== NEVER TAKEN
    return SEM_FAILED;                                                
                                                                      
  id = &the_semaphore->Object.id;                                     
  return (sem_t *)id;                                                 
  10b76d:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  10b770:	83 c0 08             	add    $0x8,%eax                      
}                                                                     
  10b773:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10b776:	5b                   	pop    %ebx                           
  10b777:	5e                   	pop    %esi                           
  10b778:	5f                   	pop    %edi                           
  10b779:	c9                   	leave                                 
  10b77a:	c3                   	ret                                   
                                                                      

0010b80c <sem_unlink>: */ int sem_unlink( const char *name ) {
  10b80c:	55                   	push   %ebp                           
  10b80d:	89 e5                	mov    %esp,%ebp                      
  10b80f:	53                   	push   %ebx                           
  10b810:	83 ec 1c             	sub    $0x1c,%esp                     
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10b813:	a1 10 35 12 00       	mov    0x123510,%eax                  
  10b818:	40                   	inc    %eax                           
  10b819:	a3 10 35 12 00       	mov    %eax,0x123510                  
  register POSIX_Semaphore_Control *the_semaphore;                    
  sem_t                        the_semaphore_id;                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );    
  10b81e:	8d 45 f8             	lea    -0x8(%ebp),%eax                
  10b821:	50                   	push   %eax                           
  10b822:	ff 75 08             	pushl  0x8(%ebp)                      
  10b825:	e8 f6 53 00 00       	call   110c20 <_POSIX_Semaphore_Name_to_id>
  10b82a:	89 c3                	mov    %eax,%ebx                      
  if ( status != 0 ) {                                                
  10b82c:	83 c4 10             	add    $0x10,%esp                     
  10b82f:	85 c0                	test   %eax,%eax                      
  10b831:	74 11                	je     10b844 <sem_unlink+0x38>       
    _Thread_Enable_dispatch();                                        
  10b833:	e8 b0 24 00 00       	call   10dce8 <_Thread_Enable_dispatch>
    rtems_set_errno_and_return_minus_one( status );                   
  10b838:	e8 27 6e 00 00       	call   112664 <__errno>               
  10b83d:	89 18                	mov    %ebx,(%eax)                    
  10b83f:	83 c8 ff             	or     $0xffffffff,%eax               
  10b842:	eb 3c                	jmp    10b880 <sem_unlink+0x74>       
  }                                                                   
                                                                      
  the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object(
  10b844:	8b 45 f8             	mov    -0x8(%ebp),%eax                
bool _Protected_heap_Get_information(                                 
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
);                                                                    
                                                                      
/**                                                                   
  10b847:	31 db                	xor    %ebx,%ebx                      
  10b849:	66 3b 05 10 38 12 00 	cmp    0x123810,%ax                   
  10b850:	77 0b                	ja     10b85d <sem_unlink+0x51>       <== NEVER TAKEN
 *  This heap routine returns information about the free blocks       
 *  in the specified heap.                                            
  10b852:	0f b7 d0             	movzwl %ax,%edx                       
  10b855:	a1 1c 38 12 00       	mov    0x12381c,%eax                  
  10b85a:	8b 1c 90             	mov    (%eax,%edx,4),%ebx             
    &_POSIX_Semaphore_Information,                                    
    _Objects_Get_index( the_semaphore_id )                            
  );                                                                  
                                                                      
  the_semaphore->linked = FALSE;                                      
  10b85d:	c6 43 15 00          	movb   $0x0,0x15(%ebx)                
static inline uint32_t _Protected_heap_Initialize(                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  size_t        size,                                                 
  uint32_t      page_size                                             
)                                                                     
  10b861:	50                   	push   %eax                           
  10b862:	50                   	push   %eax                           
  10b863:	53                   	push   %ebx                           
  10b864:	68 00 38 12 00       	push   $0x123800                      
  10b869:	e8 ce 1d 00 00       	call   10d63c <_Objects_Namespace_remove>
  _POSIX_Semaphore_Namespace_remove( the_semaphore );                 
  _POSIX_Semaphore_Delete( the_semaphore );                           
  10b86e:	89 1c 24             	mov    %ebx,(%esp)                    
  10b871:	e8 62 53 00 00       	call   110bd8 <_POSIX_Semaphore_Delete>
                                                                      
  _Thread_Enable_dispatch();                                          
  10b876:	e8 6d 24 00 00       	call   10dce8 <_Thread_Enable_dispatch>
  10b87b:	31 c0                	xor    %eax,%eax                      
  10b87d:	83 c4 10             	add    $0x10,%esp                     
  return 0;                                                           
}                                                                     
  10b880:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b883:	c9                   	leave                                 
  10b884:	c3                   	ret                                   
                                                                      

0010966c <sigaction>: int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) {
  10966c:	55                   	push   %ebp                           
  10966d:	89 e5                	mov    %esp,%ebp                      
  10966f:	57                   	push   %edi                           
  109670:	56                   	push   %esi                           
  109671:	53                   	push   %ebx                           
  109672:	83 ec 0c             	sub    $0xc,%esp                      
  109675:	8b 5d 08             	mov    0x8(%ebp),%ebx                 
  109678:	8b 7d 10             	mov    0x10(%ebp),%edi                
  ISR_Level     level;                                                
                                                                      
  if ( oact )                                                         
  10967b:	85 ff                	test   %edi,%edi                      
  10967d:	74 10                	je     10968f <sigaction+0x23>        
    *oact = _POSIX_signals_Vectors[ sig ];                            
  10967f:	6b c3 0c             	imul   $0xc,%ebx,%eax                 
  109682:	8d b0 9c 06 12 00    	lea    0x12069c(%eax),%esi            
  109688:	b9 03 00 00 00       	mov    $0x3,%ecx                      
  10968d:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  if ( !sig )                                                         
  10968f:	85 db                	test   %ebx,%ebx                      
  109691:	74 0d                	je     1096a0 <sigaction+0x34>        
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
  109693:	8d 4b ff             	lea    -0x1(%ebx),%ecx                
  109696:	83 f9 1f             	cmp    $0x1f,%ecx                     
  109699:	77 05                	ja     1096a0 <sigaction+0x34>        
   *                                                                  
   *  NOTE: Solaris documentation claims to "silently enforce" this which
   *        contradicts the POSIX specification.                      
   */                                                                 
                                                                      
  if ( sig == SIGKILL )                                               
  10969b:	83 fb 09             	cmp    $0x9,%ebx                      
  10969e:	75 10                	jne    1096b0 <sigaction+0x44>        
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  1096a0:	e8 6b 68 00 00       	call   10ff10 <__errno>               
  1096a5:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  1096ab:	83 c8 ff             	or     $0xffffffff,%eax               
  1096ae:	eb 5a                	jmp    10970a <sigaction+0x9e>        
  /*                                                                  
   *  Evaluate the new action structure and set the global signal vector
   *  appropriately.                                                  
   */                                                                 
                                                                      
  if ( act ) {                                                        
  1096b0:	31 c0                	xor    %eax,%eax                      
  1096b2:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  1096b6:	74 52                	je     10970a <sigaction+0x9e>        <== NEVER TAKEN
    /*                                                                
     *  Unless the user is installing the default signal actions, then
     *  we can just copy the provided sigaction structure into the vectors.
     */                                                               
                                                                      
    _ISR_Disable( level );                                            
  1096b8:	9c                   	pushf                                 
  1096b9:	fa                   	cli                                   
  1096ba:	8f 45 f0             	popl   -0x10(%ebp)                    
      if ( act->sa_handler == SIG_DFL ) {                             
  1096bd:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  1096c0:	83 78 08 00          	cmpl   $0x0,0x8(%eax)                 
  1096c4:	75 18                	jne    1096de <sigaction+0x72>        
        _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
  1096c6:	6b c3 0c             	imul   $0xc,%ebx,%eax                 
  1096c9:	8d b8 9c 06 12 00    	lea    0x12069c(%eax),%edi            
  1096cf:	8d b0 e0 9e 11 00    	lea    0x119ee0(%eax),%esi            
  1096d5:	b9 03 00 00 00       	mov    $0x3,%ecx                      
  1096da:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  1096dc:	eb 26                	jmp    109704 <sigaction+0x98>        
      } else {                                                        
         _POSIX_signals_Clear_process_signals( signo_to_mask(sig) );  
  1096de:	83 ec 0c             	sub    $0xc,%esp                      
  1096e1:	b8 01 00 00 00       	mov    $0x1,%eax                      
  1096e6:	d3 e0                	shl    %cl,%eax                       
  1096e8:	50                   	push   %eax                           
  1096e9:	e8 1a 4e 00 00       	call   10e508 <_POSIX_signals_Clear_process_signals>
         _POSIX_signals_Vectors[ sig ] = *act;                        
  1096ee:	6b c3 0c             	imul   $0xc,%ebx,%eax                 
  1096f1:	8d b8 9c 06 12 00    	lea    0x12069c(%eax),%edi            
  1096f7:	b9 03 00 00 00       	mov    $0x3,%ecx                      
  1096fc:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  1096ff:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  109701:	83 c4 10             	add    $0x10,%esp                     
      }                                                               
    _ISR_Enable( level );                                             
  109704:	ff 75 f0             	pushl  -0x10(%ebp)                    
  109707:	9d                   	popf                                  
  109708:	31 c0                	xor    %eax,%eax                      
   *    + If we are now ignoring a signal that was previously pending,
   *      we clear the pending signal indicator.                      
   */                                                                 
                                                                      
  return 0;                                                           
}                                                                     
  10970a:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10970d:	5b                   	pop    %ebx                           
  10970e:	5e                   	pop    %esi                           
  10970f:	5f                   	pop    %edi                           
  109710:	c9                   	leave                                 
  109711:	c3                   	ret                                   
                                                                      

0010b250 <sigsuspend>: #include <rtems/seterr.h> int sigsuspend( const sigset_t *sigmask ) {
  10b250:	55                   	push   %ebp                           
  10b251:	89 e5                	mov    %esp,%ebp                      
  10b253:	56                   	push   %esi                           
  10b254:	53                   	push   %ebx                           
  10b255:	83 ec 14             	sub    $0x14,%esp                     
  int                 status;                                         
  POSIX_API_Control  *api;                                            
                                                                      
  api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];        
                                                                      
  status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); 
  10b258:	8d 5d f4             	lea    -0xc(%ebp),%ebx                
  10b25b:	53                   	push   %ebx                           
  10b25c:	ff 75 08             	pushl  0x8(%ebp)                      
  10b25f:	6a 01                	push   $0x1                           
  10b261:	e8 c6 ff ff ff       	call   10b22c <sigprocmask>           
                                                                      
  (void) sigfillset( &all_signals );                                  
  10b266:	8d 75 f0             	lea    -0x10(%ebp),%esi               
  10b269:	89 34 24             	mov    %esi,(%esp)                    
  10b26c:	e8 13 ff ff ff       	call   10b184 <sigfillset>            
                                                                      
  status = sigtimedwait( &all_signals, NULL, NULL );                  
  10b271:	83 c4 0c             	add    $0xc,%esp                      
  10b274:	6a 00                	push   $0x0                           
  10b276:	6a 00                	push   $0x0                           
  10b278:	56                   	push   %esi                           
  10b279:	e8 6b 00 00 00       	call   10b2e9 <sigtimedwait>          
  10b27e:	89 c6                	mov    %eax,%esi                      
                                                                      
  (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );    
  10b280:	83 c4 0c             	add    $0xc,%esp                      
  10b283:	6a 00                	push   $0x0                           
  10b285:	53                   	push   %ebx                           
  10b286:	6a 00                	push   $0x0                           
  10b288:	e8 9f ff ff ff       	call   10b22c <sigprocmask>           
                                                                      
  /*                                                                  
   * sigtimedwait() returns the signal number while sigsuspend()      
   * is supposed to return -1 and EINTR when a signal is caught.      
   */                                                                 
  if ( status != -1 )                                                 
  10b28d:	83 c4 10             	add    $0x10,%esp                     
  10b290:	46                   	inc    %esi                           
  10b291:	74 0b                	je     10b29e <sigsuspend+0x4e>       <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( EINTR );                    
  10b293:	e8 78 6b 00 00       	call   111e10 <__errno>               
  10b298:	c7 00 04 00 00 00    	movl   $0x4,(%eax)                    
                                                                      
  return status;                                                      
}                                                                     
  10b29e:	83 c8 ff             	or     $0xffffffff,%eax               
  10b2a1:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10b2a4:	5b                   	pop    %ebx                           
  10b2a5:	5e                   	pop    %esi                           
  10b2a6:	c9                   	leave                                 
  10b2a7:	c3                   	ret                                   
                                                                      

00109a39 <sigtimedwait>: int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) {
  109a39:	55                   	push   %ebp                           
  109a3a:	89 e5                	mov    %esp,%ebp                      
  109a3c:	57                   	push   %edi                           
  109a3d:	56                   	push   %esi                           
  109a3e:	53                   	push   %ebx                           
  109a3f:	83 ec 1c             	sub    $0x1c,%esp                     
  109a42:	8b 5d 10             	mov    0x10(%ebp),%ebx                
   *  NOTE: This is very specifically a RELATIVE not ABSOLUTE time    
   *        in the Open Group specification.                          
   */                                                                 
                                                                      
  interval = 0;                                                       
  if ( timeout ) {                                                    
  109a45:	85 db                	test   %ebx,%ebx                      
  109a47:	74 35                	je     109a7e <sigtimedwait+0x45>     
                                                                      
    if ( !_Timespec_Is_valid( timeout ) )                             
  109a49:	83 ec 0c             	sub    $0xc,%esp                      
  109a4c:	53                   	push   %ebx                           
  109a4d:	e8 92 31 00 00       	call   10cbe4 <_Timespec_Is_valid>    
  109a52:	83 c4 10             	add    $0x10,%esp                     
  109a55:	84 c0                	test   %al,%al                        
  109a57:	74 12                	je     109a6b <sigtimedwait+0x32>     
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    interval = _Timespec_To_ticks( timeout );                         
  109a59:	83 ec 0c             	sub    $0xc,%esp                      
  109a5c:	53                   	push   %ebx                           
  109a5d:	e8 de 31 00 00       	call   10cc40 <_Timespec_To_ticks>    
  109a62:	89 c3                	mov    %eax,%ebx                      
                                                                      
    if ( !interval )                                                  
  109a64:	83 c4 10             	add    $0x10,%esp                     
  109a67:	85 c0                	test   %eax,%eax                      
  109a69:	75 15                	jne    109a80 <sigtimedwait+0x47>     <== ALWAYS TAKEN
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  109a6b:	e8 10 6a 00 00       	call   110480 <__errno>               
  109a70:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  109a76:	83 cb ff             	or     $0xffffffff,%ebx               
  109a79:	e9 05 01 00 00       	jmp    109b83 <sigtimedwait+0x14a>    
  109a7e:	31 db                	xor    %ebx,%ebx                      
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
  109a80:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  109a83:	85 f6                	test   %esi,%esi                      
  109a85:	75 03                	jne    109a8a <sigtimedwait+0x51>     
  109a87:	8d 75 e8             	lea    -0x18(%ebp),%esi               
                                                                      
  the_thread = _Thread_Executing;                                     
  109a8a:	8b 15 f8 07 12 00    	mov    0x1207f8,%edx                  
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  109a90:	8b ba f8 00 00 00    	mov    0xf8(%edx),%edi                
   *  What if they are already pending?                               
   */                                                                 
                                                                      
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
  109a96:	9c                   	pushf                                 
  109a97:	fa                   	cli                                   
  109a98:	8f 45 e0             	popl   -0x20(%ebp)                    
  if ( *set & api->signals_pending ) {                                
  109a9b:	8b 45 08             	mov    0x8(%ebp),%eax                 
  109a9e:	8b 08                	mov    (%eax),%ecx                    
  109aa0:	8b 87 c8 00 00 00    	mov    0xc8(%edi),%eax                
  109aa6:	85 c1                	test   %eax,%ecx                      
  109aa8:	74 2c                	je     109ad6 <sigtimedwait+0x9d>     
    /* XXX real info later */                                         
    the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending );
  109aaa:	50                   	push   %eax                           
  109aab:	e8 48 ff ff ff       	call   1099f8 <_POSIX_signals_Get_highest>
  109ab0:	89 06                	mov    %eax,(%esi)                    
    _POSIX_signals_Clear_signals(                                     
  109ab2:	51                   	push   %ecx                           
  109ab3:	51                   	push   %ecx                           
  109ab4:	6a 00                	push   $0x0                           
  109ab6:	6a 00                	push   $0x0                           
  109ab8:	56                   	push   %esi                           
  109ab9:	50                   	push   %eax                           
  109aba:	57                   	push   %edi                           
  109abb:	e8 38 50 00 00       	call   10eaf8 <_POSIX_signals_Clear_signals>
      the_info->si_signo,                                             
      the_info,                                                       
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
  109ac0:	ff 75 e0             	pushl  -0x20(%ebp)                    
  109ac3:	9d                   	popf                                  
                                                                      
    the_info->si_code = SI_USER;                                      
  109ac4:	c7 46 04 01 00 00 00 	movl   $0x1,0x4(%esi)                 
    the_info->si_value.sival_int = 0;                                 
  109acb:	c7 46 08 00 00 00 00 	movl   $0x0,0x8(%esi)                 
    return the_info->si_signo;                                        
  109ad2:	8b 1e                	mov    (%esi),%ebx                    
  109ad4:	eb 33                	jmp    109b09 <sigtimedwait+0xd0>     
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
  109ad6:	a1 a8 0e 12 00       	mov    0x120ea8,%eax                  
  109adb:	85 c1                	test   %eax,%ecx                      
  109add:	74 2f                	je     109b0e <sigtimedwait+0xd5>     
    signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending );     
  109adf:	50                   	push   %eax                           
  109ae0:	e8 13 ff ff ff       	call   1099f8 <_POSIX_signals_Get_highest>
  109ae5:	89 c3                	mov    %eax,%ebx                      
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
  109ae7:	52                   	push   %edx                           
  109ae8:	52                   	push   %edx                           
  109ae9:	6a 00                	push   $0x0                           
  109aeb:	6a 01                	push   $0x1                           
  109aed:	56                   	push   %esi                           
  109aee:	50                   	push   %eax                           
  109aef:	57                   	push   %edi                           
  109af0:	e8 03 50 00 00       	call   10eaf8 <_POSIX_signals_Clear_signals>
    _ISR_Enable( level );                                             
  109af5:	ff 75 e0             	pushl  -0x20(%ebp)                    
  109af8:	9d                   	popf                                  
                                                                      
    the_info->si_signo = signo;                                       
  109af9:	89 1e                	mov    %ebx,(%esi)                    
    the_info->si_code = SI_USER;                                      
  109afb:	c7 46 04 01 00 00 00 	movl   $0x1,0x4(%esi)                 
    the_info->si_value.sival_int = 0;                                 
  109b02:	c7 46 08 00 00 00 00 	movl   $0x0,0x8(%esi)                 
  109b09:	83 c4 20             	add    $0x20,%esp                     
  109b0c:	eb 75                	jmp    109b83 <sigtimedwait+0x14a>    
    return signo;                                                     
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
  109b0e:	c7 06 ff ff ff ff    	movl   $0xffffffff,(%esi)             
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  109b14:	a1 38 07 12 00       	mov    0x120738,%eax                  
  109b19:	40                   	inc    %eax                           
  109b1a:	a3 38 07 12 00       	mov    %eax,0x120738                  
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
  109b1f:	c7 42 44 68 0e 12 00 	movl   $0x120e68,0x44(%edx)           
    the_thread->Wait.return_code     = EINTR;                         
  109b26:	c7 42 34 04 00 00 00 	movl   $0x4,0x34(%edx)                
    the_thread->Wait.option          = *set;                          
  109b2d:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
  109b30:	8b 01                	mov    (%ecx),%eax                    
  109b32:	89 42 30             	mov    %eax,0x30(%edx)                
    the_thread->Wait.return_argument = the_info;                      
  109b35:	89 72 28             	mov    %esi,0x28(%edx)                
{                                                                     
  return _Heap_Initialize( the_heap, starting_address, size, page_size );
}                                                                     
                                                                      
/**                                                                   
 *  This routine grows @a the_heap memory area using the size bytes which
  109b38:	c7 05 98 0e 12 00 01 	movl   $0x1,0x120e98                  
  109b3f:	00 00 00                                                    
    _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
    _ISR_Enable( level );                                             
  109b42:	ff 75 e0             	pushl  -0x20(%ebp)                    
  109b45:	9d                   	popf                                  
    _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );    
  109b46:	50                   	push   %eax                           
  109b47:	68 e0 c7 10 00       	push   $0x10c7e0                      
  109b4c:	53                   	push   %ebx                           
  109b4d:	68 68 0e 12 00       	push   $0x120e68                      
  109b52:	e8 85 29 00 00       	call   10c4dc <_Thread_queue_Enqueue_with_handler>
  _Thread_Enable_dispatch();                                          
  109b57:	e8 30 25 00 00       	call   10c08c <_Thread_Enable_dispatch>
  /*                                                                  
   * 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 );
  109b5c:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)                    
  109b63:	6a 00                	push   $0x0                           
  109b65:	56                   	push   %esi                           
  109b66:	ff 36                	pushl  (%esi)                         
  109b68:	57                   	push   %edi                           
  109b69:	e8 8a 4f 00 00       	call   10eaf8 <_POSIX_signals_Clear_signals>
  errno = _Thread_Executing->Wait.return_code;                        
  109b6e:	83 c4 20             	add    $0x20,%esp                     
  109b71:	e8 0a 69 00 00       	call   110480 <__errno>               
  109b76:	8b 15 f8 07 12 00    	mov    0x1207f8,%edx                  
  109b7c:	8b 52 34             	mov    0x34(%edx),%edx                
  109b7f:	89 10                	mov    %edx,(%eax)                    
  return the_info->si_signo;                                          
  109b81:	8b 1e                	mov    (%esi),%ebx                    
}                                                                     
  109b83:	89 d8                	mov    %ebx,%eax                      
  109b85:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109b88:	5b                   	pop    %ebx                           
  109b89:	5e                   	pop    %esi                           
  109b8a:	5f                   	pop    %edi                           
  109b8b:	c9                   	leave                                 
  109b8c:	c3                   	ret                                   
                                                                      

0010b458 <sigwait>: int sigwait( const sigset_t *set, int *sig ) {
  10b458:	55                   	push   %ebp                           
  10b459:	89 e5                	mov    %esp,%ebp                      
  10b45b:	53                   	push   %ebx                           
  10b45c:	83 ec 08             	sub    $0x8,%esp                      
  10b45f:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  int status;                                                         
                                                                      
  status = sigtimedwait( set, NULL, NULL );                           
  10b462:	6a 00                	push   $0x0                           
  10b464:	6a 00                	push   $0x0                           
  10b466:	ff 75 08             	pushl  0x8(%ebp)                      
  10b469:	e8 7b fe ff ff       	call   10b2e9 <sigtimedwait>          
  10b46e:	89 c2                	mov    %eax,%edx                      
                                                                      
  if ( status != -1 ) {                                               
  10b470:	83 c4 10             	add    $0x10,%esp                     
  10b473:	83 f8 ff             	cmp    $0xffffffff,%eax               
  10b476:	74 0c                	je     10b484 <sigwait+0x2c>          <== NEVER TAKEN
    if ( sig )                                                        
  10b478:	31 c0                	xor    %eax,%eax                      
  10b47a:	85 db                	test   %ebx,%ebx                      
  10b47c:	74 0d                	je     10b48b <sigwait+0x33>          <== NEVER TAKEN
      *sig = status;                                                  
  10b47e:	89 13                	mov    %edx,(%ebx)                    
  10b480:	31 c0                	xor    %eax,%eax                      
  10b482:	eb 07                	jmp    10b48b <sigwait+0x33>          
    return 0;                                                         
  }                                                                   
                                                                      
  return errno;                                                       
  10b484:	e8 87 69 00 00       	call   111e10 <__errno>               <== NOT EXECUTED
  10b489:	8b 00                	mov    (%eax),%eax                    <== NOT EXECUTED
}                                                                     
  10b48b:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10b48e:	c9                   	leave                                 
  10b48f:	c3                   	ret                                   
                                                                      

00107b8b <siproc>: /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) {
  107b8b:	55                   	push   %ebp                           <== NOT EXECUTED
  107b8c:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  107b8e:	56                   	push   %esi                           <== NOT EXECUTED
  107b8f:	53                   	push   %ebx                           <== NOT EXECUTED
  107b90:	89 d6                	mov    %edx,%esi                      <== NOT EXECUTED
  107b92:	88 c3                	mov    %al,%bl                        <== NOT EXECUTED
	int i;                                                               
                                                                      
	/*                                                                   
	 * Obtain output semaphore if character will be echoed               
	 */                                                                  
	if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
  107b94:	f7 42 3c 78 0e 00 00 	testl  $0xe78,0x3c(%edx)              <== NOT EXECUTED
  107b9b:	74 2e                	je     107bcb <siproc+0x40>           <== NOT EXECUTED
		rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);   
  107b9d:	51                   	push   %ecx                           <== NOT EXECUTED
  107b9e:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107ba0:	6a 00                	push   $0x0                           <== NOT EXECUTED
  107ba2:	ff 72 18             	pushl  0x18(%edx)                     <== NOT EXECUTED
  107ba5:	e8 ca 15 00 00       	call   109174 <rtems_semaphore_obtain><== NOT EXECUTED
		i = iproc (c, tty);                                                 
  107baa:	0f b6 c3             	movzbl %bl,%eax                       <== NOT EXECUTED
  107bad:	89 f2                	mov    %esi,%edx                      <== NOT EXECUTED
  107baf:	e8 c8 fe ff ff       	call   107a7c <iproc>                 <== NOT EXECUTED
  107bb4:	89 c3                	mov    %eax,%ebx                      <== NOT EXECUTED
		rtems_semaphore_release (tty->osem);                                
  107bb6:	5a                   	pop    %edx                           <== NOT EXECUTED
  107bb7:	ff 76 18             	pushl  0x18(%esi)                     <== NOT EXECUTED
  107bba:	e8 9d 16 00 00       	call   10925c <rtems_semaphore_release><== NOT EXECUTED
  107bbf:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
	}                                                                    
	else {                                                               
		i = iproc (c, tty);                                                 
	}                                                                    
	return i;                                                            
}                                                                     
  107bc2:	89 d8                	mov    %ebx,%eax                      <== NOT EXECUTED
  107bc4:	8d 65 f8             	lea    -0x8(%ebp),%esp                <== NOT EXECUTED
  107bc7:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107bc8:	5e                   	pop    %esi                           <== NOT EXECUTED
  107bc9:	c9                   	leave                                 <== NOT EXECUTED
  107bca:	c3                   	ret                                   <== NOT EXECUTED
		rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);   
		i = iproc (c, tty);                                                 
		rtems_semaphore_release (tty->osem);                                
	}                                                                    
	else {                                                               
		i = iproc (c, tty);                                                 
  107bcb:	0f b6 c0             	movzbl %al,%eax                       <== NOT EXECUTED
	}                                                                    
	return i;                                                            
}                                                                     
  107bce:	8d 65 f8             	lea    -0x8(%ebp),%esp                <== NOT EXECUTED
  107bd1:	5b                   	pop    %ebx                           <== NOT EXECUTED
  107bd2:	5e                   	pop    %esi                           <== NOT EXECUTED
  107bd3:	c9                   	leave                                 <== NOT EXECUTED
		rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);   
		i = iproc (c, tty);                                                 
		rtems_semaphore_release (tty->osem);                                
	}                                                                    
	else {                                                               
		i = iproc (c, tty);                                                 
  107bd4:	e9 a3 fe ff ff       	jmp    107a7c <iproc>                 <== NOT EXECUTED
                                                                      

00108380 <stat>: int _STAT_NAME( const char *path, struct stat *buf ) {
  108380:	55                   	push   %ebp                           
  108381:	89 e5                	mov    %esp,%ebp                      
  108383:	57                   	push   %edi                           
  108384:	56                   	push   %esi                           
  108385:	53                   	push   %ebx                           
  108386:	83 ec 1c             	sub    $0x1c,%esp                     
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
  108389:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)                 
  10838d:	75 0d                	jne    10839c <stat+0x1c>             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
  10838f:	e8 4c 8c 00 00       	call   110fe0 <__errno>               
  108394:	c7 00 0e 00 00 00    	movl   $0xe,(%eax)                    
  10839a:	eb 45                	jmp    1083e1 <stat+0x61>             
                                                                      
  status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS );
  10839c:	6a 01                	push   $0x1                           
  10839e:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  1083a1:	56                   	push   %esi                           
  1083a2:	6a 00                	push   $0x0                           
  1083a4:	ff 75 08             	pushl  0x8(%ebp)                      
  1083a7:	e8 e2 eb ff ff       	call   106f8e <rtems_filesystem_evaluate_path>
  if ( status != 0 )                                                  
  1083ac:	83 c4 10             	add    $0x10,%esp                     
  1083af:	83 cb ff             	or     $0xffffffff,%ebx               
  1083b2:	85 c0                	test   %eax,%eax                      
  1083b4:	75 5f                	jne    108415 <stat+0x95>             
    return -1;                                                        
                                                                      
  if ( !loc.handlers->fstat_h ){                                      
  1083b6:	8b 55 e8             	mov    -0x18(%ebp),%edx               
  1083b9:	83 7a 18 00          	cmpl   $0x0,0x18(%edx)                
  1083bd:	75 27                	jne    1083e6 <stat+0x66>             <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  1083bf:	8b 45 ec             	mov    -0x14(%ebp),%eax               <== NOT EXECUTED
  1083c2:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1083c4:	74 10                	je     1083d6 <stat+0x56>             <== NOT EXECUTED
  1083c6:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  1083c9:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  1083cb:	74 09                	je     1083d6 <stat+0x56>             <== NOT EXECUTED
  1083cd:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  1083d0:	56                   	push   %esi                           <== NOT EXECUTED
  1083d1:	ff d0                	call   *%eax                          <== NOT EXECUTED
  1083d3:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  1083d6:	e8 05 8c 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  1083db:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1083e1:	83 cb ff             	or     $0xffffffff,%ebx               
  1083e4:	eb 2f                	jmp    108415 <stat+0x95>             
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
  1083e6:	b9 13 00 00 00       	mov    $0x13,%ecx                     
  1083eb:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  1083ee:	f3 ab                	rep stos %eax,%es:(%edi)              
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
  1083f0:	50                   	push   %eax                           
  1083f1:	50                   	push   %eax                           
  1083f2:	ff 75 0c             	pushl  0xc(%ebp)                      
  1083f5:	56                   	push   %esi                           
  1083f6:	ff 52 18             	call   *0x18(%edx)                    
  1083f9:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  1083fb:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  1083fe:	83 c4 10             	add    $0x10,%esp                     
  108401:	85 c0                	test   %eax,%eax                      
  108403:	74 10                	je     108415 <stat+0x95>             <== NEVER TAKEN
  108405:	8b 40 1c             	mov    0x1c(%eax),%eax                
  108408:	85 c0                	test   %eax,%eax                      
  10840a:	74 09                	je     108415 <stat+0x95>             <== NEVER TAKEN
  10840c:	83 ec 0c             	sub    $0xc,%esp                      
  10840f:	56                   	push   %esi                           
  108410:	ff d0                	call   *%eax                          
  108412:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return status;                                                      
}                                                                     
  108415:	89 d8                	mov    %ebx,%eax                      
  108417:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10841a:	5b                   	pop    %ebx                           
  10841b:	5e                   	pop    %esi                           
  10841c:	5f                   	pop    %edi                           
  10841d:	c9                   	leave                                 
  10841e:	c3                   	ret                                   
                                                                      

00108a54 <symlink>: int symlink( const char *actualpath, const char *sympath ) {
  108a54:	55                   	push   %ebp                           
  108a55:	89 e5                	mov    %esp,%ebp                      
  108a57:	57                   	push   %edi                           
  108a58:	56                   	push   %esi                           
  108a59:	53                   	push   %ebx                           
  108a5a:	83 ec 2c             	sub    $0x2c,%esp                     
  108a5d:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 
  rtems_filesystem_location_info_t    loc;                            
  int                                 i;                              
  const char                         *name_start;                     
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
  108a60:	8a 03                	mov    (%ebx),%al                     
  108a62:	3c 2f                	cmp    $0x2f,%al                      
  108a64:	74 08                	je     108a6e <symlink+0x1a>          
  108a66:	3c 5c                	cmp    $0x5c,%al                      
  108a68:	74 04                	je     108a6e <symlink+0x1a>          <== NEVER TAKEN
  108a6a:	84 c0                	test   %al,%al                        
  108a6c:	75 19                	jne    108a87 <symlink+0x33>          <== ALWAYS TAKEN
  108a6e:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  108a71:	a1 4c 09 12 00       	mov    0x12094c,%eax                  
  108a76:	8d 70 14             	lea    0x14(%eax),%esi                
  108a79:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  108a7e:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  108a80:	ba 01 00 00 00       	mov    $0x1,%edx                      
  108a85:	eb 14                	jmp    108a9b <symlink+0x47>          
  108a87:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  108a8a:	a1 4c 09 12 00       	mov    0x12094c,%eax                  
  108a8f:	8d 70 04             	lea    0x4(%eax),%esi                 
  108a92:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  108a97:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
  108a99:	31 d2                	xor    %edx,%edx                      
  result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
  108a9b:	51                   	push   %ecx                           
  108a9c:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  108a9f:	50                   	push   %eax                           
  108aa0:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  108aa3:	57                   	push   %edi                           
  108aa4:	8d 04 13             	lea    (%ebx,%edx,1),%eax             
  108aa7:	50                   	push   %eax                           
  108aa8:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  108aab:	ff 50 04             	call   *0x4(%eax)                     
  if ( result != 0 )                                                  
  108aae:	83 c4 10             	add    $0x10,%esp                     
  108ab1:	83 ce ff             	or     $0xffffffff,%esi               
  108ab4:	85 c0                	test   %eax,%eax                      
  108ab6:	75 50                	jne    108b08 <symlink+0xb4>          
    return -1;                                                        
                                                                      
  if ( !loc.ops->symlink_h ) {                                        
  108ab8:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  108abb:	8b 50 38             	mov    0x38(%eax),%edx                
  108abe:	85 d2                	test   %edx,%edx                      
  108ac0:	75 20                	jne    108ae2 <symlink+0x8e>          <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  108ac2:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  108ac5:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  108ac7:	74 09                	je     108ad2 <symlink+0x7e>          <== NOT EXECUTED
  108ac9:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  108acc:	57                   	push   %edi                           <== NOT EXECUTED
  108acd:	ff d0                	call   *%eax                          <== NOT EXECUTED
  108acf:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  108ad2:	e8 d9 8a 00 00       	call   1115b0 <__errno>               <== NOT EXECUTED
  108ad7:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  108add:	83 ce ff             	or     $0xffffffff,%esi               <== NOT EXECUTED
  108ae0:	eb 26                	jmp    108b08 <symlink+0xb4>          <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);      
  108ae2:	50                   	push   %eax                           
  108ae3:	ff 75 f0             	pushl  -0x10(%ebp)                    
  108ae6:	ff 75 08             	pushl  0x8(%ebp)                      
  108ae9:	57                   	push   %edi                           
  108aea:	ff d2                	call   *%edx                          
  108aec:	89 c6                	mov    %eax,%esi                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  108aee:	8b 45 e8             	mov    -0x18(%ebp),%eax               
  108af1:	83 c4 10             	add    $0x10,%esp                     
  108af4:	85 c0                	test   %eax,%eax                      
  108af6:	74 10                	je     108b08 <symlink+0xb4>          <== NEVER TAKEN
  108af8:	8b 40 1c             	mov    0x1c(%eax),%eax                
  108afb:	85 c0                	test   %eax,%eax                      
  108afd:	74 09                	je     108b08 <symlink+0xb4>          <== NEVER TAKEN
  108aff:	83 ec 0c             	sub    $0xc,%esp                      
  108b02:	57                   	push   %edi                           
  108b03:	ff d0                	call   *%eax                          
  108b05:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  108b08:	89 f0                	mov    %esi,%eax                      
  108b0a:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  108b0d:	5b                   	pop    %ebx                           
  108b0e:	5e                   	pop    %esi                           
  108b0f:	5f                   	pop    %edi                           
  108b10:	c9                   	leave                                 
  108b11:	c3                   	ret                                   
                                                                      

00108434 <sync_per_thread>: fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) {
  108434:	55                   	push   %ebp                           
  108435:	89 e5                	mov    %esp,%ebp                      
  108437:	53                   	push   %ebx                           
  108438:	83 ec 04             	sub    $0x4,%esp                      
  10843b:	8b 4d 08             	mov    0x8(%ebp),%ecx                 
                                                                      
   /*                                                                 
    *  The sync_wrapper() function will operate on the current thread's
    *  reent structure so we will temporarily use that.               
    */                                                                
   this_reent = t->libc_reent;                                        
  10843e:	8b 91 f0 00 00 00    	mov    0xf0(%ecx),%edx                
   if ( this_reent ) {                                                
  108444:	85 d2                	test   %edx,%edx                      
  108446:	74 31                	je     108479 <sync_per_thread+0x45>  <== NEVER TAKEN
     current_reent = _Thread_Executing->libc_reent;                   
  108448:	a1 88 15 12 00       	mov    0x121588,%eax                  
  10844d:	8b 98 f0 00 00 00    	mov    0xf0(%eax),%ebx                
     _Thread_Executing->libc_reent = this_reent;                      
  108453:	89 90 f0 00 00 00    	mov    %edx,0xf0(%eax)                
     _fwalk (t->libc_reent, sync_wrapper);                            
  108459:	50                   	push   %eax                           
  10845a:	50                   	push   %eax                           
  10845b:	68 a4 84 10 00       	push   $0x1084a4                      
  108460:	ff b1 f0 00 00 00    	pushl  0xf0(%ecx)                     
  108466:	e8 dd 97 00 00       	call   111c48 <_fwalk>                
     _Thread_Executing->libc_reent = current_reent;                   
  10846b:	a1 88 15 12 00       	mov    0x121588,%eax                  
  108470:	89 98 f0 00 00 00    	mov    %ebx,0xf0(%eax)                
  108476:	83 c4 10             	add    $0x10,%esp                     
   }                                                                  
}                                                                     
  108479:	8b 5d fc             	mov    -0x4(%ebp),%ebx                
  10847c:	c9                   	leave                                 
  10847d:	c3                   	ret                                   
                                                                      

001090ec <telldir>: #include <rtems/seterr.h> long telldir( DIR *dirp ) {
  1090ec:	55                   	push   %ebp                           
  1090ed:	89 e5                	mov    %esp,%ebp                      
  1090ef:	83 ec 08             	sub    $0x8,%esp                      
  1090f2:	8b 45 08             	mov    0x8(%ebp),%eax                 
  rtems_libio_t  *iop;                                                
                                                                      
  if ( !dirp )                                                        
  1090f5:	85 c0                	test   %eax,%eax                      
  1090f7:	75 10                	jne    109109 <telldir+0x1d>          <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( EBADF );                    
  1090f9:	e8 e2 8c 00 00       	call   111de0 <__errno>               <== NOT EXECUTED
  1090fe:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  109104:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  109107:	eb 2e                	jmp    109137 <telldir+0x4b>          <== NOT EXECUTED
  /*                                                                  
   *  Get the file control block structure associated with the        
   *  file descriptor                                                 
   */                                                                 
                                                                      
  iop = rtems_libio_iop( dirp->dd_fd );                               
  109109:	8b 00                	mov    (%eax),%eax                    
  10910b:	3b 05 18 e2 11 00    	cmp    0x11e218,%eax                  
  109111:	73 0b                	jae    10911e <telldir+0x32>          <== NEVER TAKEN
  109113:	6b c0 34             	imul   $0x34,%eax,%eax                
                                                                      
  if (iop == NULL)                                                    
  109116:	03 05 18 26 12 00    	add    0x122618,%eax                  
  10911c:	75 16                	jne    109134 <telldir+0x48>          <== ALWAYS TAKEN
     assert(0);                                                       
  10911e:	68 a7 b6 11 00       	push   $0x11b6a7                      <== NOT EXECUTED
  109123:	68 a8 be 11 00       	push   $0x11bea8                      <== NOT EXECUTED
  109128:	6a 2c                	push   $0x2c                          <== NOT EXECUTED
  10912a:	68 5b be 11 00       	push   $0x11be5b                      <== NOT EXECUTED
  10912f:	e8 00 e4 ff ff       	call   107534 <__assert_func>         <== NOT EXECUTED
                                                                      
  return (long)( iop->offset );                                       
  109134:	8b 40 08             	mov    0x8(%eax),%eax                 
}                                                                     
  109137:	c9                   	leave                                 
  109138:	c3                   	ret                                   
                                                                      

00107078 <termios_baud_to_number>: #include <sys/termios.h> int termios_baud_to_number( int termios_baud ) {
  107078:	55                   	push   %ebp                           <== NOT EXECUTED
  107079:	89 e5                	mov    %esp,%ebp                      <== NOT EXECUTED
  10707b:	8b 55 08             	mov    0x8(%ebp),%edx                 <== NOT EXECUTED
    case B110:      baud =    110;  break;                            
    case B134:      baud =    135;  break;                            
    case B150:      baud =    150;  break;                            
    case B200:      baud =    200;  break;                            
    case B300:      baud =    300;  break;                            
    case B600:      baud =    600;  break;                            
  10707e:	b8 b0 04 00 00       	mov    $0x4b0,%eax                    <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107083:	83 fa 09             	cmp    $0x9,%edx                      <== NOT EXECUTED
  107086:	0f 84 d6 00 00 00    	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
  10708c:	7f 65                	jg     1070f3 <termios_baud_to_number+0x7b><== NOT EXECUTED
    case B0:        baud =      0;  break;                            
    case B50:       baud =     50;  break;                            
    case B75:       baud =     75;  break;                            
    case B110:      baud =    110;  break;                            
  10708e:	66 b8 87 00          	mov    $0x87,%ax                      <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107092:	83 fa 04             	cmp    $0x4,%edx                      <== NOT EXECUTED
  107095:	0f 84 c7 00 00 00    	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
  10709b:	7f 2e                	jg     1070cb <termios_baud_to_number+0x53><== NOT EXECUTED
  10709d:	b0 32                	mov    $0x32,%al                      <== NOT EXECUTED
  10709f:	83 fa 01             	cmp    $0x1,%edx                      <== NOT EXECUTED
  1070a2:	0f 84 ba 00 00 00    	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
  1070a8:	7f 09                	jg     1070b3 <termios_baud_to_number+0x3b><== NOT EXECUTED
  1070aa:	30 c0                	xor    %al,%al                        <== NOT EXECUTED
  1070ac:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  1070ae:	e9 aa 00 00 00       	jmp    10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
  1070b3:	b8 4b 00 00 00       	mov    $0x4b,%eax                     <== NOT EXECUTED
  1070b8:	83 fa 02             	cmp    $0x2,%edx                      <== NOT EXECUTED
  1070bb:	0f 84 a1 00 00 00    	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B0:        baud =      0;  break;                            
    case B50:       baud =     50;  break;                            
    case B75:       baud =     75;  break;                            
  1070c1:	b0 6e                	mov    $0x6e,%al                      <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  1070c3:	83 fa 03             	cmp    $0x3,%edx                      <== NOT EXECUTED
  1070c6:	e9 92 00 00 00       	jmp    10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
    case B0:        baud =      0;  break;                            
    case B50:       baud =     50;  break;                            
    case B75:       baud =     75;  break;                            
    case B110:      baud =    110;  break;                            
    case B134:      baud =    135;  break;                            
    case B150:      baud =    150;  break;                            
  1070cb:	b8 c8 00 00 00       	mov    $0xc8,%eax                     <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  1070d0:	83 fa 06             	cmp    $0x6,%edx                      <== NOT EXECUTED
  1070d3:	0f 84 89 00 00 00    	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B0:        baud =      0;  break;                            
    case B50:       baud =     50;  break;                            
    case B75:       baud =     75;  break;                            
    case B110:      baud =    110;  break;                            
    case B134:      baud =    135;  break;                            
  1070d9:	b0 96                	mov    $0x96,%al                      <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  1070db:	0f 8c 81 00 00 00    	jl     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B50:       baud =     50;  break;                            
    case B75:       baud =     75;  break;                            
    case B110:      baud =    110;  break;                            
    case B134:      baud =    135;  break;                            
    case B150:      baud =    150;  break;                            
    case B200:      baud =    200;  break;                            
  1070e1:	66 b8 2c 01          	mov    $0x12c,%ax                     <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  1070e5:	83 fa 07             	cmp    $0x7,%edx                      <== NOT EXECUTED
  1070e8:	74 78                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B75:       baud =     75;  break;                            
    case B110:      baud =    110;  break;                            
    case B134:      baud =    135;  break;                            
    case B150:      baud =    150;  break;                            
    case B200:      baud =    200;  break;                            
    case B300:      baud =    300;  break;                            
  1070ea:	66 b8 58 02          	mov    $0x258,%ax                     <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  1070ee:	83 fa 08             	cmp    $0x8,%edx                      <== NOT EXECUTED
  1070f1:	eb 6a                	jmp    10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
    case B600:      baud =    600;  break;                            
    case B1200:     baud =   1200;  break;                            
    case B1800:     baud =   1800;  break;                            
    case B2400:     baud =   2400;  break;                            
    case B4800:     baud =   4800;  break;                            
    case B9600:     baud =   9600;  break;                            
  1070f3:	b8 00 4b 00 00       	mov    $0x4b00,%eax                   <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  1070f8:	83 fa 0e             	cmp    $0xe,%edx                      <== NOT EXECUTED
  1070fb:	74 65                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
  1070fd:	7f 21                	jg     107120 <termios_baud_to_number+0xa8><== NOT EXECUTED
    case B150:      baud =    150;  break;                            
    case B200:      baud =    200;  break;                            
    case B300:      baud =    300;  break;                            
    case B600:      baud =    600;  break;                            
    case B1200:     baud =   1200;  break;                            
    case B1800:     baud =   1800;  break;                            
  1070ff:	66 b8 60 09          	mov    $0x960,%ax                     <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107103:	83 fa 0b             	cmp    $0xb,%edx                      <== NOT EXECUTED
  107106:	74 5a                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B134:      baud =    135;  break;                            
    case B150:      baud =    150;  break;                            
    case B200:      baud =    200;  break;                            
    case B300:      baud =    300;  break;                            
    case B600:      baud =    600;  break;                            
    case B1200:     baud =   1200;  break;                            
  107108:	66 b8 08 07          	mov    $0x708,%ax                     <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  10710c:	7c 54                	jl     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B200:      baud =    200;  break;                            
    case B300:      baud =    300;  break;                            
    case B600:      baud =    600;  break;                            
    case B1200:     baud =   1200;  break;                            
    case B1800:     baud =   1800;  break;                            
    case B2400:     baud =   2400;  break;                            
  10710e:	66 b8 c0 12          	mov    $0x12c0,%ax                    <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107112:	83 fa 0c             	cmp    $0xc,%edx                      <== NOT EXECUTED
  107115:	74 4b                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B300:      baud =    300;  break;                            
    case B600:      baud =    600;  break;                            
    case B1200:     baud =   1200;  break;                            
    case B1800:     baud =   1800;  break;                            
    case B2400:     baud =   2400;  break;                            
    case B4800:     baud =   4800;  break;                            
  107117:	66 b8 80 25          	mov    $0x2580,%ax                    <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  10711b:	83 fa 0d             	cmp    $0xd,%edx                      <== NOT EXECUTED
  10711e:	eb 3d                	jmp    10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
    case B2400:     baud =   2400;  break;                            
    case B4800:     baud =   4800;  break;                            
    case B9600:     baud =   9600;  break;                            
    case B19200:    baud =  19200;  break;                            
    case B38400:    baud =  38400;  break;                            
    case B57600:    baud =  57600;  break;                            
  107120:	b8 00 c2 01 00       	mov    $0x1c200,%eax                  <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107125:	81 fa 02 10 00 00    	cmp    $0x1002,%edx                   <== NOT EXECUTED
  10712b:	74 35                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
  10712d:	7f 16                	jg     107145 <termios_baud_to_number+0xcd><== NOT EXECUTED
    case B1200:     baud =   1200;  break;                            
    case B1800:     baud =   1800;  break;                            
    case B2400:     baud =   2400;  break;                            
    case B4800:     baud =   4800;  break;                            
    case B9600:     baud =   9600;  break;                            
    case B19200:    baud =  19200;  break;                            
  10712f:	b8 00 96 00 00       	mov    $0x9600,%eax                   <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107134:	83 fa 0f             	cmp    $0xf,%edx                      <== NOT EXECUTED
  107137:	74 29                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B1800:     baud =   1800;  break;                            
    case B2400:     baud =   2400;  break;                            
    case B4800:     baud =   4800;  break;                            
    case B9600:     baud =   9600;  break;                            
    case B19200:    baud =  19200;  break;                            
    case B38400:    baud =  38400;  break;                            
  107139:	66 b8 00 e1          	mov    $0xe100,%ax                    <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  10713d:	81 fa 01 10 00 00    	cmp    $0x1001,%edx                   <== NOT EXECUTED
  107143:	eb 18                	jmp    10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
    case B4800:     baud =   4800;  break;                            
    case B9600:     baud =   9600;  break;                            
    case B19200:    baud =  19200;  break;                            
    case B38400:    baud =  38400;  break;                            
    case B57600:    baud =  57600;  break;                            
    case B115200:   baud = 115200;  break;                            
  107145:	b8 00 84 03 00       	mov    $0x38400,%eax                  <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  10714a:	81 fa 03 10 00 00    	cmp    $0x1003,%edx                   <== NOT EXECUTED
  107150:	74 10                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B9600:     baud =   9600;  break;                            
    case B19200:    baud =  19200;  break;                            
    case B38400:    baud =  38400;  break;                            
    case B57600:    baud =  57600;  break;                            
    case B115200:   baud = 115200;  break;                            
    case B230400:   baud = 230400;  break;                            
  107152:	b8 00 08 07 00       	mov    $0x70800,%eax                  <== NOT EXECUTED
  int termios_baud                                                    
)                                                                     
{                                                                     
  int baud;                                                           
                                                                      
  switch (termios_baud) {                                             
  107157:	81 fa 04 10 00 00    	cmp    $0x1004,%edx                   <== NOT EXECUTED
  10715d:	74 03                	je     107162 <termios_baud_to_number+0xea><== NOT EXECUTED
    case B19200:    baud =  19200;  break;                            
    case B38400:    baud =  38400;  break;                            
    case B57600:    baud =  57600;  break;                            
    case B115200:   baud = 115200;  break;                            
    case B230400:   baud = 230400;  break;                            
    case B460800:   baud = 460800;  break;                            
  10715f:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
    default:        baud =     -1;  break;                            
  }                                                                   
                                                                      
  return baud;                                                        
}                                                                     
  107162:	c9                   	leave                                 <== NOT EXECUTED
  107163:	c3                   	ret                                   <== NOT EXECUTED
                                                                      

0010d50c <timer_create>: int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) {
  10d50c:	55                   	push   %ebp                           
  10d50d:	89 e5                	mov    %esp,%ebp                      
  10d50f:	57                   	push   %edi                           
  10d510:	56                   	push   %esi                           
  10d511:	53                   	push   %ebx                           
  10d512:	83 ec 0c             	sub    $0xc,%esp                      
  10d515:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  10d518:	8b 7d 10             	mov    0x10(%ebp),%edi                
  POSIX_Timer_Control *ptimer;                                        
                                                                      
  if ( clock_id != CLOCK_REALTIME )                                   
  10d51b:	83 7d 08 01          	cmpl   $0x1,0x8(%ebp)                 
  10d51f:	75 1d                	jne    10d53e <timer_create+0x32>     
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !timerid )                                                     
  10d521:	85 ff                	test   %edi,%edi                      
  10d523:	74 19                	je     10d53e <timer_create+0x32>     
 /*                                                                   
  *  The data of the structure evp are checked in order to verify if they
  *  are coherent.                                                    
  */                                                                  
                                                                      
  if (evp != NULL) {                                                  
  10d525:	85 f6                	test   %esi,%esi                      
  10d527:	74 22                	je     10d54b <timer_create+0x3f>     
    /* The structure has data */                                      
    if ( ( evp->sigev_notify != SIGEV_NONE ) &&                       
  10d529:	8b 06                	mov    (%esi),%eax                    
  10d52b:	48                   	dec    %eax                           
  10d52c:	83 f8 01             	cmp    $0x1,%eax                      
  10d52f:	77 0d                	ja     10d53e <timer_create+0x32>     <== NEVER TAKEN
         ( 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 )                                         
  10d531:	8b 46 04             	mov    0x4(%esi),%eax                 
  10d534:	85 c0                	test   %eax,%eax                      
  10d536:	74 06                	je     10d53e <timer_create+0x32>     <== NEVER TAKEN
       rtems_set_errno_and_return_minus_one( EINVAL );                
                                                                      
     if ( !is_valid_signo(evp->sigev_signo) )                         
  10d538:	48                   	dec    %eax                           
  10d539:	83 f8 1f             	cmp    $0x1f,%eax                     
  10d53c:	76 0d                	jbe    10d54b <timer_create+0x3f>     <== ALWAYS TAKEN
       rtems_set_errno_and_return_minus_one( EINVAL );                
  10d53e:	e8 c9 6e 00 00       	call   11440c <__errno>               
  10d543:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10d549:	eb 31                	jmp    10d57c <timer_create+0x70>     
                                                                      
/**                                                                   
 *  This routine walks the heap and tots up the free and allocated    
 *  sizes.                                                            
 *                                                                    
 *  @param[in] the_heap pointer to heap header                        
  10d54b:	a1 58 63 12 00       	mov    0x126358,%eax                  
  10d550:	40                   	inc    %eax                           
  10d551:	a3 58 63 12 00       	mov    %eax,0x126358                  
#ifdef __cplusplus                                                    
extern "C" {                                                          
#endif                                                                
                                                                      
/**                                                                   
 *  This routine initializes @a the_heap record to manage the         
  10d556:	83 ec 0c             	sub    $0xc,%esp                      
  10d559:	68 88 66 12 00       	push   $0x126688                      
  10d55e:	e8 81 1b 00 00       	call   10f0e4 <_Objects_Allocate>     
  10d563:	89 c3                	mov    %eax,%ebx                      
                                                                      
  /*                                                                  
   *  Allocate a timer                                                
   */                                                                 
  ptimer = _POSIX_Timer_Allocate();                                   
  if ( !ptimer ) {                                                    
  10d565:	83 c4 10             	add    $0x10,%esp                     
  10d568:	85 c0                	test   %eax,%eax                      
  10d56a:	75 18                	jne    10d584 <timer_create+0x78>     
    _Thread_Enable_dispatch();                                        
  10d56c:	e8 c3 27 00 00       	call   10fd34 <_Thread_Enable_dispatch>
    rtems_set_errno_and_return_minus_one( EAGAIN );                   
  10d571:	e8 96 6e 00 00       	call   11440c <__errno>               
  10d576:	c7 00 0b 00 00 00    	movl   $0xb,(%eax)                    
  10d57c:	83 c8 ff             	or     $0xffffffff,%eax               
  10d57f:	e9 81 00 00 00       	jmp    10d605 <timer_create+0xf9>     
  }                                                                   
                                                                      
  /* The data of the created timer are stored to use them later */    
                                                                      
  ptimer->state     = POSIX_TIMER_STATE_CREATE_NEW;                   
  10d584:	c6 40 3c 02          	movb   $0x2,0x3c(%eax)                
  ptimer->thread_id = _Thread_Executing->Object.id;                   
  10d588:	a1 18 64 12 00       	mov    0x126418,%eax                  
  10d58d:	8b 40 08             	mov    0x8(%eax),%eax                 
  10d590:	89 43 38             	mov    %eax,0x38(%ebx)                
                                                                      
  if ( evp != NULL ) {                                                
  10d593:	85 f6                	test   %esi,%esi                      
  10d595:	74 11                	je     10d5a8 <timer_create+0x9c>     
    ptimer->inf.sigev_notify = evp->sigev_notify;                     
  10d597:	8b 06                	mov    (%esi),%eax                    
  10d599:	89 43 40             	mov    %eax,0x40(%ebx)                
    ptimer->inf.sigev_signo  = evp->sigev_signo;                      
  10d59c:	8b 46 04             	mov    0x4(%esi),%eax                 
  10d59f:	89 43 44             	mov    %eax,0x44(%ebx)                
    ptimer->inf.sigev_value  = evp->sigev_value;                      
  10d5a2:	8b 46 08             	mov    0x8(%esi),%eax                 
  10d5a5:	89 43 48             	mov    %eax,0x48(%ebx)                
  }                                                                   
                                                                      
  ptimer->overrun  = 0;                                               
  10d5a8:	c7 43 68 00 00 00 00 	movl   $0x0,0x68(%ebx)                
  ptimer->timer_data.it_value.tv_sec     = 0;                         
  10d5af:	c7 43 5c 00 00 00 00 	movl   $0x0,0x5c(%ebx)                
  ptimer->timer_data.it_value.tv_nsec    = 0;                         
  10d5b6:	c7 43 60 00 00 00 00 	movl   $0x0,0x60(%ebx)                
  ptimer->timer_data.it_interval.tv_sec  = 0;                         
  10d5bd:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)                
  ptimer->timer_data.it_interval.tv_nsec = 0;                         
  10d5c4:	c7 43 58 00 00 00 00 	movl   $0x0,0x58(%ebx)                
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  10d5cb:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)                
 *  @param[in] the_heap is the heap to operate upon                   
  10d5d2:	c7 43 2c 00 00 00 00 	movl   $0x0,0x2c(%ebx)                
 *  @param[in] starting_address is the starting address of the memory for
  10d5d9:	c7 43 30 00 00 00 00 	movl   $0x0,0x30(%ebx)                
 *         the heap                                                   
  10d5e0:	c7 43 34 00 00 00 00 	movl   $0x0,0x34(%ebx)                
  10d5e7:	8b 4b 08             	mov    0x8(%ebx),%ecx                 
  10d5ea:	0f b7 d1             	movzwl %cx,%edx                       
  10d5ed:	a1 a4 66 12 00       	mov    0x1266a4,%eax                  
  10d5f2:	89 1c 90             	mov    %ebx,(%eax,%edx,4)             
  10d5f5:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)                 
                                                                      
  _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );              
  _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);   
                                                                      
  *timerid  = ptimer->Object.id;                                      
  10d5fc:	89 0f                	mov    %ecx,(%edi)                    
  _Thread_Enable_dispatch();                                          
  10d5fe:	e8 31 27 00 00       	call   10fd34 <_Thread_Enable_dispatch>
  10d603:	31 c0                	xor    %eax,%eax                      
  return 0;                                                           
}                                                                     
  10d605:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10d608:	5b                   	pop    %ebx                           
  10d609:	5e                   	pop    %esi                           
  10d60a:	5f                   	pop    %edi                           
  10d60b:	c9                   	leave                                 
  10d60c:	c3                   	ret                                   
                                                                      

0010a198 <timer_settime>: timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) {
  10a198:	55                   	push   %ebp                           
  10a199:	89 e5                	mov    %esp,%ebp                      
  10a19b:	57                   	push   %edi                           
  10a19c:	56                   	push   %esi                           
  10a19d:	53                   	push   %ebx                           
  10a19e:	83 ec 2c             	sub    $0x2c,%esp                     
  10a1a1:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  Objects_Locations    location;                                      
  bool                 activated;                                     
  uint32_t             initial_period;                                
  struct itimerspec    normalize;                                     
                                                                      
  if ( !value )                                                       
  10a1a4:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)                
  10a1a8:	0f 84 4c 01 00 00    	je     10a2fa <timer_settime+0x162>   <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  /* First, it verifies if the structure "value" is correct */        
  if ( ( value->it_value.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) ||   
  10a1ae:	8b 45 10             	mov    0x10(%ebp),%eax                
  10a1b1:	81 78 0c ff c9 9a 3b 	cmpl   $0x3b9ac9ff,0xc(%eax)          
  10a1b8:	0f 87 3c 01 00 00    	ja     10a2fa <timer_settime+0x162>   
  10a1be:	8b 40 04             	mov    0x4(%eax),%eax                 
  10a1c1:	3d ff c9 9a 3b       	cmp    $0x3b9ac9ff,%eax               
  10a1c6:	0f 87 2e 01 00 00    	ja     10a2fa <timer_settime+0x162>   <== NEVER TAKEN
  10a1cc:	85 c0                	test   %eax,%eax                      
  10a1ce:	0f 88 26 01 00 00    	js     10a2fa <timer_settime+0x162>   <== NEVER TAKEN
       ( value->it_interval.tv_nsec < 0 )) {                          
    /* The number of nanoseconds is not correct */                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {    
  10a1d4:	83 fa 04             	cmp    $0x4,%edx                      
  10a1d7:	74 08                	je     10a1e1 <timer_settime+0x49>    
  10a1d9:	85 d2                	test   %edx,%edx                      
  10a1db:	0f 85 19 01 00 00    	jne    10a2fa <timer_settime+0x162>   
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  normalize = *value;                                                 
  10a1e1:	8d 7d e0             	lea    -0x20(%ebp),%edi               
  10a1e4:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10a1e9:	8b 75 10             	mov    0x10(%ebp),%esi                
  10a1ec:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
  /* Convert absolute to relative time */                             
  if (flags == TIMER_ABSTIME) {                                       
  10a1ee:	83 fa 04             	cmp    $0x4,%edx                      
  10a1f1:	75 2b                	jne    10a21e <timer_settime+0x86>    
    /* Check for seconds in the past */                               
    if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) )   
  10a1f3:	51                   	push   %ecx                           
  10a1f4:	51                   	push   %ecx                           
  10a1f5:	8d 5d e8             	lea    -0x18(%ebp),%ebx               
  10a1f8:	53                   	push   %ebx                           
  10a1f9:	68 e0 1a 12 00       	push   $0x121ae0                      
  10a1fe:	e8 4d 31 00 00       	call   10d350 <_Timespec_Greater_than>
  10a203:	83 c4 10             	add    $0x10,%esp                     
  10a206:	84 c0                	test   %al,%al                        
  10a208:	0f 85 ec 00 00 00    	jne    10a2fa <timer_settime+0x162>   
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value );
  10a20e:	52                   	push   %edx                           
  10a20f:	53                   	push   %ebx                           
  10a210:	53                   	push   %ebx                           
  10a211:	68 e0 1a 12 00       	push   $0x121ae0                      
  10a216:	e8 5d 31 00 00       	call   10d378 <_Timespec_Subtract>    
  10a21b:	83 c4 10             	add    $0x10,%esp                     
  10a21e:	50                   	push   %eax                           
  10a21f:	8d 45 f0             	lea    -0x10(%ebp),%eax               
  10a222:	50                   	push   %eax                           
  10a223:	ff 75 08             	pushl  0x8(%ebp)                      
  10a226:	68 80 1d 12 00       	push   $0x121d80                      
  10a22b:	e8 dc 1d 00 00       	call   10c00c <_Objects_Get>          
  10a230:	89 c3                	mov    %eax,%ebx                      
   * something with the structure of times of the timer: to stop, start
   * or start it again                                                
   */                                                                 
                                                                      
  ptimer = _POSIX_Timer_Get( timerid, &location );                    
  switch ( location ) {                                               
  10a232:	83 c4 10             	add    $0x10,%esp                     
  10a235:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)               
  10a239:	0f 85 bb 00 00 00    	jne    10a2fa <timer_settime+0x162>   <== NEVER TAKEN
                                                                      
    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 ) {
  10a23f:	83 7d e8 00          	cmpl   $0x0,-0x18(%ebp)               
  10a243:	75 3b                	jne    10a280 <timer_settime+0xe8>    
  10a245:	83 7d ec 00          	cmpl   $0x0,-0x14(%ebp)               
  10a249:	75 35                	jne    10a280 <timer_settime+0xe8>    <== NEVER TAKEN
         /* Stop the timer */                                         
         (void) _Watchdog_Remove( &ptimer->Timer );                   
  10a24b:	83 ec 0c             	sub    $0xc,%esp                      
  10a24e:	8d 40 10             	lea    0x10(%eax),%eax                
  10a251:	50                   	push   %eax                           
  10a252:	e8 0d 35 00 00       	call   10d764 <_Watchdog_Remove>      
         /* The old data of the timer are returned */                 
         if ( ovalue )                                                
  10a257:	83 c4 10             	add    $0x10,%esp                     
  10a25a:	83 7d 14 00          	cmpl   $0x0,0x14(%ebp)                
  10a25e:	74 0d                	je     10a26d <timer_settime+0xd5>    <== ALWAYS TAKEN
           *ovalue = ptimer->timer_data;                              
  10a260:	8d 73 54             	lea    0x54(%ebx),%esi                <== NOT EXECUTED
  10a263:	b9 04 00 00 00       	mov    $0x4,%ecx                      <== NOT EXECUTED
  10a268:	8b 7d 14             	mov    0x14(%ebp),%edi                <== NOT EXECUTED
  10a26b:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       <== NOT EXECUTED
         /* The new data are set */                                   
         ptimer->timer_data = normalize;                              
  10a26d:	8d 7b 54             	lea    0x54(%ebx),%edi                
  10a270:	8d 75 e0             	lea    -0x20(%ebp),%esi               
  10a273:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10a278:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
         /* Indicates that the timer is created and stopped */        
         ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;               
  10a27a:	c6 43 3c 04          	movb   $0x4,0x3c(%ebx)                
  10a27e:	eb 35                	jmp    10a2b5 <timer_settime+0x11d>   
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
       }                                                              
                                                                      
       /* Convert from seconds and nanoseconds to ticks */            
       ptimer->ticks  = _Timespec_To_ticks( &value->it_interval );    
  10a280:	83 ec 0c             	sub    $0xc,%esp                      
  10a283:	ff 75 10             	pushl  0x10(%ebp)                     
  10a286:	e8 25 31 00 00       	call   10d3b0 <_Timespec_To_ticks>    
  10a28b:	89 43 64             	mov    %eax,0x64(%ebx)                
       initial_period = _Timespec_To_ticks( &normalize.it_value );    
  10a28e:	8d 45 e8             	lea    -0x18(%ebp),%eax               
  10a291:	89 04 24             	mov    %eax,(%esp)                    
  10a294:	e8 17 31 00 00       	call   10d3b0 <_Timespec_To_ticks>    
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
  10a299:	89 1c 24             	mov    %ebx,(%esp)                    
  10a29c:	68 10 a3 10 00       	push   $0x10a310                      
  10a2a1:	ff 73 08             	pushl  0x8(%ebx)                      
  10a2a4:	50                   	push   %eax                           
  10a2a5:	8d 43 10             	lea    0x10(%ebx),%eax                
  10a2a8:	50                   	push   %eax                           
  10a2a9:	e8 5a 52 00 00       	call   10f508 <_POSIX_Timer_Insert_helper>
         initial_period,                                              
         ptimer->Object.id,                                           
         _POSIX_Timer_TSR,                                            
         ptimer                                                       
       );                                                             
       if ( !activated ) {                                            
  10a2ae:	83 c4 20             	add    $0x20,%esp                     
  10a2b1:	84 c0                	test   %al,%al                        
  10a2b3:	75 09                	jne    10a2be <timer_settime+0x126>   <== ALWAYS TAKEN
         _Thread_Enable_dispatch();                                   
  10a2b5:	e8 12 25 00 00       	call   10c7cc <_Thread_Enable_dispatch>
  10a2ba:	31 c0                	xor    %eax,%eax                      
  10a2bc:	eb 4a                	jmp    10a308 <timer_settime+0x170>   
                                                                      
       /*                                                             
        * The timer has been started and is running.  So we return the
        * old ones in "ovalue"                                        
        */                                                            
       if ( ovalue )                                                  
  10a2be:	83 7d 14 00          	cmpl   $0x0,0x14(%ebp)                
  10a2c2:	74 0d                	je     10a2d1 <timer_settime+0x139>   
         *ovalue = ptimer->timer_data;                                
  10a2c4:	8d 73 54             	lea    0x54(%ebx),%esi                
  10a2c7:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10a2cc:	8b 7d 14             	mov    0x14(%ebp),%edi                
  10a2cf:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
       ptimer->timer_data = normalize;                                
  10a2d1:	8d 7b 54             	lea    0x54(%ebx),%edi                
  10a2d4:	8d 75 e0             	lea    -0x20(%ebp),%esi               
  10a2d7:	b9 04 00 00 00       	mov    $0x4,%ecx                      
  10a2dc:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)       
                                                                      
       /* Indicate that the time is running */                        
       ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                  
  10a2de:	c6 43 3c 03          	movb   $0x3,0x3c(%ebx)                
       _TOD_Get( &ptimer->time );                                     
  10a2e2:	83 ec 0c             	sub    $0xc,%esp                      
  10a2e5:	8d 43 6c             	lea    0x6c(%ebx),%eax                
  10a2e8:	50                   	push   %eax                           
  10a2e9:	e8 8e 15 00 00       	call   10b87c <_TOD_Get>              
       _Thread_Enable_dispatch();                                     
  10a2ee:	e8 d9 24 00 00       	call   10c7cc <_Thread_Enable_dispatch>
  10a2f3:	31 c0                	xor    %eax,%eax                      
  10a2f5:	83 c4 10             	add    $0x10,%esp                     
  10a2f8:	eb 0e                	jmp    10a308 <timer_settime+0x170>   
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
  10a2fa:	e8 71 69 00 00       	call   110c70 <__errno>               
  10a2ff:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   
  10a305:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  10a308:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  10a30b:	5b                   	pop    %ebx                           
  10a30c:	5e                   	pop    %esi                           
  10a30d:	5f                   	pop    %edi                           
  10a30e:	c9                   	leave                                 
  10a30f:	c3                   	ret                                   
                                                                      

00108da8 <ualarm>: useconds_t ualarm( useconds_t useconds, useconds_t interval ) {
  108da8:	55                   	push   %ebp                           
  108da9:	89 e5                	mov    %esp,%ebp                      
  108dab:	56                   	push   %esi                           
  108dac:	53                   	push   %ebx                           
  108dad:	83 ec 20             	sub    $0x20,%esp                     
                                                                      
  /*                                                                  
   *  Initialize the timer used to implement alarm().                 
   */                                                                 
                                                                      
  if ( !the_timer->routine ) {                                        
  108db0:	83 3d ec fe 11 00 00 	cmpl   $0x0,0x11feec                  
  108db7:	75 2c                	jne    108de5 <ualarm+0x3d>           
 *  This routine initializes @a the_heap record to manage the         
 *  contiguous heap of @a size bytes which starts at @a starting_address.
 *  Blocks of memory are allocated from the heap in multiples of      
 *  @a page_size byte units. If @a page_size is 0 or is not multiple of
 *  CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
 *                                                                    
  108db9:	c7 05 d8 fe 11 00 00 	movl   $0x0,0x11fed8                  
  108dc0:	00 00 00                                                    
 *  @param[in] the_heap is the heap to operate upon                   
  108dc3:	c7 05 ec fe 11 00 88 	movl   $0x108e88,0x11feec             
  108dca:	8e 10 00                                                    
 *  @param[in] starting_address is the starting address of the memory for
  108dcd:	c7 05 f0 fe 11 00 00 	movl   $0x0,0x11fef0                  
  108dd4:	00 00 00                                                    
 *         the heap                                                   
  108dd7:	c7 05 f4 fe 11 00 00 	movl   $0x0,0x11fef4                  
  108dde:	00 00 00                                                    
  108de1:	31 f6                	xor    %esi,%esi                      
  108de3:	eb 4f                	jmp    108e34 <ualarm+0x8c>           
    _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
  } else {                                                            
    switch ( _Watchdog_Remove( the_timer ) ) {                        
  108de5:	83 ec 0c             	sub    $0xc,%esp                      
  108de8:	68 d0 fe 11 00       	push   $0x11fed0                      
  108ded:	e8 16 35 00 00       	call   10c308 <_Watchdog_Remove>      
  108df2:	83 c4 10             	add    $0x10,%esp                     
  108df5:	83 e8 02             	sub    $0x2,%eax                      
  108df8:	31 f6                	xor    %esi,%esi                      
  108dfa:	83 f8 01             	cmp    $0x1,%eax                      
  108dfd:	77 35                	ja     108e34 <ualarm+0x8c>           <== NEVER TAKEN
         *  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);      
  108dff:	a1 e4 fe 11 00       	mov    0x11fee4,%eax                  
  108e04:	03 05 dc fe 11 00    	add    0x11fedc,%eax                  
        /* remaining is now in ticks */                               
                                                                      
        _Timespec_From_ticks( ticks, &tp );                           
  108e0a:	51                   	push   %ecx                           
  108e0b:	51                   	push   %ecx                           
  108e0c:	8d 55 f0             	lea    -0x10(%ebp),%edx               
  108e0f:	52                   	push   %edx                           
  108e10:	2b 05 e8 fe 11 00    	sub    0x11fee8,%eax                  
  108e16:	50                   	push   %eax                           
  108e17:	e8 a4 30 00 00       	call   10bec0 <_Timespec_From_ticks>  
        remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;         
  108e1c:	69 4d f0 40 42 0f 00 	imul   $0xf4240,-0x10(%ebp),%ecx      
        remaining += tp.tv_nsec / 1000;                               
  108e23:	8b 45 f4             	mov    -0xc(%ebp),%eax                
  108e26:	bb e8 03 00 00       	mov    $0x3e8,%ebx                    
  108e2b:	99                   	cltd                                  
  108e2c:	f7 fb                	idiv   %ebx                           
  108e2e:	8d 34 08             	lea    (%eax,%ecx,1),%esi             
  108e31:	83 c4 10             	add    $0x10,%esp                     
  /*                                                                  
   *  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 ) {                                                   
  108e34:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)                 
  108e38:	74 45                	je     108e7f <ualarm+0xd7>           
    Watchdog_Interval ticks;                                          
                                                                      
    tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;               
  108e3a:	b9 40 42 0f 00       	mov    $0xf4240,%ecx                  
  108e3f:	8b 45 08             	mov    0x8(%ebp),%eax                 
  108e42:	31 d2                	xor    %edx,%edx                      
  108e44:	f7 f1                	div    %ecx                           
  108e46:	89 45 f0             	mov    %eax,-0x10(%ebp)               
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
  108e49:	69 d2 e8 03 00 00    	imul   $0x3e8,%edx,%edx               
  108e4f:	89 55 f4             	mov    %edx,-0xc(%ebp)                
    ticks = _Timespec_To_ticks( &tp );                                
  108e52:	83 ec 0c             	sub    $0xc,%esp                      
  108e55:	8d 5d f0             	lea    -0x10(%ebp),%ebx               
  108e58:	53                   	push   %ebx                           
  108e59:	e8 c6 30 00 00       	call   10bf24 <_Timespec_To_ticks>    
    if ( ticks == 0 )                                                 
      ticks = 1;                                                      
                                                                      
    _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );   
  108e5e:	89 1c 24             	mov    %ebx,(%esp)                    
  108e61:	e8 be 30 00 00       	call   10bf24 <_Timespec_To_ticks>    
 *  @param[in] size points to a user area to return the size in       
 *  @return TRUE if successfully able to determine the size, FALSE otherwise
 *  @return *size filled in with the size of the user area for this block
 */                                                                   
bool _Protected_heap_Get_block_size(                                  
  Heap_Control        *the_heap,                                      
  108e66:	a3 dc fe 11 00       	mov    %eax,0x11fedc                  
  void                *starting_address,                              
  size_t              *size                                           
  108e6b:	58                   	pop    %eax                           
  108e6c:	5a                   	pop    %edx                           
  108e6d:	68 d0 fe 11 00       	push   $0x11fed0                      
  108e72:	68 90 00 12 00       	push   $0x120090                      
  108e77:	e8 74 33 00 00       	call   10c1f0 <_Watchdog_Insert>      
  108e7c:	83 c4 10             	add    $0x10,%esp                     
  }                                                                   
                                                                      
  return remaining;                                                   
}                                                                     
  108e7f:	89 f0                	mov    %esi,%eax                      
  108e81:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  108e84:	5b                   	pop    %ebx                           
  108e85:	5e                   	pop    %esi                           
  108e86:	c9                   	leave                                 
  108e87:	c3                   	ret                                   
                                                                      

0010b110 <unlink>: #include <rtems/seterr.h> int unlink( const char *path ) {
  10b110:	55                   	push   %ebp                           
  10b111:	89 e5                	mov    %esp,%ebp                      
  10b113:	56                   	push   %esi                           
  10b114:	53                   	push   %ebx                           
  10b115:	83 ec 10             	sub    $0x10,%esp                     
                                                                      
  /*                                                                  
   * Get the node to be unlinked.                                     
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path( path, 0, &loc, false );    
  10b118:	6a 00                	push   $0x0                           
  10b11a:	8d 5d e8             	lea    -0x18(%ebp),%ebx               
  10b11d:	53                   	push   %ebx                           
  10b11e:	6a 00                	push   $0x0                           
  10b120:	ff 75 08             	pushl  0x8(%ebp)                      
  10b123:	e8 56 d1 ff ff       	call   10827e <rtems_filesystem_evaluate_path>
  if ( result != 0 )                                                  
  10b128:	83 c4 10             	add    $0x10,%esp                     
  10b12b:	85 c0                	test   %eax,%eax                      
  10b12d:	0f 85 d9 00 00 00    	jne    10b20c <unlink+0xfc>           
     return -1;                                                       
                                                                      
  result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc );
  10b133:	50                   	push   %eax                           
  10b134:	50                   	push   %eax                           
  10b135:	53                   	push   %ebx                           
  10b136:	6a 02                	push   $0x2                           
  10b138:	e8 cb d0 ff ff       	call   108208 <rtems_filesystem_evaluate_parent>
  if (result != 0 && errno != ENOTSUP) {                              
  10b13d:	83 c4 10             	add    $0x10,%esp                     
  10b140:	85 c0                	test   %eax,%eax                      
  10b142:	74 31                	je     10b175 <unlink+0x65>           <== ALWAYS TAKEN
  10b144:	e8 af 71 00 00       	call   1122f8 <__errno>               <== NOT EXECUTED
  10b149:	81 38 86 00 00 00    	cmpl   $0x86,(%eax)                   <== NOT EXECUTED
  10b14f:	74 24                	je     10b175 <unlink+0x65>           <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
  10b151:	8b 45 f0             	mov    -0x10(%ebp),%eax               <== NOT EXECUTED
  10b154:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10b156:	0f 84 b0 00 00 00    	je     10b20c <unlink+0xfc>           <== NOT EXECUTED
  10b15c:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  10b15f:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10b161:	0f 84 a5 00 00 00    	je     10b20c <unlink+0xfc>           <== NOT EXECUTED
  10b167:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10b16a:	53                   	push   %ebx                           <== NOT EXECUTED
  10b16b:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10b16d:	83 cb ff             	or     $0xffffffff,%ebx               <== NOT EXECUTED
  10b170:	e9 92 00 00 00       	jmp    10b207 <unlink+0xf7>           <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if ( !loc.ops->node_type_h ) {                                      
  10b175:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10b178:	8b 50 10             	mov    0x10(%eax),%edx                
  10b17b:	85 d2                	test   %edx,%edx                      
  10b17d:	75 12                	jne    10b191 <unlink+0x81>           <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  10b17f:	8b 50 1c             	mov    0x1c(%eax),%edx                <== NOT EXECUTED
  10b182:	85 d2                	test   %edx,%edx                      <== NOT EXECUTED
  10b184:	74 55                	je     10b1db <unlink+0xcb>           <== NOT EXECUTED
  10b186:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10b189:	8d 45 e8             	lea    -0x18(%ebp),%eax               <== NOT EXECUTED
  10b18c:	50                   	push   %eax                           <== NOT EXECUTED
  10b18d:	ff d2                	call   *%edx                          <== NOT EXECUTED
  10b18f:	eb 47                	jmp    10b1d8 <unlink+0xc8>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
  10b191:	83 ec 0c             	sub    $0xc,%esp                      
  10b194:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  10b197:	56                   	push   %esi                           
  10b198:	ff d2                	call   *%edx                          
  10b19a:	83 c4 10             	add    $0x10,%esp                     
  10b19d:	48                   	dec    %eax                           
  10b19e:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10b1a1:	75 21                	jne    10b1c4 <unlink+0xb4>           
    rtems_filesystem_freenode( &loc );                                
  10b1a3:	85 c0                	test   %eax,%eax                      
  10b1a5:	74 10                	je     10b1b7 <unlink+0xa7>           <== NEVER TAKEN
  10b1a7:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10b1aa:	85 c0                	test   %eax,%eax                      
  10b1ac:	74 09                	je     10b1b7 <unlink+0xa7>           <== NEVER TAKEN
  10b1ae:	83 ec 0c             	sub    $0xc,%esp                      
  10b1b1:	56                   	push   %esi                           
  10b1b2:	ff d0                	call   *%eax                          
  10b1b4:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( EISDIR );                   
  10b1b7:	e8 3c 71 00 00       	call   1122f8 <__errno>               
  10b1bc:	c7 00 15 00 00 00    	movl   $0x15,(%eax)                   
  10b1c2:	eb 48                	jmp    10b20c <unlink+0xfc>           
  }                                                                   
                                                                      
  if ( !loc.ops->unlink_h ) {                                         
  10b1c4:	8b 50 0c             	mov    0xc(%eax),%edx                 
  10b1c7:	85 d2                	test   %edx,%edx                      
  10b1c9:	75 1d                	jne    10b1e8 <unlink+0xd8>           <== ALWAYS TAKEN
    rtems_filesystem_freenode( &loc );                                
  10b1cb:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  10b1ce:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10b1d0:	74 09                	je     10b1db <unlink+0xcb>           <== NOT EXECUTED
  10b1d2:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10b1d5:	56                   	push   %esi                           <== NOT EXECUTED
  10b1d6:	ff d0                	call   *%eax                          <== NOT EXECUTED
  10b1d8:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10b1db:	e8 18 71 00 00       	call   1122f8 <__errno>               <== NOT EXECUTED
  10b1e0:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10b1e6:	eb 24                	jmp    10b20c <unlink+0xfc>           <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*loc.ops->unlink_h)( &loc );                              
  10b1e8:	83 ec 0c             	sub    $0xc,%esp                      
  10b1eb:	56                   	push   %esi                           
  10b1ec:	ff d2                	call   *%edx                          
  10b1ee:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  10b1f0:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10b1f3:	83 c4 10             	add    $0x10,%esp                     
  10b1f6:	85 c0                	test   %eax,%eax                      
  10b1f8:	74 15                	je     10b20f <unlink+0xff>           <== NEVER TAKEN
  10b1fa:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10b1fd:	85 c0                	test   %eax,%eax                      
  10b1ff:	74 0e                	je     10b20f <unlink+0xff>           <== NEVER TAKEN
  10b201:	83 ec 0c             	sub    $0xc,%esp                      
  10b204:	56                   	push   %esi                           
  10b205:	ff d0                	call   *%eax                          
  10b207:	83 c4 10             	add    $0x10,%esp                     
  10b20a:	eb 03                	jmp    10b20f <unlink+0xff>           
  10b20c:	83 cb ff             	or     $0xffffffff,%ebx               
                                                                      
  return result;                                                      
}                                                                     
  10b20f:	89 d8                	mov    %ebx,%eax                      
  10b211:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10b214:	5b                   	pop    %ebx                           
  10b215:	5e                   	pop    %esi                           
  10b216:	c9                   	leave                                 
  10b217:	c3                   	ret                                   
                                                                      

0010a45a <unmount>: */ int unmount( const char *path ) {
  10a45a:	55                   	push   %ebp                           
  10a45b:	89 e5                	mov    %esp,%ebp                      
  10a45d:	56                   	push   %esi                           
  10a45e:	53                   	push   %ebx                           
  10a45f:	83 ec 10             	sub    $0x10,%esp                     
   *    The root node of the mounted filesytem.                       
   *    The node for the directory that the fileystem is mounted on.  
   *    The mount entry that is being refered to.                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_evaluate_path( path, 0x0, &loc, true ) )      
  10a462:	6a 01                	push   $0x1                           
  10a464:	8d 75 e8             	lea    -0x18(%ebp),%esi               
  10a467:	56                   	push   %esi                           
  10a468:	6a 00                	push   $0x0                           
  10a46a:	ff 75 08             	pushl  0x8(%ebp)                      
  10a46d:	e8 c0 d0 ff ff       	call   107532 <rtems_filesystem_evaluate_path>
  10a472:	83 c4 10             	add    $0x10,%esp                     
  10a475:	85 c0                	test   %eax,%eax                      
  10a477:	0f 85 11 01 00 00    	jne    10a58e <unmount+0x134>         
    return -1;                                                        
                                                                      
  mt_entry     = loc.mt_entry;                                        
  10a47d:	8b 5d f4             	mov    -0xc(%ebp),%ebx                
                                                                      
  /*                                                                  
   * Verify this is the root node for the file system to be unmounted.
   */                                                                 
                                                                      
  if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){           
  10a480:	8b 43 18             	mov    0x18(%ebx),%eax                
  10a483:	3b 45 e8             	cmp    -0x18(%ebp),%eax               
  10a486:	8b 45 f0             	mov    -0x10(%ebp),%eax               
  10a489:	74 24                	je     10a4af <unmount+0x55>          
    rtems_filesystem_freenode( &loc );                                
  10a48b:	85 c0                	test   %eax,%eax                      
  10a48d:	74 10                	je     10a49f <unmount+0x45>          <== NEVER TAKEN
  10a48f:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10a492:	85 c0                	test   %eax,%eax                      
  10a494:	74 09                	je     10a49f <unmount+0x45>          <== NEVER TAKEN
  10a496:	83 ec 0c             	sub    $0xc,%esp                      
  10a499:	56                   	push   %esi                           
  10a49a:	ff d0                	call   *%eax                          
  10a49c:	83 c4 10             	add    $0x10,%esp                     
    rtems_set_errno_and_return_minus_one( EACCES );                   
  10a49f:	e8 0c 71 00 00       	call   1115b0 <__errno>               
  10a4a4:	c7 00 0d 00 00 00    	movl   $0xd,(%eax)                    
  10a4aa:	e9 df 00 00 00       	jmp    10a58e <unmount+0x134>         
                                                                      
  /*                                                                  
   * Free the loc node and just use the nodes from the mt_entry .     
   */                                                                 
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  10a4af:	85 c0                	test   %eax,%eax                      
  10a4b1:	74 10                	je     10a4c3 <unmount+0x69>          <== NEVER TAKEN
  10a4b3:	8b 40 1c             	mov    0x1c(%eax),%eax                
  10a4b6:	85 c0                	test   %eax,%eax                      
  10a4b8:	74 09                	je     10a4c3 <unmount+0x69>          <== NEVER TAKEN
  10a4ba:	83 ec 0c             	sub    $0xc,%esp                      
  10a4bd:	56                   	push   %esi                           
  10a4be:	ff d0                	call   *%eax                          
  10a4c0:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  /*                                                                  
   * Verify Unmount is supported by both filesystems.                 
   */                                                                 
                                                                      
  if ( !fs_mount_loc->ops->unmount_h )                                
  10a4c3:	8b 43 10             	mov    0x10(%ebx),%eax                
  10a4c6:	83 78 28 00          	cmpl   $0x0,0x28(%eax)                
  10a4ca:	74 09                	je     10a4d5 <unmount+0x7b>          <== NEVER TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  if ( !fs_root_loc->ops->fsunmount_me_h )                            
  10a4cc:	8b 43 20             	mov    0x20(%ebx),%eax                
  10a4cf:	83 78 2c 00          	cmpl   $0x0,0x2c(%eax)                
  10a4d3:	75 10                	jne    10a4e5 <unmount+0x8b>          <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  10a4d5:	e8 d6 70 00 00       	call   1115b0 <__errno>               <== NOT EXECUTED
  10a4da:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  10a4e0:	e9 a9 00 00 00       	jmp    10a58e <unmount+0x134>         <== NOT EXECUTED
   *        that made the current node thread based instead           
   *        of system based?  I thought it was but it doesn't         
   *        look like it in this version.                             
   */                                                                 
                                                                      
  if ( rtems_filesystem_current.mt_entry == mt_entry )                
  10a4e5:	a1 4c 09 12 00       	mov    0x12094c,%eax                  
  10a4ea:	39 58 10             	cmp    %ebx,0x10(%eax)                
  10a4ed:	74 1f                	je     10a50e <unmount+0xb4>          
  /*                                                                  
   * Search the mount table for any mount entries referencing this    
   * mount entry.                                                     
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
  10a4ef:	8b 15 94 29 12 00    	mov    0x122994,%edx                  
  10a4f5:	eb 0a                	jmp    10a501 <unmount+0xa7>          
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
        the_node = the_node->next ) {                                 
     the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node;
     if (the_mount_entry->mt_point_node.mt_entry  == fs_root_loc->mt_entry ) {
  10a4f7:	8b 42 14             	mov    0x14(%edx),%eax                
  10a4fa:	3b 43 24             	cmp    0x24(%ebx),%eax                
  10a4fd:	74 0f                	je     10a50e <unmount+0xb4>          
   * mount entry.                                                     
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
        the_node = the_node->next ) {                                 
  10a4ff:	8b 12                	mov    (%edx),%edx                    
   * Search the mount table for any mount entries referencing this    
   * mount entry.                                                     
   */                                                                 
                                                                      
  for ( the_node = rtems_filesystem_mount_table_control.first;        
        !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
  10a501:	81 fa 98 29 12 00    	cmp    $0x122998,%edx                 
  10a507:	75 ee                	jne    10a4f7 <unmount+0x9d>          
  10a509:	e9 8a 00 00 00       	jmp    10a598 <unmount+0x13e>         
   *  descriptors that are currently active and reference nodes in the
   *  file system that we are trying to unmount                       
   */                                                                 
                                                                      
  if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )             
    rtems_set_errno_and_return_minus_one( EBUSY );                    
  10a50e:	e8 9d 70 00 00       	call   1115b0 <__errno>               
  10a513:	c7 00 10 00 00 00    	movl   $0x10,(%eax)                   
  10a519:	eb 73                	jmp    10a58e <unmount+0x134>         
   * Allow the file system being unmounted on to do its cleanup.      
   * If it fails it will set the errno to the approprate value        
   * and the fileystem will not be modified.                          
   */                                                                 
                                                                      
  if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )             
  10a51b:	83 ec 0c             	sub    $0xc,%esp                      
  10a51e:	8b 43 10             	mov    0x10(%ebx),%eax                
  10a521:	53                   	push   %ebx                           
  10a522:	ff 50 28             	call   *0x28(%eax)                    
  10a525:	83 c4 10             	add    $0x10,%esp                     
  10a528:	85 c0                	test   %eax,%eax                      
  10a52a:	75 62                	jne    10a58e <unmount+0x134>         <== NEVER TAKEN
   *  NOTE:  Fatal error is called in a case which should never happen
   *         This was response was questionable but the best we could 
   *         come up with.                                            
   */                                                                 
                                                                      
  if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){          
  10a52c:	83 ec 0c             	sub    $0xc,%esp                      
  10a52f:	8b 43 20             	mov    0x20(%ebx),%eax                
  10a532:	53                   	push   %ebx                           
  10a533:	ff 50 2c             	call   *0x2c(%eax)                    
  10a536:	83 c4 10             	add    $0x10,%esp                     
  10a539:	85 c0                	test   %eax,%eax                      
  10a53b:	74 1b                	je     10a558 <unmount+0xfe>          <== ALWAYS TAKEN
    if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )             
  10a53d:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10a540:	8b 43 10             	mov    0x10(%ebx),%eax                <== NOT EXECUTED
  10a543:	53                   	push   %ebx                           <== NOT EXECUTED
  10a544:	ff 50 20             	call   *0x20(%eax)                    <== NOT EXECUTED
  10a547:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  10a54a:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  10a54c:	74 40                	je     10a58e <unmount+0x134>         <== NOT EXECUTED
      rtems_fatal_error_occurred( 0 );                                
  10a54e:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  10a551:	6a 00                	push   $0x0                           <== NOT EXECUTED
  10a553:	e8 24 0e 00 00       	call   10b37c <rtems_fatal_error_occurred><== NOT EXECUTED
  10a558:	83 ec 0c             	sub    $0xc,%esp                      
  10a55b:	53                   	push   %ebx                           
  10a55c:	e8 97 11 00 00       	call   10b6f8 <_Chain_Extract>        
  /*                                                                  
   *  Free the memory node that was allocated in mount                
   *  Free the memory associated with the extracted mount table entry.
   */                                                                 
                                                                      
  rtems_filesystem_freenode( fs_mount_loc );                          
  10a561:	8b 43 10             	mov    0x10(%ebx),%eax                
  10a564:	83 c4 10             	add    $0x10,%esp                     
  10a567:	85 c0                	test   %eax,%eax                      
  10a569:	74 13                	je     10a57e <unmount+0x124>         <== NEVER TAKEN
  10a56b:	8b 50 1c             	mov    0x1c(%eax),%edx                
  10a56e:	85 d2                	test   %edx,%edx                      
  10a570:	74 0c                	je     10a57e <unmount+0x124>         <== NEVER TAKEN
  10a572:	83 ec 0c             	sub    $0xc,%esp                      
  10a575:	8d 43 08             	lea    0x8(%ebx),%eax                 
  10a578:	50                   	push   %eax                           
  10a579:	ff d2                	call   *%edx                          
  10a57b:	83 c4 10             	add    $0x10,%esp                     
  free( mt_entry );                                                   
  10a57e:	83 ec 0c             	sub    $0xc,%esp                      
  10a581:	53                   	push   %ebx                           
  10a582:	e8 cd d0 ff ff       	call   107654 <free>                  
  10a587:	31 c0                	xor    %eax,%eax                      
  10a589:	83 c4 10             	add    $0x10,%esp                     
  10a58c:	eb 03                	jmp    10a591 <unmount+0x137>         
                                                                      
  return 0;                                                           
  10a58e:	83 c8 ff             	or     $0xffffffff,%eax               
}                                                                     
  10a591:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  10a594:	5b                   	pop    %ebx                           
  10a595:	5e                   	pop    %esi                           
  10a596:	c9                   	leave                                 
  10a597:	c3                   	ret                                   
   *  Run the file descriptor table to determine if there are any file
   *  descriptors that are currently active and reference nodes in the
   *  file system that we are trying to unmount                       
   */                                                                 
                                                                      
  if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )             
  10a598:	83 ec 0c             	sub    $0xc,%esp                      
  10a59b:	53                   	push   %ebx                           
  10a59c:	e8 bf d2 ff ff       	call   107860 <rtems_libio_is_open_files_in_fs>
  10a5a1:	83 c4 10             	add    $0x10,%esp                     
  10a5a4:	48                   	dec    %eax                           
  10a5a5:	0f 85 70 ff ff ff    	jne    10a51b <unmount+0xc1>          
  10a5ab:	e9 5e ff ff ff       	jmp    10a50e <unmount+0xb4>          
                                                                      

00109dec <utime>: int utime( const char *path, const struct utimbuf *times ) {
  109dec:	55                   	push   %ebp                           
  109ded:	89 e5                	mov    %esp,%ebp                      
  109def:	57                   	push   %edi                           
  109df0:	56                   	push   %esi                           
  109df1:	53                   	push   %ebx                           
  109df2:	83 ec 1c             	sub    $0x1c,%esp                     
  109df5:	8b 7d 0c             	mov    0xc(%ebp),%edi                 
  rtems_filesystem_location_info_t   temp_loc;                        
  int                                result;                          
                                                                      
  if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, true ) )
  109df8:	6a 01                	push   $0x1                           
  109dfa:	8d 75 e4             	lea    -0x1c(%ebp),%esi               
  109dfd:	56                   	push   %esi                           
  109dfe:	6a 00                	push   $0x0                           
  109e00:	ff 75 08             	pushl  0x8(%ebp)                      
  109e03:	e8 86 d1 ff ff       	call   106f8e <rtems_filesystem_evaluate_path>
  109e08:	83 c4 10             	add    $0x10,%esp                     
  109e0b:	83 cb ff             	or     $0xffffffff,%ebx               
  109e0e:	85 c0                	test   %eax,%eax                      
  109e10:	75 4f                	jne    109e61 <utime+0x75>            
    return -1;                                                        
                                                                      
  if ( !temp_loc.ops->utime_h ){                                      
  109e12:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  109e15:	8b 50 30             	mov    0x30(%eax),%edx                
  109e18:	85 d2                	test   %edx,%edx                      
  109e1a:	75 20                	jne    109e3c <utime+0x50>            <== ALWAYS TAKEN
    rtems_filesystem_freenode( &temp_loc );                           
  109e1c:	8b 40 1c             	mov    0x1c(%eax),%eax                <== NOT EXECUTED
  109e1f:	85 c0                	test   %eax,%eax                      <== NOT EXECUTED
  109e21:	74 09                	je     109e2c <utime+0x40>            <== NOT EXECUTED
  109e23:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  109e26:	56                   	push   %esi                           <== NOT EXECUTED
  109e27:	ff d0                	call   *%eax                          <== NOT EXECUTED
  109e29:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  109e2c:	e8 af 71 00 00       	call   110fe0 <__errno>               <== NOT EXECUTED
  109e31:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  109e37:	83 cb ff             	or     $0xffffffff,%ebx               <== NOT EXECUTED
  109e3a:	eb 25                	jmp    109e61 <utime+0x75>            <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
  109e3c:	50                   	push   %eax                           
  109e3d:	ff 77 04             	pushl  0x4(%edi)                      
  109e40:	ff 37                	pushl  (%edi)                         
  109e42:	56                   	push   %esi                           
  109e43:	ff d2                	call   *%edx                          
  109e45:	89 c3                	mov    %eax,%ebx                      
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
  109e47:	8b 45 ec             	mov    -0x14(%ebp),%eax               
  109e4a:	83 c4 10             	add    $0x10,%esp                     
  109e4d:	85 c0                	test   %eax,%eax                      
  109e4f:	74 10                	je     109e61 <utime+0x75>            <== NEVER TAKEN
  109e51:	8b 40 1c             	mov    0x1c(%eax),%eax                
  109e54:	85 c0                	test   %eax,%eax                      
  109e56:	74 09                	je     109e61 <utime+0x75>            <== NEVER TAKEN
  109e58:	83 ec 0c             	sub    $0xc,%esp                      
  109e5b:	56                   	push   %esi                           
  109e5c:	ff d0                	call   *%eax                          
  109e5e:	83 c4 10             	add    $0x10,%esp                     
                                                                      
  return result;                                                      
}                                                                     
  109e61:	89 d8                	mov    %ebx,%eax                      
  109e63:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  109e66:	5b                   	pop    %ebx                           
  109e67:	5e                   	pop    %esi                           
  109e68:	5f                   	pop    %edi                           
  109e69:	c9                   	leave                                 
  109e6a:	c3                   	ret                                   
                                                                      

00106dc4 <vprintk>: */ void vprintk( const char *fmt, va_list ap ) {
  106dc4:	55                   	push   %ebp                           
  106dc5:	89 e5                	mov    %esp,%ebp                      
  106dc7:	57                   	push   %edi                           
  106dc8:	56                   	push   %esi                           
  106dc9:	53                   	push   %ebx                           
  106dca:	83 ec 4c             	sub    $0x4c,%esp                     
  106dcd:	8b 7d 08             	mov    0x8(%ebp),%edi                 
  106dd0:	e9 6d 02 00 00       	jmp    107042 <vprintk+0x27e>         
    base  = 0;                                                        
    sign = 0;                                                         
    width = 0;                                                        
    minus = 0;                                                        
    lead = ' ';                                                       
    if (*fmt == '%') {                                                
  106dd5:	3c 25                	cmp    $0x25,%al                      
  106dd7:	0f 85 54 02 00 00    	jne    107031 <vprintk+0x26d>         
      fmt++;                                                          
  106ddd:	47                   	inc    %edi                           
      if (*fmt == '0' ) {                                             
  106dde:	c7 45 c8 20 00 00 00 	movl   $0x20,-0x38(%ebp)              
  106de5:	80 3f 30             	cmpb   $0x30,(%edi)                   
  106de8:	75 08                	jne    106df2 <vprintk+0x2e>          
        lead = '0';                                                   
        fmt++;                                                        
  106dea:	47                   	inc    %edi                           
  106deb:	c7 45 c8 30 00 00 00 	movl   $0x30,-0x38(%ebp)              
      }                                                               
      if (*fmt == '-' ) {                                             
  106df2:	c7 45 cc 00 00 00 00 	movl   $0x0,-0x34(%ebp)               
  106df9:	80 3f 2d             	cmpb   $0x2d,(%edi)                   
  106dfc:	75 08                	jne    106e06 <vprintk+0x42>          
        minus = 1;                                                    
        fmt++;                                                        
  106dfe:	47                   	inc    %edi                           
  106dff:	c7 45 cc 01 00 00 00 	movl   $0x1,-0x34(%ebp)               
  106e06:	c7 45 c4 00 00 00 00 	movl   $0x0,-0x3c(%ebp)               
  106e0d:	eb 0f                	jmp    106e1e <vprintk+0x5a>          
      }                                                               
      while (*fmt >= '0' && *fmt <= '9' ) {                           
        width *= 10;                                                  
  106e0f:	6b 55 c4 0a          	imul   $0xa,-0x3c(%ebp),%edx          
        width += (*fmt - '0');                                        
  106e13:	0f be c1             	movsbl %cl,%eax                       
  106e16:	8d 44 02 d0          	lea    -0x30(%edx,%eax,1),%eax        
  106e1a:	89 45 c4             	mov    %eax,-0x3c(%ebp)               
        fmt++;                                                        
  106e1d:	47                   	inc    %edi                           
      }                                                               
      if (*fmt == '-' ) {                                             
        minus = 1;                                                    
        fmt++;                                                        
      }                                                               
      while (*fmt >= '0' && *fmt <= '9' ) {                           
  106e1e:	8a 0f                	mov    (%edi),%cl                     
  106e20:	8d 41 d0             	lea    -0x30(%ecx),%eax               
  106e23:	3c 09                	cmp    $0x9,%al                       
  106e25:	76 e8                	jbe    106e0f <vprintk+0x4b>          
        width *= 10;                                                  
        width += (*fmt - '0');                                        
        fmt++;                                                        
      }                                                               
                                                                      
      if ((c = *fmt) == 'l') {                                        
  106e27:	31 d2                	xor    %edx,%edx                      
  106e29:	80 f9 6c             	cmp    $0x6c,%cl                      
  106e2c:	75 08                	jne    106e36 <vprintk+0x72>          
        lflag = 1;                                                    
        c = *++fmt;                                                   
  106e2e:	47                   	inc    %edi                           
  106e2f:	8a 0f                	mov    (%edi),%cl                     
  106e31:	ba 01 00 00 00       	mov    $0x1,%edx                      
      }                                                               
      switch (c) {                                                    
  106e36:	80 f9 64             	cmp    $0x64,%cl                      
  106e39:	74 71                	je     106eac <vprintk+0xe8>          
  106e3b:	7f 38                	jg     106e75 <vprintk+0xb1>          
  106e3d:	80 f9 4f             	cmp    $0x4f,%cl                      
  106e40:	0f 84 32 01 00 00    	je     106f78 <vprintk+0x1b4>         <== NEVER TAKEN
  106e46:	7f 10                	jg     106e58 <vprintk+0x94>          <== NEVER TAKEN
  106e48:	80 f9 44             	cmp    $0x44,%cl                      
  106e4b:	74 5f                	je     106eac <vprintk+0xe8>          <== NEVER TAKEN
  106e4d:	80 f9 49             	cmp    $0x49,%cl                      
  106e50:	0f 85 17 01 00 00    	jne    106f6d <vprintk+0x1a9>         <== ALWAYS TAKEN
  106e56:	eb 54                	jmp    106eac <vprintk+0xe8>          <== NOT EXECUTED
  106e58:	80 f9 58             	cmp    $0x58,%cl                      <== NOT EXECUTED
  106e5b:	0f 84 20 01 00 00    	je     106f81 <vprintk+0x1bd>         <== NOT EXECUTED
  106e61:	80 f9 63             	cmp    $0x63,%cl                      <== NOT EXECUTED
  106e64:	0f 84 e5 00 00 00    	je     106f4f <vprintk+0x18b>         <== NOT EXECUTED
  106e6a:	80 f9 55             	cmp    $0x55,%cl                      <== NOT EXECUTED
  106e6d:	0f 85 fa 00 00 00    	jne    106f6d <vprintk+0x1a9>         <== NOT EXECUTED
  106e73:	eb 3e                	jmp    106eb3 <vprintk+0xef>          <== NOT EXECUTED
  106e75:	80 f9 70             	cmp    $0x70,%cl                      
  106e78:	0f 84 03 01 00 00    	je     106f81 <vprintk+0x1bd>         
  106e7e:	7f 13                	jg     106e93 <vprintk+0xcf>          <== ALWAYS TAKEN
  106e80:	80 f9 69             	cmp    $0x69,%cl                      <== NOT EXECUTED
  106e83:	74 27                	je     106eac <vprintk+0xe8>          <== NOT EXECUTED
  106e85:	80 f9 6f             	cmp    $0x6f,%cl                      <== NOT EXECUTED
  106e88:	0f 85 df 00 00 00    	jne    106f6d <vprintk+0x1a9>         <== NOT EXECUTED
  106e8e:	e9 e5 00 00 00       	jmp    106f78 <vprintk+0x1b4>         <== NOT EXECUTED
  106e93:	80 f9 75             	cmp    $0x75,%cl                      
  106e96:	74 1b                	je     106eb3 <vprintk+0xef>          
  106e98:	80 f9 78             	cmp    $0x78,%cl                      
  106e9b:	0f 84 e0 00 00 00    	je     106f81 <vprintk+0x1bd>         
  106ea1:	80 f9 73             	cmp    $0x73,%cl                      
  106ea4:	0f 85 c3 00 00 00    	jne    106f6d <vprintk+0x1a9>         <== NEVER TAKEN
  106eaa:	eb 13                	jmp    106ebf <vprintk+0xfb>          
  106eac:	b8 01 00 00 00       	mov    $0x1,%eax                      
  106eb1:	eb 02                	jmp    106eb5 <vprintk+0xf1>          
  106eb3:	31 c0                	xor    %eax,%eax                      
  106eb5:	be 0a 00 00 00       	mov    $0xa,%esi                      
  106eba:	e9 c9 00 00 00       	jmp    106f88 <vprintk+0x1c4>         
        case 'p':           base = 16; sign = 0; break;               
        case 's':                                                     
          { int i, len;                                               
            char *s;                                                  
                                                                      
            str = va_arg(ap, char *);                                 
  106ebf:	8b 45 0c             	mov    0xc(%ebp),%eax                 
  106ec2:	83 c0 04             	add    $0x4,%eax                      
  106ec5:	89 45 d0             	mov    %eax,-0x30(%ebp)               
  106ec8:	8b 55 0c             	mov    0xc(%ebp),%edx                 
  106ecb:	8b 12                	mov    (%edx),%edx                    
  106ecd:	89 55 c0             	mov    %edx,-0x40(%ebp)               
  106ed0:	31 f6                	xor    %esi,%esi                      
  106ed2:	eb 01                	jmp    106ed5 <vprintk+0x111>         
                                                                      
            /* calculate length of string */                          
            for ( len=0, s=str ; *s ; len++, s++ )                    
  106ed4:	46                   	inc    %esi                           
  106ed5:	8b 4d c0             	mov    -0x40(%ebp),%ecx               
  106ed8:	80 3c 31 00          	cmpb   $0x0,(%ecx,%esi,1)             
  106edc:	75 f6                	jne    106ed4 <vprintk+0x110>         
              ;                                                       
                                                                      
            /* leading spaces */                                      
            if ( !minus )                                             
  106ede:	89 f3                	mov    %esi,%ebx                      
  106ee0:	83 7d cc 00          	cmpl   $0x0,-0x34(%ebp)               
  106ee4:	74 11                	je     106ef7 <vprintk+0x133>         
  106ee6:	eb 14                	jmp    106efc <vprintk+0x138>         
              for ( i=len ; i<width ; i++ )                           
                BSP_output_char(' ');                                 
  106ee8:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106eeb:	6a 20                	push   $0x20                          <== NOT EXECUTED
  106eed:	ff 15 fc 93 11 00    	call   *0x1193fc                      <== NOT EXECUTED
            for ( len=0, s=str ; *s ; len++, s++ )                    
              ;                                                       
                                                                      
            /* leading spaces */                                      
            if ( !minus )                                             
              for ( i=len ; i<width ; i++ )                           
  106ef3:	43                   	inc    %ebx                           <== NOT EXECUTED
  106ef4:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106ef7:	3b 5d c4             	cmp    -0x3c(%ebp),%ebx               
  106efa:	7c ec                	jl     106ee8 <vprintk+0x124>         <== NEVER TAKEN
                BSP_output_char(' ');                                 
                                                                      
	    /* no width option */                                            
	    if (width == 0) {                                                
  106efc:	83 7d c4 00          	cmpl   $0x0,-0x3c(%ebp)               
  106f00:	75 03                	jne    106f05 <vprintk+0x141>         
  106f02:	89 75 c4             	mov    %esi,-0x3c(%ebp)               
		    width = len;                                                    
	    }                                                                
                                                                      
            /* output the string */                                   
            for ( i=0 ; i<width && *str ; str++ )                     
  106f05:	83 7d c4 00          	cmpl   $0x0,-0x3c(%ebp)               
  106f09:	7e 1e                	jle    106f29 <vprintk+0x165>         <== NEVER TAKEN
  106f0b:	eb 13                	jmp    106f20 <vprintk+0x15c>         
              BSP_output_char(*str);                                  
  106f0d:	83 ec 0c             	sub    $0xc,%esp                      
  106f10:	0f be c0             	movsbl %al,%eax                       
  106f13:	50                   	push   %eax                           
  106f14:	ff 15 fc 93 11 00    	call   *0x1193fc                      
	    if (width == 0) {                                                
		    width = len;                                                    
	    }                                                                
                                                                      
            /* output the string */                                   
            for ( i=0 ; i<width && *str ; str++ )                     
  106f1a:	ff 45 c0             	incl   -0x40(%ebp)                    
  106f1d:	83 c4 10             	add    $0x10,%esp                     
  106f20:	8b 55 c0             	mov    -0x40(%ebp),%edx               
  106f23:	8a 02                	mov    (%edx),%al                     
  106f25:	84 c0                	test   %al,%al                        
  106f27:	75 e4                	jne    106f0d <vprintk+0x149>         
              BSP_output_char(*str);                                  
                                                                      
            /* trailing spaces */                                     
            if ( minus )                                              
  106f29:	89 f3                	mov    %esi,%ebx                      
  106f2b:	83 7d cc 00          	cmpl   $0x0,-0x34(%ebp)               
  106f2f:	75 14                	jne    106f45 <vprintk+0x181>         
  106f31:	e9 18 01 00 00       	jmp    10704e <vprintk+0x28a>         
              for ( i=len ; i<width ; i++ )                           
                BSP_output_char(' ');                                 
  106f36:	83 ec 0c             	sub    $0xc,%esp                      
  106f39:	6a 20                	push   $0x20                          
  106f3b:	ff 15 fc 93 11 00    	call   *0x1193fc                      
            for ( i=0 ; i<width && *str ; str++ )                     
              BSP_output_char(*str);                                  
                                                                      
            /* trailing spaces */                                     
            if ( minus )                                              
              for ( i=len ; i<width ; i++ )                           
  106f41:	43                   	inc    %ebx                           
  106f42:	83 c4 10             	add    $0x10,%esp                     
  106f45:	3b 5d c4             	cmp    -0x3c(%ebp),%ebx               
  106f48:	7c ec                	jl     106f36 <vprintk+0x172>         
  106f4a:	e9 ff 00 00 00       	jmp    10704e <vprintk+0x28a>         
                BSP_output_char(' ');                                 
          }                                                           
          break;                                                      
        case 'c':                                                     
          BSP_output_char(va_arg(ap, int));                           
  106f4f:	8b 5d 0c             	mov    0xc(%ebp),%ebx                 <== NOT EXECUTED
  106f52:	83 c3 04             	add    $0x4,%ebx                      <== NOT EXECUTED
  106f55:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106f58:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 <== NOT EXECUTED
  106f5b:	0f be 01             	movsbl (%ecx),%eax                    <== NOT EXECUTED
  106f5e:	50                   	push   %eax                           <== NOT EXECUTED
  106f5f:	ff 15 fc 93 11 00    	call   *0x1193fc                      <== NOT EXECUTED
  106f65:	89 5d 0c             	mov    %ebx,0xc(%ebp)                 <== NOT EXECUTED
  106f68:	e9 d1 00 00 00       	jmp    10703e <vprintk+0x27a>         <== NOT EXECUTED
          break;                                                      
        default:                                                      
          BSP_output_char(c);                                         
  106f6d:	83 ec 0c             	sub    $0xc,%esp                      
  106f70:	0f be c1             	movsbl %cl,%eax                       
  106f73:	e9 bf 00 00 00       	jmp    107037 <vprintk+0x273>         
  106f78:	31 c0                	xor    %eax,%eax                      
  106f7a:	be 08 00 00 00       	mov    $0x8,%esi                      <== NOT EXECUTED
  106f7f:	eb 07                	jmp    106f88 <vprintk+0x1c4>         <== NOT EXECUTED
  106f81:	31 c0                	xor    %eax,%eax                      
  106f83:	be 10 00 00 00       	mov    $0x10,%esi                     
          break;                                                      
      } /* switch*/                                                   
                                                                      
      if (base)                                                       
        printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
  106f88:	85 d2                	test   %edx,%edx                      
  106f8a:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  106f8d:	8d 51 04             	lea    0x4(%ecx),%edx                 
  106f90:	75 03                	jne    106f95 <vprintk+0x1d1>         
  106f92:	8b 4d 0c             	mov    0xc(%ebp),%ecx                 
  106f95:	8b 19                	mov    (%ecx),%ebx                    
  106f97:	89 55 0c             	mov    %edx,0xc(%ebp)                 
{                                                                     
  long unsigned int n;                                                
  int               count;                                            
  char              toPrint[20];                                      
                                                                      
  if ( (sign == 1) && ((long)num <  0) ) {                            
  106f9a:	48                   	dec    %eax                           
  106f9b:	75 1c                	jne    106fb9 <vprintk+0x1f5>         
  106f9d:	85 db                	test   %ebx,%ebx                      
  106f9f:	79 18                	jns    106fb9 <vprintk+0x1f5>         <== ALWAYS TAKEN
    BSP_output_char('-');                                             
  106fa1:	83 ec 0c             	sub    $0xc,%esp                      <== NOT EXECUTED
  106fa4:	6a 2d                	push   $0x2d                          <== NOT EXECUTED
  106fa6:	ff 15 fc 93 11 00    	call   *0x1193fc                      <== NOT EXECUTED
    num = -num;                                                       
  106fac:	f7 db                	neg    %ebx                           <== NOT EXECUTED
    if (maxwidth) maxwidth--;                                         
  106fae:	83 c4 10             	add    $0x10,%esp                     <== NOT EXECUTED
  106fb1:	83 7d c4 01          	cmpl   $0x1,-0x3c(%ebp)               <== NOT EXECUTED
  106fb5:	83 55 c4 ff          	adcl   $0xffffffff,-0x3c(%ebp)        <== NOT EXECUTED
  106fb9:	31 c9                	xor    %ecx,%ecx                      
  106fbb:	eb 12                	jmp    106fcf <vprintk+0x20b>         
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = num / base) > 0) {                                      
    toPrint[count++] = (num - (n*base));                              
  106fbd:	8b 45 b4             	mov    -0x4c(%ebp),%eax               
  106fc0:	0f af c6             	imul   %esi,%eax                      
  106fc3:	28 c3                	sub    %al,%bl                        
  106fc5:	88 5c 0d e0          	mov    %bl,-0x20(%ebp,%ecx,1)         
  106fc9:	8b 4d b8             	mov    -0x48(%ebp),%ecx               
  106fcc:	8b 5d b4             	mov    -0x4c(%ebp),%ebx               
    num = -num;                                                       
    if (maxwidth) maxwidth--;                                         
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = num / base) > 0) {                                      
  106fcf:	89 d8                	mov    %ebx,%eax                      
  106fd1:	31 d2                	xor    %edx,%edx                      
  106fd3:	f7 f6                	div    %esi                           
  106fd5:	89 45 b4             	mov    %eax,-0x4c(%ebp)               
  106fd8:	85 c0                	test   %eax,%eax                      
  106fda:	8d 41 01             	lea    0x1(%ecx),%eax                 
  106fdd:	89 45 b8             	mov    %eax,-0x48(%ebp)               
  106fe0:	75 db                	jne    106fbd <vprintk+0x1f9>         
    toPrint[count++] = (num - (n*base));                              
    num = n;                                                          
  }                                                                   
  toPrint[count++] = num;                                             
  106fe2:	88 5c 0d e0          	mov    %bl,-0x20(%ebp,%ecx,1)         
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
  106fe6:	8b 5d c4             	mov    -0x3c(%ebp),%ebx               
    BSP_output_char(lead);                                            
  106fe9:	0f be 75 c8          	movsbl -0x38(%ebp),%esi               
  106fed:	eb 0e                	jmp    106ffd <vprintk+0x239>         
  106fef:	83 ec 0c             	sub    $0xc,%esp                      
  106ff2:	56                   	push   %esi                           
  106ff3:	ff 15 fc 93 11 00    	call   *0x1193fc                      
    toPrint[count++] = (num - (n*base));                              
    num = n;                                                          
  }                                                                   
  toPrint[count++] = num;                                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
  106ff9:	4b                   	dec    %ebx                           
  106ffa:	83 c4 10             	add    $0x10,%esp                     
  106ffd:	3b 5d b8             	cmp    -0x48(%ebp),%ebx               
  107000:	77 ed                	ja     106fef <vprintk+0x22b>         
  107002:	31 db                	xor    %ebx,%ebx                      
    BSP_output_char(lead);                                            
                                                                      
  for (n = 0; n < count; n++) {                                       
    BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 
  107004:	8d 75 f4             	lea    -0xc(%ebp),%esi                
  107007:	03 75 b8             	add    -0x48(%ebp),%esi               
  10700a:	eb 1e                	jmp    10702a <vprintk+0x266>         
  10700c:	83 ec 0c             	sub    $0xc,%esp                      
  10700f:	89 d8                	mov    %ebx,%eax                      
  107011:	f7 d0                	not    %eax                           
  107013:	0f be 44 30 ec       	movsbl -0x14(%eax,%esi,1),%eax        
  107018:	0f be 80 36 72 11 00 	movsbl 0x117236(%eax),%eax            
  10701f:	50                   	push   %eax                           
  107020:	ff 15 fc 93 11 00    	call   *0x1193fc                      
  toPrint[count++] = num;                                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
    BSP_output_char(lead);                                            
                                                                      
  for (n = 0; n < count; n++) {                                       
  107026:	43                   	inc    %ebx                           
  107027:	83 c4 10             	add    $0x10,%esp                     
  10702a:	3b 5d b8             	cmp    -0x48(%ebp),%ebx               
  10702d:	72 dd                	jb     10700c <vprintk+0x248>         
  10702f:	eb 10                	jmp    107041 <vprintk+0x27d>         
                                                                      
      if (base)                                                       
        printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
                 base, sign, width, lead);                            
    } else {                                                          
      BSP_output_char(*fmt);                                          
  107031:	83 ec 0c             	sub    $0xc,%esp                      
  107034:	0f be c0             	movsbl %al,%eax                       
  107037:	50                   	push   %eax                           
  107038:	ff 15 fc 93 11 00    	call   *0x1193fc                      
  10703e:	83 c4 10             	add    $0x10,%esp                     
)                                                                     
{                                                                     
  char     c, *str;                                                   
  int      lflag, base, sign, width, lead, minus;                     
                                                                      
  for (; *fmt != '\0'; fmt++) {                                       
  107041:	47                   	inc    %edi                           
  107042:	8a 07                	mov    (%edi),%al                     
  107044:	84 c0                	test   %al,%al                        
  107046:	0f 85 89 fd ff ff    	jne    106dd5 <vprintk+0x11>          
  10704c:	eb 08                	jmp    107056 <vprintk+0x292>         
                 base, sign, width, lead);                            
    } else {                                                          
      BSP_output_char(*fmt);                                          
    }                                                                 
  }                                                                   
}                                                                     
  10704e:	8b 55 d0             	mov    -0x30(%ebp),%edx               
  107051:	89 55 0c             	mov    %edx,0xc(%ebp)                 
  107054:	eb eb                	jmp    107041 <vprintk+0x27d>         
  107056:	8d 65 f4             	lea    -0xc(%ebp),%esp                
  107059:	5b                   	pop    %ebx                           
  10705a:	5e                   	pop    %esi                           
  10705b:	5f                   	pop    %edi                           
  10705c:	c9                   	leave                                 
  10705d:	c3                   	ret                                   
                                                                      

00115950 <write>: ssize_t write( int fd, const void *buffer, size_t count ) {
  115950:	55                   	push   %ebp                           
  115951:	89 e5                	mov    %esp,%ebp                      
  115953:	56                   	push   %esi                           
  115954:	53                   	push   %ebx                           
  115955:	8b 45 08             	mov    0x8(%ebp),%eax                 
  115958:	8b 75 0c             	mov    0xc(%ebp),%esi                 
  11595b:	8b 4d 10             	mov    0x10(%ebp),%ecx                
  ssize_t  rc;                                                        
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  11595e:	3b 05 d8 92 11 00    	cmp    0x1192d8,%eax                  
  115964:	73 2d                	jae    115993 <write+0x43>            <== NEVER TAKEN
  iop = rtems_libio_iop( fd );                                        
  115966:	6b d8 34             	imul   $0x34,%eax,%ebx                
  115969:	03 1d 38 d6 11 00    	add    0x11d638,%ebx                  
  rtems_libio_check_is_open( iop );                                   
  11596f:	8b 53 0c             	mov    0xc(%ebx),%edx                 
  115972:	f6 c6 01             	test   $0x1,%dh                       
  115975:	74 1c                	je     115993 <write+0x43>            <== NEVER TAKEN
  rtems_libio_check_buffer( buffer );                                 
  115977:	85 f6                	test   %esi,%esi                      
  115979:	75 0d                	jne    115988 <write+0x38>            <== ALWAYS TAKEN
  11597b:	e8 a8 97 ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  115980:	c7 00 16 00 00 00    	movl   $0x16,(%eax)                   <== NOT EXECUTED
  115986:	eb 2d                	jmp    1159b5 <write+0x65>            <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
  115988:	31 c0                	xor    %eax,%eax                      
  11598a:	85 c9                	test   %ecx,%ecx                      
  11598c:	74 3c                	je     1159ca <write+0x7a>            
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
  11598e:	80 e2 04             	and    $0x4,%dl                       
  115991:	75 0d                	jne    1159a0 <write+0x50>            <== ALWAYS TAKEN
  115993:	e8 90 97 ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  115998:	c7 00 09 00 00 00    	movl   $0x9,(%eax)                    <== NOT EXECUTED
  11599e:	eb 15                	jmp    1159b5 <write+0x65>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the write() request.                                
   */                                                                 
                                                                      
  if ( !iop->handlers->write_h )                                      
  1159a0:	8b 43 30             	mov    0x30(%ebx),%eax                
  1159a3:	8b 40 0c             	mov    0xc(%eax),%eax                 
  1159a6:	85 c0                	test   %eax,%eax                      
  1159a8:	75 10                	jne    1159ba <write+0x6a>            <== ALWAYS TAKEN
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  1159aa:	e8 79 97 ff ff       	call   10f128 <__errno>               <== NOT EXECUTED
  1159af:	c7 00 86 00 00 00    	movl   $0x86,(%eax)                   <== NOT EXECUTED
  1159b5:	83 c8 ff             	or     $0xffffffff,%eax               <== NOT EXECUTED
  1159b8:	eb 10                	jmp    1159ca <write+0x7a>            <== NOT EXECUTED
                                                                      
  rc = (*iop->handlers->write_h)( iop, buffer, count );               
  1159ba:	52                   	push   %edx                           
  1159bb:	51                   	push   %ecx                           
  1159bc:	56                   	push   %esi                           
  1159bd:	53                   	push   %ebx                           
  1159be:	ff d0                	call   *%eax                          
                                                                      
  if ( rc > 0 )                                                       
  1159c0:	83 c4 10             	add    $0x10,%esp                     
  1159c3:	85 c0                	test   %eax,%eax                      
  1159c5:	7e 03                	jle    1159ca <write+0x7a>            <== NEVER TAKEN
    iop->offset += rc;                                                
  1159c7:	01 43 08             	add    %eax,0x8(%ebx)                 
                                                                      
  return rc;                                                          
}                                                                     
  1159ca:	8d 65 f8             	lea    -0x8(%ebp),%esp                
  1159cd:	5b                   	pop    %ebx                           
  1159ce:	5e                   	pop    %esi                           
  1159cf:	c9                   	leave                                 
  1159d0:	c3                   	ret