ffc0a638 <_Heap_Walk_print>:                                          
{                                                                     
  /* Do nothing */                                                    
}                                                                     
                                                                      
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{                                                                     
ffc0a638:	94 21 ff 88 	stwu    r1,-120(r1)                            
ffc0a63c:	7c 08 02 a6 	mflr    r0                                     
ffc0a640:	93 e1 00 74 	stw     r31,116(r1)                            
ffc0a644:	90 01 00 7c 	stw     r0,124(r1)                             
ffc0a648:	7c 60 1b 78 	mr      r0,r3                                  
ffc0a64c:	90 c1 00 1c 	stw     r6,28(r1)                              
ffc0a650:	90 e1 00 20 	stw     r7,32(r1)                              
ffc0a654:	91 01 00 24 	stw     r8,36(r1)                              
ffc0a658:	91 21 00 28 	stw     r9,40(r1)                              
ffc0a65c:	91 41 00 2c 	stw     r10,44(r1)                             
ffc0a660:	40 86 00 24 	bne-    cr1,ffc0a684 <_Heap_Walk_print+0x4c>   
ffc0a664:	d8 21 00 30 	stfd    f1,48(r1)                              <== NOT EXECUTED
ffc0a668:	d8 41 00 38 	stfd    f2,56(r1)                              <== NOT EXECUTED
ffc0a66c:	d8 61 00 40 	stfd    f3,64(r1)                              <== NOT EXECUTED
ffc0a670:	d8 81 00 48 	stfd    f4,72(r1)                              <== NOT EXECUTED
ffc0a674:	d8 a1 00 50 	stfd    f5,80(r1)                              <== NOT EXECUTED
ffc0a678:	d8 c1 00 58 	stfd    f6,88(r1)                              <== NOT EXECUTED
ffc0a67c:	d8 e1 00 60 	stfd    f7,96(r1)                              <== NOT EXECUTED
ffc0a680:	d9 01 00 68 	stfd    f8,104(r1)                             <== NOT EXECUTED
  va_list ap;                                                         
                                                                      
  if ( error ) {                                                      
ffc0a684:	2f 84 00 00 	cmpwi   cr7,r4,0                               
{                                                                     
  /* Do nothing */                                                    
}                                                                     
                                                                      
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{                                                                     
ffc0a688:	7c bf 2b 78 	mr      r31,r5                                 
  va_list ap;                                                         
                                                                      
  if ( error ) {                                                      
ffc0a68c:	41 be 00 10 	beq+    cr7,ffc0a69c <_Heap_Walk_print+0x64>   
    printk( "FAIL[%d]: ", source );                                   
ffc0a690:	3c 60 ff c2 	lis     r3,-62                                 
ffc0a694:	38 63 f6 f1 	addi    r3,r3,-2319                            
ffc0a698:	48 00 00 0c 	b       ffc0a6a4 <_Heap_Walk_print+0x6c>       
  } else {                                                            
    printk( "PASS[%d]: ", source );                                   
ffc0a69c:	3c 60 ff c2 	lis     r3,-62                                 
ffc0a6a0:	38 63 f6 fc 	addi    r3,r3,-2308                            
ffc0a6a4:	7c 04 03 78 	mr      r4,r0                                  
ffc0a6a8:	4c c6 31 82 	crclr   4*cr1+eq                               
ffc0a6ac:	4b ff b4 49 	bl      ffc05af4 <printk>                      
  }                                                                   
                                                                      
  va_start( ap, fmt );                                                
ffc0a6b0:	38 00 00 03 	li      r0,3                                   
ffc0a6b4:	98 01 00 08 	stb     r0,8(r1)                               
ffc0a6b8:	38 00 00 00 	li      r0,0                                   
  vprintk( fmt, ap );                                                 
ffc0a6bc:	7f e3 fb 78 	mr      r3,r31                                 
    printk( "FAIL[%d]: ", source );                                   
  } else {                                                            
    printk( "PASS[%d]: ", source );                                   
  }                                                                   
                                                                      
  va_start( ap, fmt );                                                
ffc0a6c0:	98 01 00 09 	stb     r0,9(r1)                               
ffc0a6c4:	38 01 00 80 	addi    r0,r1,128                              
  vprintk( fmt, ap );                                                 
ffc0a6c8:	38 81 00 08 	addi    r4,r1,8                                
    printk( "FAIL[%d]: ", source );                                   
  } else {                                                            
    printk( "PASS[%d]: ", source );                                   
  }                                                                   
                                                                      
  va_start( ap, fmt );                                                
ffc0a6cc:	90 01 00 0c 	stw     r0,12(r1)                              
ffc0a6d0:	38 01 00 10 	addi    r0,r1,16                               
ffc0a6d4:	90 01 00 10 	stw     r0,16(r1)                              
  vprintk( fmt, ap );                                                 
ffc0a6d8:	4b ff d4 79 	bl      ffc07b50 <vprintk>                     
  va_end( ap );                                                       
}                                                                     
ffc0a6dc:	80 01 00 7c 	lwz     r0,124(r1)                             
ffc0a6e0:	83 e1 00 74 	lwz     r31,116(r1)                            
ffc0a6e4:	38 21 00 78 	addi    r1,r1,120                              
ffc0a6e8:	7c 08 03 a6 	mtlr    r0                                     
ffc0a6ec:	4e 80 00 20 	blr                                            
                                                                      
ffc08650 <_IO_Manager_initialization>:                                
 *  workspace.                                                        
 *                                                                    
 */                                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
{                                                                     
ffc08650:	94 21 ff d8 	stwu    r1,-40(r1)                             
ffc08654:	7c 08 02 a6 	mflr    r0                                     
  uint32_t                    index;                                  
  rtems_driver_address_table *driver_table;                           
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = Configuration.Device_driver_table;              
ffc08658:	3d 20 00 00 	lis     r9,0                                   
 *  workspace.                                                        
 *                                                                    
 */                                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
{                                                                     
ffc0865c:	90 01 00 2c 	stw     r0,44(r1)                              
  uint32_t                    index;                                  
  rtems_driver_address_table *driver_table;                           
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = Configuration.Device_driver_table;              
ffc08660:	39 29 20 a0 	addi    r9,r9,8352                             
 *  workspace.                                                        
 *                                                                    
 */                                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
{                                                                     
ffc08664:	93 c1 00 20 	stw     r30,32(r1)                             
ffc08668:	93 e1 00 24 	stw     r31,36(r1)                             
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = Configuration.Device_driver_table;              
  drivers_in_table  = Configuration.number_of_device_drivers;         
  number_of_drivers = Configuration.maximum_drivers;                  
ffc0866c:	83 c9 00 2c 	lwz     r30,44(r9)                             
  rtems_driver_address_table *driver_table;                           
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = Configuration.Device_driver_table;              
  drivers_in_table  = Configuration.number_of_device_drivers;         
ffc08670:	83 e9 00 30 	lwz     r31,48(r9)                             
 *  workspace.                                                        
 *                                                                    
 */                                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
{                                                                     
ffc08674:	93 61 00 14 	stw     r27,20(r1)                             
                                                                      
  /*                                                                  
   *  If the user claims there are less drivers than are actually in  
   *  the table, then let's just go with the table's count.           
   */                                                                 
  if ( number_of_drivers <= drivers_in_table )                        
ffc08678:	7f 9e f8 40 	cmplw   cr7,r30,r31                            
 *  workspace.                                                        
 *                                                                    
 */                                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
{                                                                     
ffc0867c:	93 81 00 18 	stw     r28,24(r1)                             
ffc08680:	3f 80 00 00 	lis     r28,0                                  
ffc08684:	93 a1 00 1c 	stw     r29,28(r1)                             
ffc08688:	3f a0 00 00 	lis     r29,0                                  
ffc0868c:	93 21 00 0c 	stw     r25,12(r1)                             
ffc08690:	93 41 00 10 	stw     r26,16(r1)                             
  uint32_t                    index;                                  
  rtems_driver_address_table *driver_table;                           
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = Configuration.Device_driver_table;              
ffc08694:	83 69 00 34 	lwz     r27,52(r9)                             
                                                                      
  /*                                                                  
   *  If the user claims there are less drivers than are actually in  
   *  the table, then let's just go with the table's count.           
   */                                                                 
  if ( number_of_drivers <= drivers_in_table )                        
ffc08698:	40 9d 00 40 	ble-    cr7,ffc086d8 <_IO_Manager_initialization+0x88>
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
ffc0869c:	1f 3e 00 18 	mulli   r25,r30,24                             
  /*                                                                  
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
ffc086a0:	7f 23 cb 78 	mr      r3,r25                                 
ffc086a4:	48 00 36 e1 	bl      ffc0bd84 <_Workspace_Allocate_or_fatal_error>
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
                                                                      
  memset(                                                             
ffc086a8:	7f 25 cb 78 	mr      r5,r25                                 
ffc086ac:	38 80 00 00 	li      r4,0                                   
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
ffc086b0:	93 dd 27 ec 	stw     r30,10220(r29)                         
  /*                                                                  
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
ffc086b4:	7c 7a 1b 78 	mr      r26,r3                                 
ffc086b8:	90 7c 27 f0 	stw     r3,10224(r28)                          
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
                                                                      
  memset(                                                             
ffc086bc:	48 00 a1 ad 	bl      ffc12868 <memset>                      
ffc086c0:	2f 9f 00 00 	cmpwi   cr7,r31,0                              
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
    _IO_Driver_address_table[index] = driver_table[index];            
ffc086c4:	39 40 00 00 	li      r10,0                                  
ffc086c8:	3b ff 00 01 	addi    r31,r31,1                              
ffc086cc:	40 be 00 4c 	bne+    cr7,ffc08718 <_IO_Manager_initialization+0xc8>
ffc086d0:	3b e0 00 01 	li      r31,1                                  <== NOT EXECUTED
ffc086d4:	48 00 00 44 	b       ffc08718 <_IO_Manager_initialization+0xc8><== NOT EXECUTED
   *  If the maximum number of driver is the same as the number in the
   *  table, then we do not have to copy the driver table.  They can't
   *  register any dynamically.                                       
   */                                                                 
  if ( number_of_drivers == drivers_in_table ) {                      
    _IO_Driver_address_table = driver_table;                          
ffc086d8:	93 7c 27 f0 	stw     r27,10224(r28)                         
    _IO_Number_of_drivers = number_of_drivers;                        
ffc086dc:	93 fd 27 ec 	stw     r31,10220(r29)                         
    return;                                                           
ffc086e0:	48 00 00 48 	b       ffc08728 <_IO_Manager_initialization+0xd8>
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
    _IO_Driver_address_table[index] = driver_table[index];            
ffc086e4:	7c c9 50 6e 	lwzux   r6,r9,r10                              
ffc086e8:	81 09 00 08 	lwz     r8,8(r9)                               
ffc086ec:	80 09 00 0c 	lwz     r0,12(r9)                              
ffc086f0:	80 e9 00 04 	lwz     r7,4(r9)                               
ffc086f4:	7c da 51 2e 	stwx    r6,r26,r10                             
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
ffc086f8:	39 4a 00 18 	addi    r10,r10,24                             
    _IO_Driver_address_table[index] = driver_table[index];            
ffc086fc:	90 eb 00 04 	stw     r7,4(r11)                              
ffc08700:	91 0b 00 08 	stw     r8,8(r11)                              
ffc08704:	90 0b 00 0c 	stw     r0,12(r11)                             
ffc08708:	81 09 00 14 	lwz     r8,20(r9)                              
ffc0870c:	80 09 00 10 	lwz     r0,16(r9)                              
ffc08710:	91 0b 00 14 	stw     r8,20(r11)                             
ffc08714:	90 0b 00 10 	stw     r0,16(r11)                             
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
ffc08718:	37 ff ff ff 	addic.  r31,r31,-1                             
    _IO_Driver_address_table[index] = driver_table[index];            
ffc0871c:	7f 69 db 78 	mr      r9,r27                                 
ffc08720:	7d 7a 52 14 	add     r11,r26,r10                            
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
ffc08724:	40 82 ff c0 	bne+    ffc086e4 <_IO_Manager_initialization+0x94>
    _IO_Driver_address_table[index] = driver_table[index];            
  number_of_drivers = drivers_in_table;                               
}                                                                     
ffc08728:	80 01 00 2c 	lwz     r0,44(r1)                              
ffc0872c:	83 21 00 0c 	lwz     r25,12(r1)                             
ffc08730:	7c 08 03 a6 	mtlr    r0                                     
ffc08734:	83 41 00 10 	lwz     r26,16(r1)                             
ffc08738:	83 61 00 14 	lwz     r27,20(r1)                             
ffc0873c:	83 81 00 18 	lwz     r28,24(r1)                             
ffc08740:	83 a1 00 1c 	lwz     r29,28(r1)                             
ffc08744:	83 c1 00 20 	lwz     r30,32(r1)                             
ffc08748:	83 e1 00 24 	lwz     r31,36(r1)                             
ffc0874c:	38 21 00 28 	addi    r1,r1,40                               
ffc08750:	4e 80 00 20 	blr                                            
                                                                      
ffc0941c <_Internal_error_Occurred>:                                  
void _Internal_error_Occurred(                                        
  Internal_errors_Source  the_source,                                 
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
ffc0941c:	94 21 ff f0 	stwu    r1,-16(r1)                             
ffc09420:	7c 08 02 a6 	mflr    r0                                     
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
ffc09424:	3d 60 00 00 	lis     r11,0                                  
ffc09428:	39 2b 2d 30 	addi    r9,r11,11568                           
void _Internal_error_Occurred(                                        
  Internal_errors_Source  the_source,                                 
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
ffc0942c:	90 01 00 14 	stw     r0,20(r1)                              
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
  _Internal_errors_What_happened.is_internal = is_internal;           
  _Internal_errors_What_happened.the_error   = the_error;             
ffc09430:	90 a9 00 08 	stw     r5,8(r9)                               
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
  _Internal_errors_What_happened.is_internal = is_internal;           
ffc09434:	98 89 00 04 	stb     r4,4(r9)                               
void _Internal_error_Occurred(                                        
  Internal_errors_Source  the_source,                                 
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
ffc09438:	93 e1 00 0c 	stw     r31,12(r1)                             
ffc0943c:	7c bf 2b 78 	mr      r31,r5                                 
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
ffc09440:	90 6b 2d 30 	stw     r3,11568(r11)                          
  _Internal_errors_What_happened.is_internal = is_internal;           
  _Internal_errors_What_happened.the_error   = the_error;             
                                                                      
  _User_extensions_Fatal( the_source, is_internal, the_error );       
ffc09444:	48 00 23 c9 	bl      ffc0b80c <_User_extensions_Fatal>      
                                                                      
RTEMS_INLINE_ROUTINE void _System_state_Set (                         
  System_state_Codes state                                            
)                                                                     
{                                                                     
  _System_state_Current = state;                                      
ffc09448:	38 00 00 05 	li      r0,5                                   
ffc0944c:	3d 20 00 00 	lis     r9,0                                   
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
ffc09450:	7f e3 fb 78 	mr      r3,r31                                 
ffc09454:	90 09 27 d4 	stw     r0,10196(r9)                           
ffc09458:	4b ff a2 f9 	bl      ffc03750 <_BSP_Fatal_error>            
ffc0945c:	48 00 00 00 	b       ffc0945c <_Internal_error_Occurred+0x40><== NOT EXECUTED
                                                                      
ffc0955c <_Objects_Extend_information>:                               
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc0955c:	94 21 ff b8 	stwu    r1,-72(r1)                             
ffc09560:	7c 08 02 a6 	mflr    r0                                     
ffc09564:	90 01 00 4c 	stw     r0,76(r1)                              
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
ffc09568:	81 63 00 34 	lwz     r11,52(r3)                             
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc0956c:	93 61 00 34 	stw     r27,52(r1)                             
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
ffc09570:	2f 8b 00 00 	cmpwi   cr7,r11,0                              
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc09574:	93 e1 00 44 	stw     r31,68(r1)                             
ffc09578:	7c 7f 1b 78 	mr      r31,r3                                 
ffc0957c:	92 a1 00 1c 	stw     r21,28(r1)                             
ffc09580:	92 c1 00 20 	stw     r22,32(r1)                             
ffc09584:	92 e1 00 24 	stw     r23,36(r1)                             
ffc09588:	93 01 00 28 	stw     r24,40(r1)                             
ffc0958c:	93 21 00 2c 	stw     r25,44(r1)                             
ffc09590:	93 41 00 30 	stw     r26,48(r1)                             
ffc09594:	93 81 00 38 	stw     r28,56(r1)                             
ffc09598:	93 a1 00 3c 	stw     r29,60(r1)                             
ffc0959c:	93 c1 00 40 	stw     r30,64(r1)                             
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. The block variable ends up set
   *  to block_count + 1 if the table needs to be extended.           
   */                                                                 
  minimum_index = _Objects_Get_index( information->minimum_id );      
ffc095a0:	a3 63 00 0a 	lhz     r27,10(r3)                             
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
ffc095a4:	40 be 00 14 	bne+    cr7,ffc095b8 <_Objects_Extend_information+0x5c>
ffc095a8:	7f 7e db 78 	mr      r30,r27                                
ffc095ac:	3b 80 00 00 	li      r28,0                                  
ffc095b0:	3b 40 00 00 	li      r26,0                                  
ffc095b4:	48 00 00 4c 	b       ffc09600 <_Objects_Extend_information+0xa4>
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
ffc095b8:	a1 23 00 14 	lhz     r9,20(r3)                              
ffc095bc:	7f 7e db 78 	mr      r30,r27                                
ffc095c0:	a3 43 00 10 	lhz     r26,16(r3)                             
ffc095c4:	3b 80 00 00 	li      r28,0                                  
ffc095c8:	7f 5a 4b 96 	divwu   r26,r26,r9                             
ffc095cc:	2f 9a 00 00 	cmpwi   cr7,r26,0                              
ffc095d0:	38 1a 00 01 	addi    r0,r26,1                               
ffc095d4:	40 be 00 20 	bne+    cr7,ffc095f4 <_Objects_Extend_information+0x98>
ffc095d8:	38 00 00 01 	li      r0,1                                   <== NOT EXECUTED
ffc095dc:	48 00 00 18 	b       ffc095f4 <_Objects_Extend_information+0x98><== NOT EXECUTED
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL )              
ffc095e0:	7d 4b 50 2e 	lwzx    r10,r11,r10                            
ffc095e4:	2f 8a 00 00 	cmpwi   cr7,r10,0                              
ffc095e8:	41 9e 00 18 	beq-    cr7,ffc09600 <_Objects_Extend_information+0xa4>
ffc095ec:	7f de 4a 14 	add     r30,r30,r9                             
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
ffc095f0:	3b 9c 00 01 	addi    r28,r28,1                              
ffc095f4:	34 00 ff ff 	addic.  r0,r0,-1                               
      if ( information->object_blocks[ block ] == NULL )              
ffc095f8:	57 8a 10 3a 	rlwinm  r10,r28,2,0,29                         
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
ffc095fc:	40 82 ff e4 	bne+    ffc095e0 <_Objects_Extend_information+0x84>
      else                                                            
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
ffc09600:	a0 1f 00 14 	lhz     r0,20(r31)                             
ffc09604:	a2 df 00 10 	lhz     r22,16(r31)                            
ffc09608:	7e c0 b2 14 	add     r22,r0,r22                             
  /*                                                                  
   *  We need to limit the number of objects to the maximum number    
   *  representable in the index portion of the object Id.  In the    
   *  case of 16-bit Ids, this is only 256 object instances.          
   */                                                                 
  if ( maximum > OBJECTS_ID_FINAL_INDEX ) {                           
ffc0960c:	2b 96 ff ff 	cmplwi  cr7,r22,65535                          
ffc09610:	41 9d 02 1c 	bgt-    cr7,ffc0982c <_Objects_Extend_information+0x2d0>
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
  if ( information->auto_extend ) {                                   
ffc09614:	89 3f 00 12 	lbz     r9,18(r31)                             
                                                                      
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
ffc09618:	80 7f 00 18 	lwz     r3,24(r31)                             
  if ( information->auto_extend ) {                                   
ffc0961c:	2f 89 00 00 	cmpwi   cr7,r9,0                               
                                                                      
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
ffc09620:	7c 60 19 d6 	mullw   r3,r0,r3                               
  if ( information->auto_extend ) {                                   
ffc09624:	41 9e 00 14 	beq-    cr7,ffc09638 <_Objects_Extend_information+0xdc>
    new_object_block = _Workspace_Allocate( block_size );             
ffc09628:	48 00 27 a5 	bl      ffc0bdcc <_Workspace_Allocate>         
    if ( !new_object_block )                                          
ffc0962c:	7c 7d 1b 79 	mr.     r29,r3                                 
ffc09630:	40 a2 00 10 	bne+    ffc09640 <_Objects_Extend_information+0xe4>
ffc09634:	48 00 01 f8 	b       ffc0982c <_Objects_Extend_information+0x2d0>
      return;                                                         
  } else {                                                            
    new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
ffc09638:	48 00 27 4d 	bl      ffc0bd84 <_Workspace_Allocate_or_fatal_error>
ffc0963c:	7c 7d 1b 78 	mr      r29,r3                                 
  }                                                                   
                                                                      
  /*                                                                  
   *  If the index_base is the maximum we need to grow the tables.    
   */                                                                 
  if (index_base >= information->maximum ) {                          
ffc09640:	a0 1f 00 10 	lhz     r0,16(r31)                             
ffc09644:	7f 9e 00 40 	cmplw   cr7,r30,r0                             
ffc09648:	41 9c 01 5c 	blt-    cr7,ffc097a4 <_Objects_Extend_information+0x248>
     */                                                               
                                                                      
    /*                                                                
     *  Up the block count and maximum                                
     */                                                               
    block_count++;                                                    
ffc0964c:	3b 3a 00 01 	addi    r25,r26,1                              
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    object_blocks = (void**) _Workspace_Allocate( block_size );       
ffc09650:	1c 19 00 03 	mulli   r0,r25,3                               
ffc09654:	7c 76 da 14 	add     r3,r22,r27                             
ffc09658:	7c 63 02 14 	add     r3,r3,r0                               
ffc0965c:	54 63 10 3a 	rlwinm  r3,r3,2,0,29                           
ffc09660:	48 00 27 6d 	bl      ffc0bdcc <_Workspace_Allocate>         
                                                                      
    if ( !object_blocks ) {                                           
ffc09664:	7c 77 1b 79 	mr.     r23,r3                                 
ffc09668:	40 a2 00 10 	bne+    ffc09678 <_Objects_Extend_information+0x11c>
      _Workspace_Free( new_object_block );                            
ffc0966c:	7f a3 eb 78 	mr      r3,r29                                 
ffc09670:	48 00 27 91 	bl      ffc0be00 <_Workspace_Free>             
      return;                                                         
ffc09674:	48 00 01 b8 	b       ffc0982c <_Objects_Extend_information+0x2d0>
     *  Take the block count down. Saves all the (block_count - 1)    
     *  in the copies.                                                
     */                                                               
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
ffc09678:	a0 1f 00 10 	lhz     r0,16(r31)                             
    }                                                                 
                                                                      
    /*                                                                
     *  Break the block into the various sections.                    
     */                                                               
    inactive_per_block = (uint32_t *) _Addresses_Add_offset(          
ffc0967c:	57 39 10 3a 	rlwinm  r25,r25,2,0,29                         
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (                    
  const void *base,                                                   
  uintptr_t   offset                                                  
)                                                                     
{                                                                     
  return (void *)((uintptr_t)base + offset);                          
ffc09680:	7f 17 ca 14 	add     r24,r23,r25                            
     *  Take the block count down. Saves all the (block_count - 1)    
     *  in the copies.                                                
     */                                                               
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
ffc09684:	7f 80 d8 40 	cmplw   cr7,r0,r27                             
ffc09688:	7f 38 ca 14 	add     r25,r24,r25                            
ffc0968c:	41 9d 00 20 	bgt-    cr7,ffc096ac <_Objects_Extend_information+0x150>
ffc09690:	2f 9b 00 00 	cmpwi   cr7,r27,0                              
ffc09694:	39 20 00 00 	li      r9,0                                   
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
        local_table[ index ] = NULL;                                  
ffc09698:	38 00 00 00 	li      r0,0                                   
ffc0969c:	3b 7b 00 01 	addi    r27,r27,1                              
ffc096a0:	40 be 00 50 	bne+    cr7,ffc096f0 <_Objects_Extend_information+0x194>
ffc096a4:	3b 60 00 01 	li      r27,1                                  <== NOT EXECUTED
ffc096a8:	48 00 00 48 	b       ffc096f0 <_Objects_Extend_information+0x194><== NOT EXECUTED
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
ffc096ac:	57 55 10 3a 	rlwinm  r21,r26,2,0,29                         
      /*                                                              
       *  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,                                          
ffc096b0:	80 9f 00 34 	lwz     r4,52(r31)                             
ffc096b4:	7e a5 ab 78 	mr      r5,r21                                 
ffc096b8:	48 00 90 b1 	bl      ffc12768 <memcpy>                      
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
ffc096bc:	80 9f 00 30 	lwz     r4,48(r31)                             
ffc096c0:	7e a5 ab 78 	mr      r5,r21                                 
ffc096c4:	7f 03 c3 78 	mr      r3,r24                                 
ffc096c8:	48 00 90 a1 	bl      ffc12768 <memcpy>                      
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
ffc096cc:	a0 1f 00 10 	lhz     r0,16(r31)                             
ffc096d0:	80 9f 00 1c 	lwz     r4,28(r31)                             
ffc096d4:	7f 23 cb 78 	mr      r3,r25                                 
ffc096d8:	7f 7b 02 14 	add     r27,r27,r0                             
ffc096dc:	57 65 10 3a 	rlwinm  r5,r27,2,0,29                          
ffc096e0:	48 00 90 89 	bl      ffc12768 <memcpy>                      
ffc096e4:	48 00 00 18 	b       ffc096fc <_Objects_Extend_information+0x1a0>
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
        local_table[ index ] = NULL;                                  
ffc096e8:	7c 0b c9 2e 	stwx    r0,r11,r25                             
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
ffc096ec:	39 29 00 01 	addi    r9,r9,1                                
ffc096f0:	37 7b ff ff 	addic.  r27,r27,-1                             
        local_table[ index ] = NULL;                                  
ffc096f4:	55 2b 10 3a 	rlwinm  r11,r9,2,0,29                          
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
ffc096f8:	40 82 ff f0 	bne+    ffc096e8 <_Objects_Extend_information+0x18c>
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
ffc096fc:	a1 5f 00 14 	lhz     r10,20(r31)                            
    }                                                                 
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
ffc09700:	38 00 00 00 	li      r0,0                                   
ffc09704:	57 5a 10 3a 	rlwinm  r26,r26,2,0,29                         
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
ffc09708:	7d 7e 52 14 	add     r11,r30,r10                            
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
ffc0970c:	7c 18 d1 2e 	stwx    r0,r24,r26                             
ffc09710:	7f 9e 58 40 	cmplw   cr7,r30,r11                            
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
ffc09714:	57 c9 10 3a 	rlwinm  r9,r30,2,0,29                          
    }                                                                 
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
ffc09718:	7c 17 d1 2e 	stwx    r0,r23,r26                             
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
ffc0971c:	7d 39 4a 14 	add     r9,r25,r9                              
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
ffc09720:	38 0a 00 01 	addi    r0,r10,1                               
ffc09724:	39 40 00 00 	li      r10,0                                  
ffc09728:	41 9d 00 0c 	bgt-    cr7,ffc09734 <_Objects_Extend_information+0x1d8>
ffc0972c:	2f 8b 00 00 	cmpwi   cr7,r11,0                              
ffc09730:	40 be 00 14 	bne+    cr7,ffc09744 <_Objects_Extend_information+0x1e8>
ffc09734:	38 00 00 01 	li      r0,1                                   <== NOT EXECUTED
ffc09738:	48 00 00 0c 	b       ffc09744 <_Objects_Extend_information+0x1e8><== NOT EXECUTED
ffc0973c:	91 49 00 00 	stw     r10,0(r9)                              
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
ffc09740:	39 29 00 04 	addi    r9,r9,4                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
ffc09744:	34 00 ff ff 	addic.  r0,r0,-1                               
ffc09748:	40 82 ff f4 	bne+    ffc0973c <_Objects_Extend_information+0x1e0>
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc0974c:	7c 00 00 a6 	mfmsr   r0                                     
ffc09750:	7d 30 42 a6 	mfsprg  r9,0                                   
ffc09754:	7c 09 48 78 	andc    r9,r0,r9                               
ffc09758:	7d 20 01 24 	mtmsr   r9                                     
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
ffc0975c:	81 7f 00 00 	lwz     r11,0(r31)                             
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
ffc09760:	56 d6 04 3e 	clrlwi  r22,r22,16                             
    information->maximum_id = _Objects_Build_id(                      
ffc09764:	a1 3f 00 04 	lhz     r9,4(r31)                              
ffc09768:	55 6b c0 0e 	rlwinm  r11,r11,24,0,7                         
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
ffc0976c:	80 7f 00 34 	lwz     r3,52(r31)                             
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
ffc09770:	65 6b 00 01 	oris    r11,r11,1                              
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
ffc09774:	93 1f 00 30 	stw     r24,48(r31)                            
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
ffc09778:	55 29 d8 08 	rlwinm  r9,r9,27,0,4                           
ffc0977c:	7d 69 4b 78 	or      r9,r11,r9                              
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
ffc09780:	93 3f 00 1c 	stw     r25,28(r31)                            
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
ffc09784:	7d 29 b3 78 	or      r9,r9,r22                              
ffc09788:	91 3f 00 0c 	stw     r9,12(r31)                             
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
ffc0978c:	b2 df 00 10 	sth     r22,16(r31)                            
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
ffc09790:	92 ff 00 34 	stw     r23,52(r31)                            
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc09794:	7c 00 01 24 	mtmsr   r0                                     
        information->maximum                                          
      );                                                              
                                                                      
    _ISR_Enable( level );                                             
                                                                      
    if ( old_tables )                                                 
ffc09798:	2f 83 00 00 	cmpwi   cr7,r3,0                               
ffc0979c:	41 9e 00 08 	beq-    cr7,ffc097a4 <_Objects_Extend_information+0x248>
      _Workspace_Free( old_tables );                                  
ffc097a0:	48 00 26 61 	bl      ffc0be00 <_Workspace_Free>             
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
ffc097a4:	81 3f 00 34 	lwz     r9,52(r31)                             
ffc097a8:	57 9c 10 3a 	rlwinm  r28,r28,2,0,29                         
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
ffc097ac:	3b 61 00 08 	addi    r27,r1,8                               
ffc097b0:	a0 bf 00 14 	lhz     r5,20(r31)                             
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
ffc097b4:	7f a9 e1 2e 	stwx    r29,r9,r28                             
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
ffc097b8:	7f a4 eb 78 	mr      r4,r29                                 
ffc097bc:	7f 63 db 78 	mr      r3,r27                                 
ffc097c0:	80 df 00 18 	lwz     r6,24(r31)                             
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
ffc097c4:	3b bf 00 20 	addi    r29,r31,32                             
  information->object_blocks[ block ] = new_object_block;             
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
ffc097c8:	48 00 4e 21 	bl      ffc0e5e8 <_Chain_Initialize>           
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
ffc097cc:	48 00 00 2c 	b       ffc097f8 <_Objects_Extend_information+0x29c>
                                                                      
    the_object->id = _Objects_Build_id(                               
ffc097d0:	81 7f 00 00 	lwz     r11,0(r31)                             
ffc097d4:	a0 1f 00 04 	lhz     r0,4(r31)                              
ffc097d8:	55 6b c0 0e 	rlwinm  r11,r11,24,0,7                         
ffc097dc:	65 6b 00 01 	oris    r11,r11,1                              
ffc097e0:	54 00 d8 08 	rlwinm  r0,r0,27,0,4                           
ffc097e4:	7d 60 03 78 	or      r0,r11,r0                              
ffc097e8:	7c 00 f3 78 	or      r0,r0,r30                              
ffc097ec:	90 09 00 08 	stw     r0,8(r9)                               
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
ffc097f0:	3b de 00 01 	addi    r30,r30,1                              
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
ffc097f4:	4b ff f2 81 	bl      ffc08a74 <_Chain_Append>               
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
ffc097f8:	7f 63 db 78 	mr      r3,r27                                 
ffc097fc:	4b ff f2 a9 	bl      ffc08aa4 <_Chain_Get>                  
ffc09800:	7c 69 1b 79 	mr.     r9,r3                                  
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
ffc09804:	7f a3 eb 78 	mr      r3,r29                                 
ffc09808:	7d 24 4b 78 	mr      r4,r9                                  
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
ffc0980c:	40 82 ff c4 	bne+    ffc097d0 <_Objects_Extend_information+0x274>
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
ffc09810:	a0 1f 00 14 	lhz     r0,20(r31)                             
  information->inactive =                                             
ffc09814:	a1 3f 00 2c 	lhz     r9,44(r31)                             
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
ffc09818:	81 7f 00 30 	lwz     r11,48(r31)                            
  information->inactive =                                             
ffc0981c:	7d 20 4a 14 	add     r9,r0,r9                               
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
ffc09820:	54 00 04 3e 	clrlwi  r0,r0,16                               
  information->inactive =                                             
ffc09824:	b1 3f 00 2c 	sth     r9,44(r31)                             
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
ffc09828:	7c 0b e1 2e 	stwx    r0,r11,r28                             
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
}                                                                     
ffc0982c:	80 01 00 4c 	lwz     r0,76(r1)                              
ffc09830:	82 a1 00 1c 	lwz     r21,28(r1)                             
ffc09834:	7c 08 03 a6 	mtlr    r0                                     
ffc09838:	82 c1 00 20 	lwz     r22,32(r1)                             
ffc0983c:	82 e1 00 24 	lwz     r23,36(r1)                             
ffc09840:	83 01 00 28 	lwz     r24,40(r1)                             
ffc09844:	83 21 00 2c 	lwz     r25,44(r1)                             
ffc09848:	83 41 00 30 	lwz     r26,48(r1)                             
ffc0984c:	83 61 00 34 	lwz     r27,52(r1)                             
ffc09850:	83 81 00 38 	lwz     r28,56(r1)                             
ffc09854:	83 a1 00 3c 	lwz     r29,60(r1)                             
ffc09858:	83 c1 00 40 	lwz     r30,64(r1)                             
ffc0985c:	83 e1 00 44 	lwz     r31,68(r1)                             
ffc09860:	38 21 00 48 	addi    r1,r1,72                               
ffc09864:	4e 80 00 20 	blr                                            
                                                                      
ffc09c84 <_Objects_Shrink_information>:                               
 */                                                                   
                                                                      
void _Objects_Shrink_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc09c84:	94 21 ff e8 	stwu    r1,-24(r1)                             
ffc09c88:	7c 08 02 a6 	mflr    r0                                     
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
ffc09c8c:	39 20 00 00 	li      r9,0                                   
 */                                                                   
                                                                      
void _Objects_Shrink_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc09c90:	90 01 00 1c 	stw     r0,28(r1)                              
ffc09c94:	93 c1 00 10 	stw     r30,16(r1)                             
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
ffc09c98:	a1 43 00 10 	lhz     r10,16(r3)                             
                                                                      
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
ffc09c9c:	a3 c3 00 0a 	lhz     r30,10(r3)                             
  block_count = (information->maximum - index_base) /                 
ffc09ca0:	a1 63 00 14 	lhz     r11,20(r3)                             
ffc09ca4:	7d 5e 50 50 	subf    r10,r30,r10                            
 */                                                                   
                                                                      
void _Objects_Shrink_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc09ca8:	93 e1 00 14 	stw     r31,20(r1)                             
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
ffc09cac:	7d 4a 5b 96 	divwu   r10,r10,r11                            
 */                                                                   
                                                                      
void _Objects_Shrink_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
ffc09cb0:	93 81 00 08 	stw     r28,8(r1)                              
ffc09cb4:	93 a1 00 0c 	stw     r29,12(r1)                             
ffc09cb8:	2f 8a 00 00 	cmpwi   cr7,r10,0                              
ffc09cbc:	7c 7f 1b 78 	mr      r31,r3                                 
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
ffc09cc0:	38 0a 00 01 	addi    r0,r10,1                               
ffc09cc4:	40 be 00 88 	bne+    cr7,ffc09d4c <_Objects_Shrink_information+0xc8>
ffc09cc8:	38 00 00 01 	li      r0,1                                   <== NOT EXECUTED
ffc09ccc:	48 00 00 80 	b       ffc09d4c <_Objects_Shrink_information+0xc8><== NOT EXECUTED
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
    if ( information->inactive_per_block[ block ] ==                  
ffc09cd0:	81 5f 00 30 	lwz     r10,48(r31)                            
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
ffc09cd4:	39 29 00 01 	addi    r9,r9,1                                
    if ( information->inactive_per_block[ block ] ==                  
ffc09cd8:	7d 4a e8 2e 	lwzx    r10,r10,r29                            
ffc09cdc:	7f 8a 58 00 	cmpw    cr7,r10,r11                            
ffc09ce0:	40 be 00 68 	bne+    cr7,ffc09d48 <_Objects_Shrink_information+0xc4>
         information->allocation_size ) {                             
                                                                      
      /*                                                              
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) information->Inactive.first;   
ffc09ce4:	80 7f 00 20 	lwz     r3,32(r31)                             
                                                                      
      do {                                                            
         index = _Objects_Get_index( the_object->id );                
ffc09ce8:	a0 03 00 0a 	lhz     r0,10(r3)                              
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
ffc09cec:	83 83 00 00 	lwz     r28,0(r3)                              
         if ((index >= index_base) &&                                 
ffc09cf0:	7f 80 f0 40 	cmplw   cr7,r0,r30                             
ffc09cf4:	41 9c 00 18 	blt-    cr7,ffc09d0c <_Objects_Shrink_information+0x88>
             (index < (index_base + information->allocation_size))) { 
ffc09cf8:	a1 3f 00 14 	lhz     r9,20(r31)                             
ffc09cfc:	7d 3e 4a 14 	add     r9,r30,r9                              
ffc09d00:	7f 80 48 40 	cmplw   cr7,r0,r9                              
ffc09d04:	40 bc 00 08 	bge+    cr7,ffc09d0c <_Objects_Shrink_information+0x88>
           _Chain_Extract( &extract_me->Node );                       
ffc09d08:	48 00 48 b9 	bl      ffc0e5c0 <_Chain_Extract>              
         }                                                            
       }                                                              
       while ( the_object );                                          
ffc09d0c:	2f 9c 00 00 	cmpwi   cr7,r28,0                              
ffc09d10:	7f 83 e3 78 	mr      r3,r28                                 
ffc09d14:	40 9e ff d4 	bne+    cr7,ffc09ce8 <_Objects_Shrink_information+0x64>
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
ffc09d18:	81 3f 00 34 	lwz     r9,52(r31)                             
ffc09d1c:	7c 69 e8 2e 	lwzx    r3,r9,r29                              
ffc09d20:	48 00 20 e1 	bl      ffc0be00 <_Workspace_Free>             
      information->object_blocks[ block ] = NULL;                     
      information->inactive_per_block[ block ] = 0;                   
                                                                      
      information->inactive -= information->allocation_size;          
ffc09d24:	a1 5f 00 2c 	lhz     r10,44(r31)                            
ffc09d28:	a0 1f 00 14 	lhz     r0,20(r31)                             
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
ffc09d2c:	81 3f 00 34 	lwz     r9,52(r31)                             
      information->inactive_per_block[ block ] = 0;                   
ffc09d30:	81 7f 00 30 	lwz     r11,48(r31)                            
                                                                      
      information->inactive -= information->allocation_size;          
ffc09d34:	7c 00 50 50 	subf    r0,r0,r10                              
ffc09d38:	b0 1f 00 2c 	sth     r0,44(r31)                             
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
      information->inactive_per_block[ block ] = 0;                   
ffc09d3c:	7f 8b e9 2e 	stwx    r28,r11,r29                            
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
ffc09d40:	7f 89 e9 2e 	stwx    r28,r9,r29                             
      information->inactive_per_block[ block ] = 0;                   
                                                                      
      information->inactive -= information->allocation_size;          
                                                                      
      return;                                                         
ffc09d44:	48 00 00 14 	b       ffc09d58 <_Objects_Shrink_information+0xd4>
    }                                                                 
                                                                      
    index_base += information->allocation_size;                       
ffc09d48:	7f de 5a 14 	add     r30,r30,r11                            
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
ffc09d4c:	34 00 ff ff 	addic.  r0,r0,-1                               
ffc09d50:	55 3d 10 3a 	rlwinm  r29,r9,2,0,29                          
ffc09d54:	40 82 ff 7c 	bne+    ffc09cd0 <_Objects_Shrink_information+0x4c>
      return;                                                         
    }                                                                 
                                                                      
    index_base += information->allocation_size;                       
  }                                                                   
}                                                                     
ffc09d58:	80 01 00 1c 	lwz     r0,28(r1)                              
ffc09d5c:	83 81 00 08 	lwz     r28,8(r1)                              
ffc09d60:	7c 08 03 a6 	mtlr    r0                                     
ffc09d64:	83 a1 00 0c 	lwz     r29,12(r1)                             
ffc09d68:	83 c1 00 10 	lwz     r30,16(r1)                             
ffc09d6c:	83 e1 00 14 	lwz     r31,20(r1)                             
ffc09d70:	38 21 00 18 	addi    r1,r1,24                               
ffc09d74:	4e 80 00 20 	blr                                            
                                                                      
ffc0816c <_POSIX_Timer_TSR>:                                          
 *  This is the operation that is run when a timer expires            
 */                                                                   
void _POSIX_Timer_TSR(                                                
  Objects_Id timer __attribute__((unused)),                           
  void *data)                                                         
{                                                                     
ffc0816c:	94 21 ff f0 	stwu    r1,-16(r1)                             
ffc08170:	7c 08 02 a6 	mflr    r0                                     
ffc08174:	90 01 00 14 	stw     r0,20(r1)                              
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
ffc08178:	80 04 00 54 	lwz     r0,84(r4)                              
  bool                 activated;                                     
                                                                      
  ptimer = (POSIX_Timer_Control *)data;                               
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
ffc0817c:	81 24 00 68 	lwz     r9,104(r4)                             
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
ffc08180:	2f 80 00 00 	cmpwi   cr7,r0,0                               
 *  This is the operation that is run when a timer expires            
 */                                                                   
void _POSIX_Timer_TSR(                                                
  Objects_Id timer __attribute__((unused)),                           
  void *data)                                                         
{                                                                     
ffc08184:	93 e1 00 0c 	stw     r31,12(r1)                             
  bool                 activated;                                     
                                                                      
  ptimer = (POSIX_Timer_Control *)data;                               
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
ffc08188:	38 09 00 01 	addi    r0,r9,1                                
 *  This is the operation that is run when a timer expires            
 */                                                                   
void _POSIX_Timer_TSR(                                                
  Objects_Id timer __attribute__((unused)),                           
  void *data)                                                         
{                                                                     
ffc0818c:	7c 9f 23 78 	mr      r31,r4                                 
  bool                 activated;                                     
                                                                      
  ptimer = (POSIX_Timer_Control *)data;                               
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
ffc08190:	90 04 00 68 	stw     r0,104(r4)                             
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
ffc08194:	40 9e 00 10 	bne-    cr7,ffc081a4 <_POSIX_Timer_TSR+0x38>   
       ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {            
ffc08198:	80 04 00 58 	lwz     r0,88(r4)                              
ffc0819c:	2f 80 00 00 	cmpwi   cr7,r0,0                               
ffc081a0:	41 9e 00 38 	beq-    cr7,ffc081d8 <_POSIX_Timer_TSR+0x6c>   
    activated = _POSIX_Timer_Insert_helper(                           
ffc081a4:	80 9f 00 64 	lwz     r4,100(r31)                            
ffc081a8:	3c c0 ff c1 	lis     r6,-63                                 
ffc081ac:	80 bf 00 08 	lwz     r5,8(r31)                              
ffc081b0:	38 c6 81 6c 	addi    r6,r6,-32404                           
ffc081b4:	38 7f 00 10 	addi    r3,r31,16                              
ffc081b8:	7f e7 fb 78 	mr      r7,r31                                 
ffc081bc:	48 00 6e c5 	bl      ffc0f080 <_POSIX_Timer_Insert_helper>  
      ptimer->ticks,                                                  
      ptimer->Object.id,                                              
      _POSIX_Timer_TSR,                                               
      ptimer                                                          
    );                                                                
    if ( !activated )                                                 
ffc081c0:	2f 83 00 00 	cmpwi   cr7,r3,0                               
ffc081c4:	41 be 00 30 	beq+    cr7,ffc081f4 <_POSIX_Timer_TSR+0x88>   
      return;                                                         
                                                                      
    /* Store the time when the timer was started again */             
    _TOD_Get( &ptimer->time );                                        
ffc081c8:	38 7f 00 6c 	addi    r3,r31,108                             
ffc081cc:	48 00 1b 79 	bl      ffc09d44 <_TOD_Get>                    
                                                                      
    /* The state really did not change but just to be safe */         
    ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                     
ffc081d0:	38 00 00 03 	li      r0,3                                   
ffc081d4:	48 00 00 08 	b       ffc081dc <_POSIX_Timer_TSR+0x70>       
  } else {                                                            
   /* Indicates that the timer is stopped */                          
   ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;                     
ffc081d8:	38 00 00 04 	li      r0,4                                   <== NOT EXECUTED
ffc081dc:	98 1f 00 3c 	stb     r0,60(r31)                             
  /*                                                                  
   * 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 ) ) {
ffc081e0:	80 7f 00 38 	lwz     r3,56(r31)                             
ffc081e4:	80 9f 00 44 	lwz     r4,68(r31)                             
ffc081e8:	48 00 69 0d 	bl      ffc0eaf4 <pthread_kill>                
  }                                                                   
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
ffc081ec:	38 00 00 00 	li      r0,0                                   
ffc081f0:	90 1f 00 68 	stw     r0,104(r31)                            
}                                                                     
ffc081f4:	80 01 00 14 	lwz     r0,20(r1)                              
ffc081f8:	83 e1 00 0c 	lwz     r31,12(r1)                             
ffc081fc:	38 21 00 10 	addi    r1,r1,16                               
ffc08200:	7c 08 03 a6 	mtlr    r0                                     
ffc08204:	4e 80 00 20 	blr                                            
                                                                      
ffc0bfc8 <_Thread_Restart>:                                           
bool _Thread_Restart(                                                 
  Thread_Control            *the_thread,                              
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
ffc0bfc8:	94 21 ff e8 	stwu    r1,-24(r1)                             
ffc0bfcc:	7c 08 02 a6 	mflr    r0                                     
ffc0bfd0:	90 01 00 1c 	stw     r0,28(r1)                              
  if ( !_States_Is_dormant( the_thread->current_state ) ) {           
ffc0bfd4:	80 03 00 10 	lwz     r0,16(r3)                              
bool _Thread_Restart(                                                 
  Thread_Control            *the_thread,                              
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
ffc0bfd8:	93 e1 00 14 	stw     r31,20(r1)                             
ffc0bfdc:	7c 7f 1b 78 	mr      r31,r3                                 
  if ( !_States_Is_dormant( the_thread->current_state ) ) {           
ffc0bfe0:	70 09 00 01 	andi.   r9,r0,1                                
ffc0bfe4:	38 00 00 00 	li      r0,0                                   
ffc0bfe8:	40 a2 00 74 	bne+    ffc0c05c <_Thread_Restart+0x94>        
                                                                      
    _Thread_Set_transient( the_thread );                              
ffc0bfec:	90 81 00 08 	stw     r4,8(r1)                               
ffc0bff0:	90 a1 00 0c 	stw     r5,12(r1)                              
ffc0bff4:	48 00 01 f5 	bl      ffc0c1e8 <_Thread_Set_transient>       
                                                                      
    _Thread_Reset( the_thread, pointer_argument, numeric_argument );  
ffc0bff8:	7f e3 fb 78 	mr      r3,r31                                 
ffc0bffc:	80 81 00 08 	lwz     r4,8(r1)                               
ffc0c000:	80 a1 00 0c 	lwz     r5,12(r1)                              
ffc0c004:	48 00 42 d1 	bl      ffc102d4 <_Thread_Reset>               
                                                                      
    _Thread_Load_environment( the_thread );                           
ffc0c008:	7f e3 fb 78 	mr      r3,r31                                 
ffc0c00c:	48 00 3e c5 	bl      ffc0fed0 <_Thread_Load_environment>    
                                                                      
    _Thread_Ready( the_thread );                                      
ffc0c010:	7f e3 fb 78 	mr      r3,r31                                 
ffc0c014:	48 00 41 e5 	bl      ffc101f8 <_Thread_Ready>               
                                                                      
    _User_extensions_Thread_restart( the_thread );                    
ffc0c018:	7f e3 fb 78 	mr      r3,r31                                 
ffc0c01c:	48 00 0a a1 	bl      ffc0cabc <_User_extensions_Thread_restart>
                                                                      
    if ( _Thread_Is_executing ( the_thread ) )                        
ffc0c020:	3d 20 00 00 	lis     r9,0                                   
ffc0c024:	81 29 27 fc 	lwz     r9,10236(r9)                           
ffc0c028:	38 00 00 01 	li      r0,1                                   
ffc0c02c:	7f 9f 48 00 	cmpw    cr7,r31,r9                             
ffc0c030:	40 be 00 2c 	bne+    cr7,ffc0c05c <_Thread_Restart+0x94>    
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )                
{                                                                     
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  if ( _Thread_Executing->fp_context != NULL )                        
ffc0c034:	80 1f 01 3c 	lwz     r0,316(r31)                            
ffc0c038:	2f 80 00 00 	cmpwi   cr7,r0,0                               
ffc0c03c:	41 9e 00 0c 	beq-    cr7,ffc0c048 <_Thread_Restart+0x80>    
    _Context_Restore_fp( &_Thread_Executing->fp_context );            
ffc0c040:	38 7f 01 3c 	addi    r3,r31,316                             
ffc0c044:	48 01 42 5d 	bl      ffc202a0 <_CPU_Context_restore_fp>     
#endif                                                                
                                                                      
  _CPU_Context_Restart_self( &_Thread_Executing->Registers );         
ffc0c048:	3d 20 00 00 	lis     r9,0                                   
ffc0c04c:	80 69 27 fc 	lwz     r3,10236(r9)                           
ffc0c050:	38 63 00 dc 	addi    r3,r3,220                              
ffc0c054:	48 01 44 0d 	bl      ffc20460 <_CPU_Context_restore>        
ffc0c058:	38 00 00 01 	li      r0,1                                   <== NOT EXECUTED
                                                                      
    return true;                                                      
  }                                                                   
                                                                      
  return false;                                                       
}                                                                     
ffc0c05c:	7c 03 03 78 	mr      r3,r0                                  
ffc0c060:	80 01 00 1c 	lwz     r0,28(r1)                              
ffc0c064:	83 e1 00 14 	lwz     r31,20(r1)                             
ffc0c068:	38 21 00 18 	addi    r1,r1,24                               
ffc0c06c:	7c 08 03 a6 	mtlr    r0                                     
ffc0c070:	4e 80 00 20 	blr                                            
                                                                      
ffc0ac04 <_Thread_queue_Enqueue_priority>:                            
  Priority_Control     priority;                                      
  States_Control       block_state;                                   
                                                                      
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
ffc0ac04:	80 04 00 14 	lwz     r0,20(r4)                              
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
ffc0ac08:	39 04 00 3c 	addi    r8,r4,60                               
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (     
  Thread_queue_Control *the_thread_queue,                             
  Thread_Control       *the_thread,                                   
  ISR_Level            *level_p                                       
)                                                                     
{                                                                     
ffc0ac0c:	94 21 ff f0 	stwu    r1,-16(r1)                             
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
ffc0ac10:	39 64 00 38 	addi    r11,r4,56                              
  priority     = the_thread->current_priority;                        
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
  block_state  = the_thread_queue->state;                             
                                                                      
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
ffc0ac14:	70 09 00 20 	andi.   r9,r0,32                               
                                                                      
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
ffc0ac18:	54 0a d1 be 	rlwinm  r10,r0,26,6,31                         
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
ffc0ac1c:	91 04 00 38 	stw     r8,56(r4)                              
ffc0ac20:	1d 4a 00 0c 	mulli   r10,r10,12                             
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (     
  Thread_queue_Control *the_thread_queue,                             
  Thread_Control       *the_thread,                                   
  ISR_Level            *level_p                                       
)                                                                     
{                                                                     
ffc0ac24:	93 e1 00 0c 	stw     r31,12(r1)                             
  the_chain->permanent_null = NULL;                                   
ffc0ac28:	39 00 00 00 	li      r8,0                                   
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
  block_state  = the_thread_queue->state;                             
ffc0ac2c:	81 23 00 38 	lwz     r9,56(r3)                              
                                                                      
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
ffc0ac30:	7d 43 52 14 	add     r10,r3,r10                             
ffc0ac34:	91 04 00 3c 	stw     r8,60(r4)                              
  the_chain->last           = _Chain_Head(the_chain);                 
ffc0ac38:	91 64 00 40 	stw     r11,64(r4)                             
  block_state  = the_thread_queue->state;                             
                                                                      
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
ffc0ac3c:	40 82 00 98 	bne-    ffc0acd4 <_Thread_queue_Enqueue_priority+0xd0>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
ffc0ac40:	38 ca 00 04 	addi    r6,r10,4                               
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc0ac44:	7d 00 00 a6 	mfmsr   r8                                     
ffc0ac48:	7d 70 42 a6 	mfsprg  r11,0                                  
ffc0ac4c:	7d 0b 58 78 	andc    r11,r8,r11                             
ffc0ac50:	7d 60 01 24 	mtmsr   r11                                    
    goto restart_reverse_search;                                      
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->first;                   
ffc0ac54:	38 e0 ff ff 	li      r7,-1                                  
ffc0ac58:	81 6a 00 00 	lwz     r11,0(r10)                             
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
ffc0ac5c:	48 00 00 34 	b       ffc0ac90 <_Thread_queue_Enqueue_priority+0x8c>
    search_priority = search_thread->current_priority;                
ffc0ac60:	80 eb 00 14 	lwz     r7,20(r11)                             
    if ( priority <= search_priority )                                
ffc0ac64:	7f 80 38 40 	cmplw   cr7,r0,r7                              
ffc0ac68:	40 9d 00 30 	ble-    cr7,ffc0ac98 <_Thread_queue_Enqueue_priority+0x94>
                                                                      
static inline void ppc_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t current_level;                                             
                                                                      
  asm volatile (                                                      
ffc0ac6c:	7d 80 00 a6 	mfmsr   r12                                    
ffc0ac70:	7d 00 01 24 	mtmsr   r8                                     
ffc0ac74:	7d 80 01 24 	mtmsr   r12                                    
    search_priority = search_thread->current_priority;                
    if ( priority <= search_priority )                                
      break;                                                          
#endif                                                                
    _ISR_Flash( level );                                              
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
ffc0ac78:	81 8b 00 10 	lwz     r12,16(r11)                            
ffc0ac7c:	7d 3f 60 39 	and.    r31,r9,r12                             
ffc0ac80:	40 a2 00 0c 	bne+    ffc0ac8c <_Thread_queue_Enqueue_priority+0x88>
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc0ac84:	7d 00 01 24 	mtmsr   r8                                     <== NOT EXECUTED
ffc0ac88:	4b ff ff bc 	b       ffc0ac44 <_Thread_queue_Enqueue_priority+0x40><== NOT EXECUTED
      _ISR_Enable( level );                                           
      goto restart_forward_search;                                    
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
ffc0ac8c:	81 6b 00 00 	lwz     r11,0(r11)                             
                                                                      
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 ) ) {  
ffc0ac90:	7f 8b 30 00 	cmpw    cr7,r11,r6                             
ffc0ac94:	40 9e ff cc 	bne+    cr7,ffc0ac60 <_Thread_queue_Enqueue_priority+0x5c>
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
ffc0ac98:	81 43 00 30 	lwz     r10,48(r3)                             
                                                                      
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 ) ) {  
ffc0ac9c:	7d 09 43 78 	mr      r9,r8                                  
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
ffc0aca0:	2f 8a 00 01 	cmpwi   cr7,r10,1                              
ffc0aca4:	40 be 00 f8 	bne+    cr7,ffc0ad9c <_Thread_queue_Enqueue_priority+0x198>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
                                                                      
  if ( priority == search_priority )                                  
ffc0aca8:	7f 80 38 00 	cmpw    cr7,r0,r7                              
                                                                      
  if ( the_thread_queue->sync_state !=                                
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
ffc0acac:	38 00 00 00 	li      r0,0                                   
ffc0acb0:	90 03 00 30 	stw     r0,48(r3)                              
                                                                      
  if ( priority == search_priority )                                  
ffc0acb4:	41 9e 00 c4 	beq-    cr7,ffc0ad78 <_Thread_queue_Enqueue_priority+0x174>
    goto equal_priority;                                              
                                                                      
  search_node   = (Chain_Node *) search_thread;                       
  previous_node = search_node->previous;                              
ffc0acb8:	81 2b 00 04 	lwz     r9,4(r11)                              
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
ffc0acbc:	91 64 00 00 	stw     r11,0(r4)                              
  the_node->previous     = previous_node;                             
ffc0acc0:	91 24 00 04 	stw     r9,4(r4)                               
  previous_node->next    = the_node;                                  
  search_node->previous  = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
ffc0acc4:	90 64 00 44 	stw     r3,68(r4)                              
  previous_node = search_node->previous;                              
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
  the_node->previous     = previous_node;                             
  previous_node->next    = the_node;                                  
ffc0acc8:	90 89 00 00 	stw     r4,0(r9)                               
  search_node->previous  = the_node;                                  
ffc0accc:	90 8b 00 04 	stw     r4,4(r11)                              
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
ffc0acd0:	48 00 00 9c 	b       ffc0ad6c <_Thread_queue_Enqueue_priority+0x168>
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
ffc0acd4:	3c c0 00 00 	lis     r6,0                                   
ffc0acd8:	38 c6 26 a4 	addi    r6,r6,9892                             
ffc0acdc:	88 e6 00 00 	lbz     r7,0(r6)                               
ffc0ace0:	38 e7 00 01 	addi    r7,r7,1                                
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc0ace4:	7d 00 00 a6 	mfmsr   r8                                     
ffc0ace8:	7d 70 42 a6 	mfsprg  r11,0                                  
ffc0acec:	7d 0b 58 78 	andc    r11,r8,r11                             
ffc0acf0:	7d 60 01 24 	mtmsr   r11                                    
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->last;                    
ffc0acf4:	81 6a 00 08 	lwz     r11,8(r10)                             
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
ffc0acf8:	48 00 00 34 	b       ffc0ad2c <_Thread_queue_Enqueue_priority+0x128>
    search_priority = search_thread->current_priority;                
ffc0acfc:	80 eb 00 14 	lwz     r7,20(r11)                             
    if ( priority >= search_priority )                                
ffc0ad00:	7f 80 38 40 	cmplw   cr7,r0,r7                              
ffc0ad04:	40 9c 00 30 	bge-    cr7,ffc0ad34 <_Thread_queue_Enqueue_priority+0x130>
                                                                      
static inline void ppc_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t current_level;                                             
                                                                      
  asm volatile (                                                      
ffc0ad08:	7d 80 00 a6 	mfmsr   r12                                    
ffc0ad0c:	7d 00 01 24 	mtmsr   r8                                     
ffc0ad10:	7d 80 01 24 	mtmsr   r12                                    
    search_priority = search_thread->current_priority;                
    if ( priority >= search_priority )                                
      break;                                                          
#endif                                                                
    _ISR_Flash( level );                                              
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
ffc0ad14:	81 8b 00 10 	lwz     r12,16(r11)                            
ffc0ad18:	7d 3f 60 39 	and.    r31,r9,r12                             
ffc0ad1c:	40 a2 00 0c 	bne+    ffc0ad28 <_Thread_queue_Enqueue_priority+0x124>
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc0ad20:	7d 00 01 24 	mtmsr   r8                                     
ffc0ad24:	4b ff ff b8 	b       ffc0acdc <_Thread_queue_Enqueue_priority+0xd8>
      _ISR_Enable( level );                                           
      goto restart_reverse_search;                                    
    }                                                                 
    search_thread = (Thread_Control *)                                
ffc0ad28:	81 6b 00 04 	lwz     r11,4(r11)                             
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 ) ) {  
ffc0ad2c:	7f 8b 50 00 	cmpw    cr7,r11,r10                            
ffc0ad30:	40 9e ff cc 	bne+    cr7,ffc0acfc <_Thread_queue_Enqueue_priority+0xf8>
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
ffc0ad34:	81 43 00 30 	lwz     r10,48(r3)                             
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 ) ) {  
ffc0ad38:	7d 09 43 78 	mr      r9,r8                                  
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
ffc0ad3c:	2f 8a 00 01 	cmpwi   cr7,r10,1                              
ffc0ad40:	40 be 00 5c 	bne+    cr7,ffc0ad9c <_Thread_queue_Enqueue_priority+0x198>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
                                                                      
  if ( priority == search_priority )                                  
ffc0ad44:	7f 80 38 00 	cmpw    cr7,r0,r7                              
                                                                      
  if ( the_thread_queue->sync_state !=                                
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
ffc0ad48:	38 00 00 00 	li      r0,0                                   
ffc0ad4c:	90 03 00 30 	stw     r0,48(r3)                              
                                                                      
  if ( priority == search_priority )                                  
ffc0ad50:	41 9e 00 28 	beq-    cr7,ffc0ad78 <_Thread_queue_Enqueue_priority+0x174>
    goto equal_priority;                                              
                                                                      
  search_node = (Chain_Node *) search_thread;                         
  next_node   = search_node->next;                                    
ffc0ad54:	81 2b 00 00 	lwz     r9,0(r11)                              
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  the_node->previous      = search_node;                              
ffc0ad58:	91 64 00 04 	stw     r11,4(r4)                              
                                                                      
  search_node = (Chain_Node *) search_thread;                         
  next_node   = search_node->next;                                    
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
ffc0ad5c:	91 24 00 00 	stw     r9,0(r4)                               
  the_node->previous      = search_node;                              
  search_node->next       = the_node;                                 
  next_node->previous    = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
ffc0ad60:	90 64 00 44 	stw     r3,68(r4)                              
  next_node   = search_node->next;                                    
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  the_node->previous      = search_node;                              
  search_node->next       = the_node;                                 
ffc0ad64:	90 8b 00 00 	stw     r4,0(r11)                              
  next_node->previous    = the_node;                                  
ffc0ad68:	90 89 00 04 	stw     r4,4(r9)                               
ffc0ad6c:	7d 00 01 24 	mtmsr   r8                                     
ffc0ad70:	38 60 00 01 	li      r3,1                                   
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
ffc0ad74:	48 00 00 30 	b       ffc0ada4 <_Thread_queue_Enqueue_priority+0x1a0>
ffc0ad78:	39 6b 00 3c 	addi    r11,r11,60                             
                                                                      
  the_node->next         = search_node;                               
  the_node->previous     = previous_node;                             
  previous_node->next    = the_node;                                  
  search_node->previous  = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
ffc0ad7c:	90 64 00 44 	stw     r3,68(r4)                              
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
equal_priority:               /* add at end of priority group */      
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );        
  previous_node = search_node->previous;                              
ffc0ad80:	81 4b 00 04 	lwz     r10,4(r11)                             
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
ffc0ad84:	91 64 00 00 	stw     r11,0(r4)                              
  the_node->previous     = previous_node;                             
ffc0ad88:	91 44 00 04 	stw     r10,4(r4)                              
  previous_node->next    = the_node;                                  
ffc0ad8c:	90 8a 00 00 	stw     r4,0(r10)                              
  search_node->previous  = the_node;                                  
ffc0ad90:	90 8b 00 04 	stw     r4,4(r11)                              
ffc0ad94:	7d 20 01 24 	mtmsr   r9                                     
ffc0ad98:	4b ff ff d8 	b       ffc0ad70 <_Thread_queue_Enqueue_priority+0x16c>
   *  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;                                                   
ffc0ad9c:	91 25 00 00 	stw     r9,0(r5)                               
  return the_thread_queue->sync_state;                                
ffc0ada0:	80 63 00 30 	lwz     r3,48(r3)                              
}                                                                     
ffc0ada4:	83 e1 00 0c 	lwz     r31,12(r1)                             
ffc0ada8:	38 21 00 10 	addi    r1,r1,16                               
ffc0adac:	4e 80 00 20 	blr                                            
                                                                      
ffc19d0c <_Timer_server_Body>:                                        
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19d0c:	94 21 ff 98 	stwu    r1,-104(r1)                            
ffc19d10:	7c 08 02 a6 	mflr    r0                                     
ffc19d14:	92 01 00 28 	stw     r16,40(r1)                             
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
ffc19d18:	3a 01 00 08 	addi    r16,r1,8                               
ffc19d1c:	90 01 00 6c 	stw     r0,108(r1)                             
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
ffc19d20:	38 00 00 00 	li      r0,0                                   
ffc19d24:	93 01 00 48 	stw     r24,72(r1)                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
ffc19d28:	3b 01 00 0c 	addi    r24,r1,12                              
ffc19d2c:	93 61 00 54 	stw     r27,84(r1)                             
ffc19d30:	3b 61 00 18 	addi    r27,r1,24                              
ffc19d34:	93 c1 00 60 	stw     r30,96(r1)                             
ffc19d38:	3b c1 00 14 	addi    r30,r1,20                              
ffc19d3c:	92 21 00 2c 	stw     r17,44(r1)                             
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
ffc19d40:	3e 20 00 00 	lis     r17,0                                  
ffc19d44:	3a 31 28 c0 	addi    r17,r17,10432                          
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19d48:	92 41 00 30 	stw     r18,48(r1)                             
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ffc19d4c:	3e 40 00 00 	lis     r18,0                                  
ffc19d50:	3a 52 28 88 	addi    r18,r18,10376                          
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19d54:	93 21 00 4c 	stw     r25,76(r1)                             
ffc19d58:	3f 20 00 00 	lis     r25,0                                  
ffc19d5c:	3b 39 28 68 	addi    r25,r25,10344                          
ffc19d60:	93 a1 00 5c 	stw     r29,92(r1)                             
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
ffc19d64:	90 01 00 18 	stw     r0,24(r1)                              
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
ffc19d68:	93 01 00 08 	stw     r24,8(r1)                              
  the_chain->permanent_null = NULL;                                   
ffc19d6c:	90 01 00 0c 	stw     r0,12(r1)                              
  the_chain->last           = _Chain_Head(the_chain);                 
ffc19d70:	92 01 00 10 	stw     r16,16(r1)                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
ffc19d74:	93 61 00 14 	stw     r27,20(r1)                             
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
ffc19d78:	93 c1 00 1c 	stw     r30,28(r1)                             
ffc19d7c:	92 61 00 34 	stw     r19,52(r1)                             
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
ffc19d80:	3a 63 00 08 	addi    r19,r3,8                               
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19d84:	92 81 00 38 	stw     r20,56(r1)                             
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
ffc19d88:	3a 83 00 40 	addi    r20,r3,64                              
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19d8c:	92 a1 00 3c 	stw     r21,60(r1)                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
ffc19d90:	3a a0 00 00 	li      r21,0                                  
ffc19d94:	92 c1 00 40 	stw     r22,64(r1)                             
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
ffc19d98:	3a c0 00 00 	li      r22,0                                  
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19d9c:	92 e1 00 44 	stw     r23,68(r1)                             
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
        _Timer_server_Reset_interval_system_watchdog( ts );           
        _Timer_server_Reset_tod_system_watchdog( ts );                
      _Thread_Enable_dispatch();                                      
                                                                      
      ts->active = true;                                              
ffc19da0:	3a e0 00 01 	li      r23,1                                  
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19da4:	93 41 00 50 	stw     r26,80(r1)                             
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
ffc19da8:	3b 43 00 30 	addi    r26,r3,48                              
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19dac:	93 81 00 58 	stw     r28,88(r1)                             
    /*                                                                
     *  This path is for normal forward movement and cases where the  
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc19db0:	3b 83 00 68 	addi    r28,r3,104                             
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
ffc19db4:	93 e1 00 64 	stw     r31,100(r1)                            
ffc19db8:	7c 7f 1b 78 	mr      r31,r3                                 
{                                                                     
  /*                                                                  
   *  Afterwards all timer inserts are directed to this chain and the interval
   *  and TOD chains will be no more modified by other parties.       
   */                                                                 
  ts->insert_chain = insert_chain;                                    
ffc19dbc:	92 1f 00 78 	stw     r16,120(r31)                           
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
ffc19dc0:	80 11 00 00 	lwz     r0,0(r17)                              
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
ffc19dc4:	7f c5 f3 78 	mr      r5,r30                                 
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
ffc19dc8:	80 9f 00 3c 	lwz     r4,60(r31)                             
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
ffc19dcc:	7f 43 d3 78 	mr      r3,r26                                 
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
ffc19dd0:	90 1f 00 3c 	stw     r0,60(r31)                             
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
ffc19dd4:	7c 84 00 50 	subf    r4,r4,r0                               
ffc19dd8:	48 00 4f 69 	bl      ffc1ed40 <_Watchdog_Adjust_to_chain>   
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ffc19ddc:	83 b2 00 00 	lwz     r29,0(r18)                             
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;         
ffc19de0:	80 bf 00 74 	lwz     r5,116(r31)                            
  /*                                                                  
   *  Process the seconds chain.  Start by checking that the Time     
   *  of Day (TOD) has not been set backwards.  If it has then        
   *  we want to adjust the watchdogs->Chain to indicate this.        
   */                                                                 
  if ( snapshot > last_snapshot ) {                                   
ffc19de4:	7f 9d 28 40 	cmplw   cr7,r29,r5                             
ffc19de8:	40 bd 00 18 	ble+    cr7,ffc19e00 <_Timer_server_Body+0xf4> 
    /*                                                                
     *  This path is for normal forward movement and cases where the  
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc19dec:	7c 85 e8 50 	subf    r4,r5,r29                              
ffc19df0:	7f 83 e3 78 	mr      r3,r28                                 
ffc19df4:	7f c5 f3 78 	mr      r5,r30                                 
ffc19df8:	48 00 4f 49 	bl      ffc1ed40 <_Watchdog_Adjust_to_chain>   
ffc19dfc:	48 00 00 18 	b       ffc19e14 <_Timer_server_Body+0x108>    
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
ffc19e00:	40 bc 00 14 	bge+    cr7,ffc19e14 <_Timer_server_Body+0x108>
     /*                                                               
      *  The current TOD is before the last TOD which indicates that  
      *  TOD has been set backwards.                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
ffc19e04:	7c bd 28 50 	subf    r5,r29,r5                              
ffc19e08:	7f 83 e3 78 	mr      r3,r28                                 
ffc19e0c:	38 80 00 01 	li      r4,1                                   
ffc19e10:	48 00 4e 4d 	bl      ffc1ec5c <_Watchdog_Adjust>            
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
ffc19e14:	93 bf 00 74 	stw     r29,116(r31)                           
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
ffc19e18:	80 7f 00 78 	lwz     r3,120(r31)                            
ffc19e1c:	48 00 0b 79 	bl      ffc1a994 <_Chain_Get>                  
                                                                      
    if ( timer == NULL ) {                                            
ffc19e20:	7c 64 1b 79 	mr.     r4,r3                                  
ffc19e24:	41 82 00 34 	beq-    ffc19e58 <_Timer_server_Body+0x14c>    
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
ffc19e28:	80 04 00 38 	lwz     r0,56(r4)                              
ffc19e2c:	2f 00 00 01 	cmpwi   cr6,r0,1                               
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
ffc19e30:	2f 80 00 03 	cmpwi   cr7,r0,3                               
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
ffc19e34:	40 ba 00 10 	bne+    cr6,ffc19e44 <_Timer_server_Body+0x138>
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
ffc19e38:	38 84 00 10 	addi    r4,r4,16                               
ffc19e3c:	7f 43 d3 78 	mr      r3,r26                                 
ffc19e40:	48 00 00 10 	b       ffc19e50 <_Timer_server_Body+0x144>    
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
ffc19e44:	40 9e ff d4 	bne+    cr7,ffc19e18 <_Timer_server_Body+0x10c>
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
ffc19e48:	38 84 00 10 	addi    r4,r4,16                               
ffc19e4c:	7f 83 e3 78 	mr      r3,r28                                 
ffc19e50:	48 00 4f a9 	bl      ffc1edf8 <_Watchdog_Insert>            
ffc19e54:	4b ff ff c4 	b       ffc19e18 <_Timer_server_Body+0x10c>    
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc19e58:	7c 00 00 a6 	mfmsr   r0                                     
ffc19e5c:	7d 30 42 a6 	mfsprg  r9,0                                   
ffc19e60:	7c 09 48 78 	andc    r9,r0,r9                               
ffc19e64:	7d 20 01 24 	mtmsr   r9                                     
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
ffc19e68:	81 21 00 08 	lwz     r9,8(r1)                               
ffc19e6c:	7f 89 c0 00 	cmpw    cr7,r9,r24                             
ffc19e70:	40 be 00 1c 	bne+    cr7,ffc19e8c <_Timer_server_Body+0x180>
      ts->insert_chain = NULL;                                        
ffc19e74:	90 9f 00 78 	stw     r4,120(r31)                            
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc19e78:	7c 00 01 24 	mtmsr   r0                                     
  _Chain_Initialize_empty( &fire_chain );                             
                                                                      
  while ( true ) {                                                    
    _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
                                                                      
    if ( !_Chain_Is_empty( &fire_chain ) ) {                          
ffc19e7c:	80 01 00 14 	lwz     r0,20(r1)                              
ffc19e80:	7f 80 d8 00 	cmpw    cr7,r0,r27                             
ffc19e84:	40 be 00 10 	bne+    cr7,ffc19e94 <_Timer_server_Body+0x188>
ffc19e88:	48 00 00 64 	b       ffc19eec <_Timer_server_Body+0x1e0>    
ffc19e8c:	7c 00 01 24 	mtmsr   r0                                     <== NOT EXECUTED
ffc19e90:	4b ff ff 30 	b       ffc19dc0 <_Timer_server_Body+0xb4>     <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc19e94:	7c 00 00 a6 	mfmsr   r0                                     
ffc19e98:	7d 30 42 a6 	mfsprg  r9,0                                   
ffc19e9c:	7c 09 48 78 	andc    r9,r0,r9                               
ffc19ea0:	7d 20 01 24 	mtmsr   r9                                     
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
ffc19ea4:	81 21 00 14 	lwz     r9,20(r1)                              
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
ffc19ea8:	7f 09 d8 00 	cmpw    cr6,r9,r27                             
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
ffc19eac:	2f 89 00 00 	cmpwi   cr7,r9,0                               
ffc19eb0:	41 9a 00 34 	beq-    cr6,ffc19ee4 <_Timer_server_Body+0x1d8>
{                                                                     
  Chain_Node  *return_node;                                           
  Chain_Node  *new_first;                                             
                                                                      
  return_node         = the_chain->first;                             
  new_first           = return_node->next;                            
ffc19eb4:	81 69 00 00 	lwz     r11,0(r9)                              
  the_chain->first    = new_first;                                    
ffc19eb8:	91 61 00 14 	stw     r11,20(r1)                             
  new_first->previous = _Chain_Head(the_chain);                       
ffc19ebc:	93 cb 00 04 	stw     r30,4(r11)                             
ffc19ec0:	41 9e 00 24 	beq-    cr7,ffc19ee4 <_Timer_server_Body+0x1d8>
          watchdog->state = WATCHDOG_INACTIVE;                        
ffc19ec4:	92 a9 00 08 	stw     r21,8(r9)                              
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc19ec8:	7c 00 01 24 	mtmsr   r0                                     
        /*                                                            
         *  The timer server may block here and wait for resources or time.
         *  The system watchdogs are inactive and will remain inactive since
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
ffc19ecc:	80 09 00 1c 	lwz     r0,28(r9)                              
ffc19ed0:	80 89 00 24 	lwz     r4,36(r9)                              
ffc19ed4:	80 69 00 20 	lwz     r3,32(r9)                              
ffc19ed8:	7c 09 03 a6 	mtctr   r0                                     
ffc19edc:	4e 80 04 21 	bctrl                                          
      }                                                               
ffc19ee0:	4b ff ff b4 	b       ffc19e94 <_Timer_server_Body+0x188>    
ffc19ee4:	7c 00 01 24 	mtmsr   r0                                     
ffc19ee8:	4b ff fe d4 	b       ffc19dbc <_Timer_server_Body+0xb0>     
    } else {                                                          
      ts->active = false;                                             
ffc19eec:	9a df 00 7c 	stb     r22,124(r31)                           
ffc19ef0:	81 39 00 00 	lwz     r9,0(r25)                              
ffc19ef4:	38 09 00 01 	addi    r0,r9,1                                
ffc19ef8:	90 19 00 00 	stw     r0,0(r25)                              
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
ffc19efc:	80 7f 00 00 	lwz     r3,0(r31)                              
ffc19f00:	38 80 00 08 	li      r4,8                                   
ffc19f04:	48 00 41 75 	bl      ffc1e078 <_Thread_Set_state>           
        _Timer_server_Reset_interval_system_watchdog( ts );           
ffc19f08:	7f e3 fb 78 	mr      r3,r31                                 
ffc19f0c:	4b ff fd 01 	bl      ffc19c0c <_Timer_server_Reset_interval_system_watchdog>
        _Timer_server_Reset_tod_system_watchdog( ts );                
ffc19f10:	7f e3 fb 78 	mr      r3,r31                                 
ffc19f14:	4b ff fd 79 	bl      ffc19c8c <_Timer_server_Reset_tod_system_watchdog>
      _Thread_Enable_dispatch();                                      
ffc19f18:	48 00 35 15 	bl      ffc1d42c <_Thread_Enable_dispatch>     
                                                                      
      ts->active = true;                                              
ffc19f1c:	9a ff 00 7c 	stb     r23,124(r31)                           
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
ffc19f20:	7e 63 9b 78 	mr      r3,r19                                 
ffc19f24:	48 00 50 2d 	bl      ffc1ef50 <_Watchdog_Remove>            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
ffc19f28:	7e 83 a3 78 	mr      r3,r20                                 
ffc19f2c:	48 00 50 25 	bl      ffc1ef50 <_Watchdog_Remove>            
ffc19f30:	4b ff fe 8c 	b       ffc19dbc <_Timer_server_Body+0xb0>     
                                                                      
ffc0a370 <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                  
)                                                                     
{                                                                     
ffc0a370:	94 21 ff f0 	stwu    r1,-16(r1)                             
ffc0a374:	7c 08 02 a6 	mflr    r0                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
ffc0a378:	3d 20 00 00 	lis     r9,0                                   
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                  
)                                                                     
{                                                                     
ffc0a37c:	90 01 00 14 	stw     r0,20(r1)                              
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
ffc0a380:	80 09 27 b8 	lwz     r0,10168(r9)                           
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
ffc0a384:	3d 20 00 00 	lis     r9,0                                   
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                  
)                                                                     
{                                                                     
ffc0a388:	93 e1 00 0c 	stw     r31,12(r1)                             
ffc0a38c:	7c 7f 1b 78 	mr      r31,r3                                 
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
ffc0a390:	2f 80 00 00 	cmpwi   cr7,r0,0                               
ffc0a394:	38 60 00 12 	li      r3,18                                  
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
ffc0a398:	80 09 28 08 	lwz     r0,10248(r9)                           
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
ffc0a39c:	40 9e 01 40 	bne-    cr7,ffc0a4dc <rtems_io_register_driver+0x16c>
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( registered_major == NULL )                                     
ffc0a3a0:	2f 85 00 00 	cmpwi   cr7,r5,0                               
ffc0a3a4:	41 9e 01 34 	beq-    cr7,ffc0a4d8 <rtems_io_register_driver+0x168>
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Set it to an invalid value */                                    
  *registered_major = major_limit;                                    
                                                                      
  if ( driver_table == NULL )                                         
ffc0a3a8:	2f 84 00 00 	cmpwi   cr7,r4,0                               
                                                                      
  if ( registered_major == NULL )                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Set it to an invalid value */                                    
  *registered_major = major_limit;                                    
ffc0a3ac:	90 05 00 00 	stw     r0,0(r5)                               
                                                                      
  if ( driver_table == NULL )                                         
ffc0a3b0:	41 9e 01 28 	beq-    cr7,ffc0a4d8 <rtems_io_register_driver+0x168>
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0a3b4:	81 24 00 00 	lwz     r9,0(r4)                               
ffc0a3b8:	2f 89 00 00 	cmpwi   cr7,r9,0                               
ffc0a3bc:	40 be 01 34 	bne+    cr7,ffc0a4f0 <rtems_io_register_driver+0x180>
ffc0a3c0:	81 24 00 04 	lwz     r9,4(r4)                               
ffc0a3c4:	2f 89 00 00 	cmpwi   cr7,r9,0                               
ffc0a3c8:	40 be 01 28 	bne+    cr7,ffc0a4f0 <rtems_io_register_driver+0x180>
ffc0a3cc:	48 00 01 0c 	b       ffc0a4d8 <rtems_io_register_driver+0x168>
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
ffc0a3d0:	3d 20 00 00 	lis     r9,0                                   
ffc0a3d4:	81 69 27 90 	lwz     r11,10128(r9)                          
ffc0a3d8:	38 0b 00 01 	addi    r0,r11,1                               
ffc0a3dc:	90 09 27 90 	stw     r0,10128(r9)                           
  if ( major >= major_limit )                                         
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( major == 0 ) {                                                 
ffc0a3e0:	2f 9f 00 00 	cmpwi   cr7,r31,0                              
ffc0a3e4:	3d 20 00 00 	lis     r9,0                                   
ffc0a3e8:	40 9e 00 58 	bne-    cr7,ffc0a440 <rtems_io_register_driver+0xd0>
                                                                      
static rtems_status_code rtems_io_obtain_major_number(                
  rtems_device_major_number *major                                    
)                                                                     
{                                                                     
  rtems_device_major_number n = _IO_Number_of_drivers;                
ffc0a3ec:	3d 60 00 00 	lis     r11,0                                  
ffc0a3f0:	81 29 28 0c 	lwz     r9,10252(r9)                           
ffc0a3f4:	81 6b 28 08 	lwz     r11,10248(r11)                         
ffc0a3f8:	2f 8b 00 00 	cmpwi   cr7,r11,0                              
ffc0a3fc:	38 0b 00 01 	addi    r0,r11,1                               
ffc0a400:	40 be 00 28 	bne+    cr7,ffc0a428 <rtems_io_register_driver+0xb8>
ffc0a404:	38 00 00 01 	li      r0,1                                   <== NOT EXECUTED
ffc0a408:	48 00 00 20 	b       ffc0a428 <rtems_io_register_driver+0xb8><== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0a40c:	81 49 00 00 	lwz     r10,0(r9)                              
ffc0a410:	2f 8a 00 00 	cmpwi   cr7,r10,0                              
ffc0a414:	40 be 00 ec 	bne+    cr7,ffc0a500 <rtems_io_register_driver+0x190>
ffc0a418:	81 49 00 04 	lwz     r10,4(r9)                              
ffc0a41c:	2f 8a 00 00 	cmpwi   cr7,r10,0                              
ffc0a420:	40 be 00 e0 	bne+    cr7,ffc0a500 <rtems_io_register_driver+0x190>
ffc0a424:	48 00 00 0c 	b       ffc0a430 <rtems_io_register_driver+0xc0>
  rtems_device_major_number n = _IO_Number_of_drivers;                
  rtems_device_major_number m = 0;                                    
                                                                      
  /* major is error checked by caller */                              
                                                                      
  for ( m = 0; m < n; ++m ) {                                         
ffc0a428:	34 00 ff ff 	addic.  r0,r0,-1                               
ffc0a42c:	40 82 ff e0 	bne+    ffc0a40c <rtems_io_register_driver+0x9c>
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
                                                                      
  if ( m != n )                                                       
ffc0a430:	7f 9f 58 00 	cmpw    cr7,r31,r11                            
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
ffc0a434:	93 e5 00 00 	stw     r31,0(r5)                              
                                                                      
  if ( m != n )                                                       
ffc0a438:	40 be 00 48 	bne+    cr7,ffc0a480 <rtems_io_register_driver+0x110>
ffc0a43c:	48 00 00 d0 	b       ffc0a50c <rtems_io_register_driver+0x19c>
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
ffc0a440:	1c 1f 00 18 	mulli   r0,r31,24                              
ffc0a444:	81 29 28 0c 	lwz     r9,10252(r9)                           
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0a448:	7d 69 00 2e 	lwzx    r11,r9,r0                              
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
ffc0a44c:	7d 29 02 14 	add     r9,r9,r0                               
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0a450:	38 00 00 00 	li      r0,0                                   
ffc0a454:	2f 8b 00 00 	cmpwi   cr7,r11,0                              
ffc0a458:	40 be 00 10 	bne+    cr7,ffc0a468 <rtems_io_register_driver+0xf8>
ffc0a45c:	80 09 00 04 	lwz     r0,4(r9)                               
ffc0a460:	7c 00 00 34 	cntlzw  r0,r0                                  
ffc0a464:	54 00 d9 7e 	rlwinm  r0,r0,27,5,31                          
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
                                                                      
    if ( !rtems_io_is_empty_table( table ) ) {                        
ffc0a468:	2f 80 00 00 	cmpwi   cr7,r0,0                               
ffc0a46c:	40 9e 00 10 	bne-    cr7,ffc0a47c <rtems_io_register_driver+0x10c>
      _Thread_Enable_dispatch();                                      
ffc0a470:	48 00 20 0d 	bl      ffc0c47c <_Thread_Enable_dispatch>     
ffc0a474:	38 60 00 0c 	li      r3,12                                  
      return RTEMS_RESOURCE_IN_USE;                                   
ffc0a478:	48 00 00 64 	b       ffc0a4dc <rtems_io_register_driver+0x16c>
    }                                                                 
                                                                      
    *registered_major = major;                                        
ffc0a47c:	93 e5 00 00 	stw     r31,0(r5)                              
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
ffc0a480:	3d 20 00 00 	lis     r9,0                                   
ffc0a484:	80 c4 00 00 	lwz     r6,0(r4)                               
ffc0a488:	81 69 28 0c 	lwz     r11,10252(r9)                          
ffc0a48c:	1c 1f 00 18 	mulli   r0,r31,24                              
ffc0a490:	80 e4 00 04 	lwz     r7,4(r4)                               
ffc0a494:	81 04 00 08 	lwz     r8,8(r4)                               
ffc0a498:	7d 2b 02 14 	add     r9,r11,r0                              
ffc0a49c:	81 44 00 0c 	lwz     r10,12(r4)                             
ffc0a4a0:	7c cb 01 2e 	stwx    r6,r11,r0                              
ffc0a4a4:	90 e9 00 04 	stw     r7,4(r9)                               
ffc0a4a8:	91 09 00 08 	stw     r8,8(r9)                               
ffc0a4ac:	91 49 00 0c 	stw     r10,12(r9)                             
ffc0a4b0:	81 64 00 14 	lwz     r11,20(r4)                             
ffc0a4b4:	80 04 00 10 	lwz     r0,16(r4)                              
ffc0a4b8:	91 69 00 14 	stw     r11,20(r9)                             
ffc0a4bc:	90 09 00 10 	stw     r0,16(r9)                              
                                                                      
  _Thread_Enable_dispatch();                                          
ffc0a4c0:	48 00 1f bd 	bl      ffc0c47c <_Thread_Enable_dispatch>     
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
ffc0a4c4:	7f e3 fb 78 	mr      r3,r31                                 
ffc0a4c8:	38 80 00 00 	li      r4,0                                   
ffc0a4cc:	38 a0 00 00 	li      r5,0                                   
ffc0a4d0:	48 00 a1 ad 	bl      ffc1467c <rtems_io_initialize>         
ffc0a4d4:	48 00 00 08 	b       ffc0a4dc <rtems_io_register_driver+0x16c>
ffc0a4d8:	38 60 00 09 	li      r3,9                                   
}                                                                     
ffc0a4dc:	80 01 00 14 	lwz     r0,20(r1)                              
ffc0a4e0:	83 e1 00 0c 	lwz     r31,12(r1)                             
ffc0a4e4:	38 21 00 10 	addi    r1,r1,16                               
ffc0a4e8:	7c 08 03 a6 	mtlr    r0                                     
ffc0a4ec:	4e 80 00 20 	blr                                            
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( major >= major_limit )                                         
ffc0a4f0:	7f 9f 00 40 	cmplw   cr7,r31,r0                             
ffc0a4f4:	38 60 00 0a 	li      r3,10                                  
ffc0a4f8:	41 9c fe d8 	blt+    cr7,ffc0a3d0 <rtems_io_register_driver+0x60>
ffc0a4fc:	4b ff ff e0 	b       ffc0a4dc <rtems_io_register_driver+0x16c>
  rtems_device_major_number n = _IO_Number_of_drivers;                
  rtems_device_major_number m = 0;                                    
                                                                      
  /* major is error checked by caller */                              
                                                                      
  for ( m = 0; m < n; ++m ) {                                         
ffc0a500:	3b ff 00 01 	addi    r31,r31,1                              
ffc0a504:	39 29 00 18 	addi    r9,r9,24                               
ffc0a508:	4b ff ff 20 	b       ffc0a428 <rtems_io_register_driver+0xb8>
                                                                      
  if ( major == 0 ) {                                                 
    rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
                                                                      
    if ( sc != RTEMS_SUCCESSFUL ) {                                   
      _Thread_Enable_dispatch();                                      
ffc0a50c:	48 00 1f 71 	bl      ffc0c47c <_Thread_Enable_dispatch>     
ffc0a510:	38 60 00 05 	li      r3,5                                   
      return sc;                                                      
ffc0a514:	4b ff ff c8 	b       ffc0a4dc <rtems_io_register_driver+0x16c>
                                                                      
ffc41a1c <rtems_rate_monotonic_period>:                               
                                                                      
rtems_status_code rtems_rate_monotonic_period(                        
  rtems_id       id,                                                  
  rtems_interval length                                               
)                                                                     
{                                                                     
ffc41a1c:	94 21 ff d8 	stwu    r1,-40(r1)                             
ffc41a20:	7c 08 02 a6 	mflr    r0                                     
ffc41a24:	93 c1 00 20 	stw     r30,32(r1)                             
ffc41a28:	7c 7e 1b 78 	mr      r30,r3                                 
ffc41a2c:	3c 60 00 00 	lis     r3,0                                   
ffc41a30:	93 e1 00 24 	stw     r31,36(r1)                             
ffc41a34:	38 63 6f ec 	addi    r3,r3,28652                            
ffc41a38:	7c 9f 23 78 	mr      r31,r4                                 
ffc41a3c:	38 a1 00 08 	addi    r5,r1,8                                
ffc41a40:	90 01 00 2c 	stw     r0,44(r1)                              
ffc41a44:	7f c4 f3 78 	mr      r4,r30                                 
ffc41a48:	93 a1 00 1c 	stw     r29,28(r1)                             
ffc41a4c:	93 81 00 18 	stw     r28,24(r1)                             
ffc41a50:	4b fc c2 01 	bl      ffc0dc50 <_Objects_Get>                
ffc41a54:	7c 7d 1b 78 	mr      r29,r3                                 
  rtems_rate_monotonic_period_states   local_state;                   
  ISR_Level                            level;                         
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
                                                                      
  switch ( location ) {                                               
ffc41a58:	80 01 00 08 	lwz     r0,8(r1)                               
ffc41a5c:	2f 80 00 00 	cmpwi   cr7,r0,0                               
ffc41a60:	40 9e 01 70 	bne-    cr7,ffc41bd0 <rtems_rate_monotonic_period+0x1b4>
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
ffc41a64:	3d 20 00 00 	lis     r9,0                                   
ffc41a68:	80 09 36 58 	lwz     r0,13912(r9)                           
ffc41a6c:	81 23 00 40 	lwz     r9,64(r3)                              
ffc41a70:	7f 89 00 00 	cmpw    cr7,r9,r0                              
ffc41a74:	41 9e 00 10 	beq-    cr7,ffc41a84 <rtems_rate_monotonic_period+0x68>
        _Thread_Enable_dispatch();                                    
ffc41a78:	4b fc ce 15 	bl      ffc0e88c <_Thread_Enable_dispatch>     
ffc41a7c:	3b c0 00 17 	li      r30,23                                 
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
ffc41a80:	48 00 01 54 	b       ffc41bd4 <rtems_rate_monotonic_period+0x1b8>
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
ffc41a84:	2f 9f 00 00 	cmpwi   cr7,r31,0                              
ffc41a88:	40 be 00 28 	bne+    cr7,ffc41ab0 <rtems_rate_monotonic_period+0x94>
        switch ( the_period->state ) {                                
ffc41a8c:	80 03 00 38 	lwz     r0,56(r3)                              
ffc41a90:	3b c0 00 00 	li      r30,0                                  
ffc41a94:	2b 80 00 04 	cmplwi  cr7,r0,4                               
ffc41a98:	41 9d 01 30 	bgt-    cr7,ffc41bc8 <rtems_rate_monotonic_period+0x1ac>
ffc41a9c:	3d 20 ff c7 	lis     r9,-57                                 
ffc41aa0:	54 00 10 3a 	rlwinm  r0,r0,2,0,29                           
ffc41aa4:	39 29 bd e4 	addi    r9,r9,-16924                           
ffc41aa8:	7f c9 00 2e 	lwzx    r30,r9,r0                              
ffc41aac:	48 00 01 1c 	b       ffc41bc8 <rtems_rate_monotonic_period+0x1ac>
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc41ab0:	7f 80 00 a6 	mfmsr   r28                                    
ffc41ab4:	7c 10 42 a6 	mfsprg  r0,0                                   
ffc41ab8:	7f 80 00 78 	andc    r0,r28,r0                              
ffc41abc:	7c 00 01 24 	mtmsr   r0                                     
        _Thread_Enable_dispatch();                                    
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
      switch ( the_period->state ) {                                  
ffc41ac0:	80 03 00 38 	lwz     r0,56(r3)                              
ffc41ac4:	2f 80 00 02 	cmpwi   cr7,r0,2                               
ffc41ac8:	41 9e 00 60 	beq-    cr7,ffc41b28 <rtems_rate_monotonic_period+0x10c>
ffc41acc:	2f 80 00 04 	cmpwi   cr7,r0,4                               
ffc41ad0:	41 9e 00 cc 	beq-    cr7,ffc41b9c <rtems_rate_monotonic_period+0x180>
ffc41ad4:	2f 80 00 00 	cmpwi   cr7,r0,0                               
ffc41ad8:	40 9e 00 f8 	bne-    cr7,ffc41bd0 <rtems_rate_monotonic_period+0x1b4>
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc41adc:	7f 80 01 24 	mtmsr   r28                                    
          _ISR_Enable( level );                                       
                                                                      
          /*                                                          
           *  Baseline statistics information for the beginning of a period.
           */                                                         
          _Rate_monotonic_Initiate_statistics( the_period );          
ffc41ae0:	4b ff fc 99 	bl      ffc41778 <_Rate_monotonic_Initiate_statistics>
                                                                      
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
ffc41ae4:	39 20 00 02 	li      r9,2                                   
ffc41ae8:	91 3d 00 38 	stw     r9,56(r29)                             
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
ffc41aec:	3d 20 ff c4 	lis     r9,-60                                 
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
ffc41af0:	38 00 00 00 	li      r0,0                                   
  the_watchdog->routine   = routine;                                  
ffc41af4:	39 29 1b f8 	addi    r9,r9,7160                             
  the_watchdog->id        = id;                                       
ffc41af8:	93 dd 00 30 	stw     r30,48(r29)                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
ffc41afc:	3c 60 00 00 	lis     r3,0                                   
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
ffc41b00:	91 3d 00 2c 	stw     r9,44(r29)                             
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
ffc41b04:	38 63 65 e8 	addi    r3,r3,26088                            
ffc41b08:	38 9d 00 10 	addi    r4,r29,16                              
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
ffc41b0c:	90 1d 00 34 	stw     r0,52(r29)                             
          );                                                          
                                                                      
          the_period->next_length = length;                           
                                                                      
          _Watchdog_Insert_ticks( &the_period->Timer, length );       
          _Thread_Enable_dispatch();                                  
ffc41b10:	3b c0 00 00 	li      r30,0                                  
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
ffc41b14:	93 fd 00 1c 	stw     r31,28(r29)                            
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
ffc41b18:	90 1d 00 18 	stw     r0,24(r29)                             
            _Rate_monotonic_Timeout,                                  
            id,                                                       
            NULL                                                      
          );                                                          
                                                                      
          the_period->next_length = length;                           
ffc41b1c:	93 fd 00 3c 	stw     r31,60(r29)                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
ffc41b20:	4b fc e2 e1 	bl      ffc0fe00 <_Watchdog_Insert>            
ffc41b24:	48 00 00 a4 	b       ffc41bc8 <rtems_rate_monotonic_period+0x1ac>
        case RATE_MONOTONIC_ACTIVE:                                   
                                                                      
          /*                                                          
           *  Update statistics from the concluding period.           
           */                                                         
          _Rate_monotonic_Update_statistics( the_period );            
ffc41b28:	4b ff fd d9 	bl      ffc41900 <_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;       
ffc41b2c:	38 00 00 01 	li      r0,1                                   
          the_period->next_length = length;                           
ffc41b30:	93 fd 00 3c 	stw     r31,60(r29)                            
          /*                                                          
           *  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;       
ffc41b34:	90 1d 00 38 	stw     r0,56(r29)                             
ffc41b38:	7f 80 01 24 	mtmsr   r28                                    
          the_period->next_length = length;                           
                                                                      
          _ISR_Enable( level );                                       
                                                                      
          _Thread_Executing->Wait.id = the_period->Object.id;         
ffc41b3c:	3d 20 00 00 	lis     r9,0                                   
ffc41b40:	80 1d 00 08 	lwz     r0,8(r29)                              
ffc41b44:	81 29 36 58 	lwz     r9,13912(r9)                           
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc41b48:	38 80 40 00 	li      r4,16384                               
          the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;       
          the_period->next_length = length;                           
                                                                      
          _ISR_Enable( level );                                       
                                                                      
          _Thread_Executing->Wait.id = the_period->Object.id;         
ffc41b4c:	90 09 00 20 	stw     r0,32(r9)                              
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc41b50:	7d 23 4b 78 	mr      r3,r9                                  
ffc41b54:	4b fc d7 c5 	bl      ffc0f318 <_Thread_Set_state>           
static inline uint32_t ppc_interrupt_disable( void )                  
{                                                                     
  uint32_t level;                                                     
  uint32_t mask;                                                      
                                                                      
  asm volatile (                                                      
ffc41b58:	7d 20 00 a6 	mfmsr   r9                                     
ffc41b5c:	7c 10 42 a6 	mfsprg  r0,0                                   
ffc41b60:	7d 20 00 78 	andc    r0,r9,r0                               
ffc41b64:	7c 00 01 24 	mtmsr   r0                                     
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?                                                  
           */                                                         
          _ISR_Disable( level );                                      
            local_state = the_period->state;                          
            the_period->state = RATE_MONOTONIC_ACTIVE;                
ffc41b68:	39 60 00 02 	li      r11,2                                  
          /*                                                          
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?                                                  
           */                                                         
          _ISR_Disable( level );                                      
            local_state = the_period->state;                          
ffc41b6c:	80 1d 00 38 	lwz     r0,56(r29)                             
            the_period->state = RATE_MONOTONIC_ACTIVE;                
ffc41b70:	91 7d 00 38 	stw     r11,56(r29)                            
  return level;                                                       
}                                                                     
                                                                      
static inline void ppc_interrupt_enable( uint32_t level )             
{                                                                     
  asm volatile (                                                      
ffc41b74:	7d 20 01 24 	mtmsr   r9                                     
                                                                      
          /*                                                          
           *  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 ) 
ffc41b78:	2f 80 00 03 	cmpwi   cr7,r0,3                               
ffc41b7c:	40 be 00 14 	bne+    cr7,ffc41b90 <rtems_rate_monotonic_period+0x174>
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc41b80:	3d 20 00 00 	lis     r9,0                                   <== NOT EXECUTED
ffc41b84:	80 69 36 58 	lwz     r3,13912(r9)                           <== NOT EXECUTED
ffc41b88:	38 80 40 00 	li      r4,16384                               <== NOT EXECUTED
ffc41b8c:	4b fc c8 1d 	bl      ffc0e3a8 <_Thread_Clear_state>         <== NOT EXECUTED
                                                                      
          _Thread_Enable_dispatch();                                  
ffc41b90:	4b fc cc fd 	bl      ffc0e88c <_Thread_Enable_dispatch>     
ffc41b94:	3b c0 00 00 	li      r30,0                                  
          return RTEMS_SUCCESSFUL;                                    
ffc41b98:	48 00 00 3c 	b       ffc41bd4 <rtems_rate_monotonic_period+0x1b8>
        case RATE_MONOTONIC_EXPIRED:                                  
                                                                      
          /*                                                          
           *  Update statistics from the concluding period            
           */                                                         
          _Rate_monotonic_Update_statistics( the_period );            
ffc41b9c:	4b ff fd 65 	bl      ffc41900 <_Rate_monotonic_Update_statistics>
ffc41ba0:	7f 80 01 24 	mtmsr   r28                                    
                                                                      
          _ISR_Enable( level );                                       
                                                                      
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
ffc41ba4:	38 00 00 02 	li      r0,2                                   
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
ffc41ba8:	93 fd 00 1c 	stw     r31,28(r29)                            
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
ffc41bac:	3c 60 00 00 	lis     r3,0                                   
ffc41bb0:	90 1d 00 38 	stw     r0,56(r29)                             
ffc41bb4:	38 63 65 e8 	addi    r3,r3,26088                            
ffc41bb8:	38 9d 00 10 	addi    r4,r29,16                              
          the_period->next_length = length;                           
ffc41bbc:	93 fd 00 3c 	stw     r31,60(r29)                            
                                                                      
          _Watchdog_Insert_ticks( &the_period->Timer, length );       
          _Thread_Enable_dispatch();                                  
ffc41bc0:	3b c0 00 06 	li      r30,6                                  
ffc41bc4:	4b fc e2 3d 	bl      ffc0fe00 <_Watchdog_Insert>            
ffc41bc8:	4b fc cc c5 	bl      ffc0e88c <_Thread_Enable_dispatch>     
          return RTEMS_TIMEOUT;                                       
ffc41bcc:	48 00 00 08 	b       ffc41bd4 <rtems_rate_monotonic_period+0x1b8>
ffc41bd0:	3b c0 00 04 	li      r30,4                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
ffc41bd4:	80 01 00 2c 	lwz     r0,44(r1)                              
ffc41bd8:	7f c3 f3 78 	mr      r3,r30                                 
ffc41bdc:	83 81 00 18 	lwz     r28,24(r1)                             
ffc41be0:	7c 08 03 a6 	mtlr    r0                                     
ffc41be4:	83 a1 00 1c 	lwz     r29,28(r1)                             
ffc41be8:	83 c1 00 20 	lwz     r30,32(r1)                             
ffc41bec:	83 e1 00 24 	lwz     r31,36(r1)                             
ffc41bf0:	38 21 00 28 	addi    r1,r1,40                               
ffc41bf4:	4e 80 00 20 	blr