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 f9 91 	addi    r3,r3,-1647
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 f9 9c 	addi    r3,r3,-1636
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 a4 41 	bl      ffc12afc <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 93 45 	bl      ffc129fc <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 93 35 	bl      ffc129fc <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 93 1d 	bl      ffc129fc <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 4f 95 	bl      ffc0e75c <_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 4a 2d 	bl      ffc0e734 <_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

ffc08164 <_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)
{
ffc08164:	94 21 ff f0 	stwu    r1,-16(r1)
ffc08168:	7c 08 02 a6 	mflr    r0
ffc0816c:	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 ) ||
ffc08170:	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;
ffc08174:	81 24 00 68 	lwz     r9,104(r4)

  /* The timer must be reprogrammed */
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||
ffc08178:	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)
{
ffc0817c:	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;
ffc08180:	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)
{
ffc08184:	7c 9f 23 78 	mr      r31,r4
  bool                 activated;

  ptimer = (POSIX_Timer_Control *)data;

  /* Increment the number of expirations. */
  ptimer->overrun = ptimer->overrun + 1;
ffc08188:	90 04 00 68 	stw     r0,104(r4)

  /* The timer must be reprogrammed */
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||
ffc0818c:	40 9e 00 10 	bne-    cr7,ffc0819c <_POSIX_Timer_TSR+0x38>
       ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
ffc08190:	80 04 00 58 	lwz     r0,88(r4)
ffc08194:	2f 80 00 00 	cmpwi   cr7,r0,0
ffc08198:	41 9e 00 38 	beq-    cr7,ffc081d0 <_POSIX_Timer_TSR+0x6c>
    activated = _POSIX_Timer_Insert_helper(
ffc0819c:	80 9f 00 64 	lwz     r4,100(r31)
ffc081a0:	3c c0 ff c1 	lis     r6,-63
ffc081a4:	80 bf 00 08 	lwz     r5,8(r31)
ffc081a8:	38 c6 81 64 	addi    r6,r6,-32412
ffc081ac:	38 7f 00 10 	addi    r3,r31,16
ffc081b0:	7f e7 fb 78 	mr      r7,r31
ffc081b4:	48 00 6e d1 	bl      ffc0f084 <_POSIX_Timer_Insert_helper>
      ptimer->ticks,
      ptimer->Object.id,
      _POSIX_Timer_TSR,
      ptimer
    );
    if ( !activated )
ffc081b8:	2f 83 00 00 	cmpwi   cr7,r3,0
ffc081bc:	41 be 00 30 	beq+    cr7,ffc081ec <_POSIX_Timer_TSR+0x88>
      return;

    /* Store the time when the timer was started again */
    _TOD_Get( &ptimer->time );
ffc081c0:	38 7f 00 6c 	addi    r3,r31,108
ffc081c4:	48 00 1b 79 	bl      ffc09d3c <_TOD_Get>

    /* The state really did not change but just to be safe */
    ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
ffc081c8:	38 00 00 03 	li      r0,3
ffc081cc:	48 00 00 08 	b       ffc081d4 <_POSIX_Timer_TSR+0x70>
  } else {
   /* Indicates that the timer is stopped */
   ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
ffc081d0:	38 00 00 04 	li      r0,4                                         	<== NOT EXECUTED
ffc081d4:	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 ) ) {
ffc081d8:	80 7f 00 38 	lwz     r3,56(r31)
ffc081dc:	80 9f 00 44 	lwz     r4,68(r31)
ffc081e0:	48 00 69 19 	bl      ffc0eaf8 <pthread_kill>
  }

  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.
   */
  ptimer->overrun = 0;
ffc081e4:	38 00 00 00 	li      r0,0
ffc081e8:	90 1f 00 68 	stw     r0,104(r31)
}
ffc081ec:	80 01 00 14 	lwz     r0,20(r1)
ffc081f0:	83 e1 00 0c 	lwz     r31,12(r1)
ffc081f4:	38 21 00 10 	addi    r1,r1,16
ffc081f8:	7c 08 03 a6 	mtlr    r0
ffc081fc:	4e 80 00 20 	blr

ffc0bf74 <_Thread_Restart>:
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
ffc0bf74:	94 21 ff e8 	stwu    r1,-24(r1)
ffc0bf78:	7c 08 02 a6 	mflr    r0
ffc0bf7c:	90 01 00 1c 	stw     r0,28(r1)
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
ffc0bf80:	80 03 00 10 	lwz     r0,16(r3)
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
ffc0bf84:	93 e1 00 14 	stw     r31,20(r1)
ffc0bf88:	7c 7f 1b 78 	mr      r31,r3
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
ffc0bf8c:	70 09 00 01 	andi.   r9,r0,1
ffc0bf90:	38 00 00 00 	li      r0,0
ffc0bf94:	40 a2 00 74 	bne+    ffc0c008 <_Thread_Restart+0x94>

    _Thread_Set_transient( the_thread );
ffc0bf98:	90 81 00 08 	stw     r4,8(r1)
ffc0bf9c:	90 a1 00 0c 	stw     r5,12(r1)
ffc0bfa0:	48 00 01 f5 	bl      ffc0c194 <_Thread_Set_transient>

    _Thread_Reset( the_thread, pointer_argument, numeric_argument );
ffc0bfa4:	7f e3 fb 78 	mr      r3,r31
ffc0bfa8:	80 81 00 08 	lwz     r4,8(r1)
ffc0bfac:	80 a1 00 0c 	lwz     r5,12(r1)
ffc0bfb0:	48 00 44 45 	bl      ffc103f4 <_Thread_Reset>

    _Thread_Load_environment( the_thread );
ffc0bfb4:	7f e3 fb 78 	mr      r3,r31
ffc0bfb8:	48 00 40 39 	bl      ffc0fff0 <_Thread_Load_environment>

    _Thread_Ready( the_thread );
ffc0bfbc:	7f e3 fb 78 	mr      r3,r31
ffc0bfc0:	48 00 43 59 	bl      ffc10318 <_Thread_Ready>

    _User_extensions_Thread_restart( the_thread );
ffc0bfc4:	7f e3 fb 78 	mr      r3,r31
ffc0bfc8:	48 00 0a a1 	bl      ffc0ca68 <_User_extensions_Thread_restart>

    if ( _Thread_Is_executing ( the_thread ) )
ffc0bfcc:	3d 20 00 00 	lis     r9,0
ffc0bfd0:	81 29 27 fc 	lwz     r9,10236(r9)
ffc0bfd4:	38 00 00 01 	li      r0,1
ffc0bfd8:	7f 9f 48 00 	cmpw    cr7,r31,r9
ffc0bfdc:	40 be 00 2c 	bne+    cr7,ffc0c008 <_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 )
ffc0bfe0:	80 1f 01 3c 	lwz     r0,316(r31)
ffc0bfe4:	2f 80 00 00 	cmpwi   cr7,r0,0
ffc0bfe8:	41 9e 00 0c 	beq-    cr7,ffc0bff4 <_Thread_Restart+0x80>
    _Context_Restore_fp( &_Thread_Executing->fp_context );
ffc0bfec:	38 7f 01 3c 	addi    r3,r31,316
ffc0bff0:	48 01 44 f1 	bl      ffc204e0 <_CPU_Context_restore_fp>
#endif

  _CPU_Context_Restart_self( &_Thread_Executing->Registers );
ffc0bff4:	3d 20 00 00 	lis     r9,0
ffc0bff8:	80 69 27 fc 	lwz     r3,10236(r9)
ffc0bffc:	38 63 00 dc 	addi    r3,r3,220
ffc0c000:	48 01 46 a1 	bl      ffc206a0 <_CPU_Context_restore>
ffc0c004:	38 00 00 01 	li      r0,1                                         	<== NOT EXECUTED

    return true;
  }

  return false;
}
ffc0c008:	7c 03 03 78 	mr      r3,r0
ffc0c00c:	80 01 00 1c 	lwz     r0,28(r1)
ffc0c010:	83 e1 00 14 	lwz     r31,20(r1)
ffc0c014:	38 21 00 18 	addi    r1,r1,24
ffc0c018:	7c 08 03 a6 	mtlr    r0
ffc0c01c:	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

ffc07690 <rtems_clock_tick>:
 *
 *  NOTE: This routine only works for leap-years through 2099.
 */

rtems_status_code rtems_clock_tick( void )
{
ffc07690:	7c 08 02 a6 	mflr    r0
ffc07694:	94 21 ff f8 	stwu    r1,-8(r1)
ffc07698:	90 01 00 0c 	stw     r0,12(r1)
  _TOD_Tickle_ticks();
ffc0769c:	48 00 19 1d 	bl      ffc08fb8 <_TOD_Tickle_ticks>
 */

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{

  _Watchdog_Tickle( &_Watchdog_Ticks_chain );
ffc076a0:	3c 60 00 00 	lis     r3,0
ffc076a4:	38 63 2d 48 	addi    r3,r3,11592
ffc076a8:	48 00 46 09 	bl      ffc0bcb0 <_Watchdog_Tickle>

  _Watchdog_Tickle_ticks();

  _Thread_Tickle_timeslice();
ffc076ac:	48 00 3d 8d 	bl      ffc0b438 <_Thread_Tickle_timeslice>
 *  otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
  return ( _Context_Switch_necessary );
ffc076b0:	3d 20 00 00 	lis     r9,0
ffc076b4:	88 09 27 c0 	lbz     r0,10176(r9)

  if ( _Thread_Is_context_switch_necessary() &&
ffc076b8:	2f 80 00 00 	cmpwi   cr7,r0,0
ffc076bc:	41 9e 00 18 	beq-    cr7,ffc076d4 <rtems_clock_tick+0x44>
 *  otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
  return ( _Thread_Dispatch_disable_level == 0 );
ffc076c0:	3d 20 00 00 	lis     r9,0
ffc076c4:	80 09 27 70 	lwz     r0,10096(r9)
ffc076c8:	2f 80 00 00 	cmpwi   cr7,r0,0
ffc076cc:	40 be 00 08 	bne+    cr7,ffc076d4 <rtems_clock_tick+0x44>
       _Thread_Is_dispatching_enabled() )
    _Thread_Dispatch();
ffc076d0:	48 00 2c 79 	bl      ffc0a348 <_Thread_Dispatch>                  	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
ffc076d4:	80 01 00 0c 	lwz     r0,12(r1)
ffc076d8:	38 60 00 00 	li      r3,0
ffc076dc:	38 21 00 08 	addi    r1,r1,8
ffc076e0:	7c 08 03 a6 	mtlr    r0
ffc076e4:	4e 80 00 20 	blr

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 a3 21 	bl      ffc147f0 <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>

ffc41d70 <rtems_rate_monotonic_period>:

rtems_status_code rtems_rate_monotonic_period(
  rtems_id       id,
  rtems_interval length
)
{
ffc41d70:	94 21 ff d8 	stwu    r1,-40(r1)
ffc41d74:	7c 08 02 a6 	mflr    r0
ffc41d78:	93 c1 00 20 	stw     r30,32(r1)
ffc41d7c:	7c 7e 1b 78 	mr      r30,r3
ffc41d80:	3c 60 00 00 	lis     r3,0
ffc41d84:	93 e1 00 24 	stw     r31,36(r1)
ffc41d88:	38 63 6f ec 	addi    r3,r3,28652
ffc41d8c:	7c 9f 23 78 	mr      r31,r4
ffc41d90:	38 a1 00 08 	addi    r5,r1,8
ffc41d94:	90 01 00 2c 	stw     r0,44(r1)
ffc41d98:	7f c4 f3 78 	mr      r4,r30
ffc41d9c:	93 a1 00 1c 	stw     r29,28(r1)
ffc41da0:	93 81 00 18 	stw     r28,24(r1)
ffc41da4:	4b fc d7 55 	bl      ffc0f4f8 <_Objects_Get>
ffc41da8:	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 ) {
ffc41dac:	80 01 00 08 	lwz     r0,8(r1)
ffc41db0:	2f 80 00 00 	cmpwi   cr7,r0,0
ffc41db4:	40 9e 01 70 	bne-    cr7,ffc41f24 <rtems_rate_monotonic_period+0x1b4>
    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
ffc41db8:	3d 20 00 00 	lis     r9,0
ffc41dbc:	80 09 36 58 	lwz     r0,13912(r9)
ffc41dc0:	81 23 00 40 	lwz     r9,64(r3)
ffc41dc4:	7f 89 00 00 	cmpw    cr7,r9,r0
ffc41dc8:	41 9e 00 10 	beq-    cr7,ffc41dd8 <rtems_rate_monotonic_period+0x68>
        _Thread_Enable_dispatch();
ffc41dcc:	4b fc e3 69 	bl      ffc10134 <_Thread_Enable_dispatch>
ffc41dd0:	3b c0 00 17 	li      r30,23
        return RTEMS_NOT_OWNER_OF_RESOURCE;
ffc41dd4:	48 00 01 54 	b       ffc41f28 <rtems_rate_monotonic_period+0x1b8>
      }

      if ( length == RTEMS_PERIOD_STATUS ) {
ffc41dd8:	2f 9f 00 00 	cmpwi   cr7,r31,0
ffc41ddc:	40 be 00 28 	bne+    cr7,ffc41e04 <rtems_rate_monotonic_period+0x94>
        switch ( the_period->state ) {
ffc41de0:	80 03 00 38 	lwz     r0,56(r3)
ffc41de4:	3b c0 00 00 	li      r30,0
ffc41de8:	2b 80 00 04 	cmplwi  cr7,r0,4
ffc41dec:	41 9d 01 30 	bgt-    cr7,ffc41f1c <rtems_rate_monotonic_period+0x1ac>
ffc41df0:	3d 20 ff c7 	lis     r9,-57
ffc41df4:	54 00 10 3a 	rlwinm  r0,r0,2,0,29
ffc41df8:	39 29 c0 a0 	addi    r9,r9,-16224
ffc41dfc:	7f c9 00 2e 	lwzx    r30,r9,r0
ffc41e00:	48 00 01 1c 	b       ffc41f1c <rtems_rate_monotonic_period+0x1ac>
static inline uint32_t ppc_interrupt_disable( void )
{
  uint32_t level;
  uint32_t mask;

  asm volatile (
ffc41e04:	7f 80 00 a6 	mfmsr   r28
ffc41e08:	7c 10 42 a6 	mfsprg  r0,0
ffc41e0c:	7f 80 00 78 	andc    r0,r28,r0
ffc41e10:	7c 00 01 24 	mtmsr   r0
        _Thread_Enable_dispatch();
        return( return_value );
      }

      _ISR_Disable( level );
      switch ( the_period->state ) {
ffc41e14:	80 03 00 38 	lwz     r0,56(r3)
ffc41e18:	2f 80 00 02 	cmpwi   cr7,r0,2
ffc41e1c:	41 9e 00 60 	beq-    cr7,ffc41e7c <rtems_rate_monotonic_period+0x10c>
ffc41e20:	2f 80 00 04 	cmpwi   cr7,r0,4
ffc41e24:	41 9e 00 cc 	beq-    cr7,ffc41ef0 <rtems_rate_monotonic_period+0x180>
ffc41e28:	2f 80 00 00 	cmpwi   cr7,r0,0
ffc41e2c:	40 9e 00 f8 	bne-    cr7,ffc41f24 <rtems_rate_monotonic_period+0x1b4>
  return level;
}

static inline void ppc_interrupt_enable( uint32_t level )
{
  asm volatile (
ffc41e30:	7f 80 01 24 	mtmsr   r28
          _ISR_Enable( level );

          /*
           *  Baseline statistics information for the beginning of a period.
           */
          _Rate_monotonic_Initiate_statistics( the_period );
ffc41e34:	4b ff fc 99 	bl      ffc41acc <_Rate_monotonic_Initiate_statistics>

          the_period->state = RATE_MONOTONIC_ACTIVE;
ffc41e38:	39 20 00 02 	li      r9,2
ffc41e3c:	91 3d 00 38 	stw     r9,56(r29)
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
ffc41e40:	3d 20 ff c4 	lis     r9,-60
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
ffc41e44:	38 00 00 00 	li      r0,0
  the_watchdog->routine   = routine;
ffc41e48:	39 29 1f 4c 	addi    r9,r9,8012
  the_watchdog->id        = id;
ffc41e4c:	93 dd 00 30 	stw     r30,48(r29)
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc41e50:	3c 60 00 00 	lis     r3,0
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
ffc41e54:	91 3d 00 2c 	stw     r9,44(r29)
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc41e58:	38 63 65 e8 	addi    r3,r3,26088
ffc41e5c:	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;
ffc41e60:	90 1d 00 34 	stw     r0,52(r29)
          );

          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
ffc41e64:	3b c0 00 00 	li      r30,0
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
ffc41e68:	93 fd 00 1c 	stw     r31,28(r29)
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
ffc41e6c:	90 1d 00 18 	stw     r0,24(r29)
            _Rate_monotonic_Timeout,
            id,
            NULL
          );

          the_period->next_length = length;
ffc41e70:	93 fd 00 3c 	stw     r31,60(r29)
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc41e74:	4b fc f8 35 	bl      ffc116a8 <_Watchdog_Insert>
ffc41e78:	48 00 00 a4 	b       ffc41f1c <rtems_rate_monotonic_period+0x1ac>
        case RATE_MONOTONIC_ACTIVE:

          /*
           *  Update statistics from the concluding period.
           */
          _Rate_monotonic_Update_statistics( the_period );
ffc41e7c:	4b ff fd d9 	bl      ffc41c54 <_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;
ffc41e80:	38 00 00 01 	li      r0,1
          the_period->next_length = length;
ffc41e84:	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;
ffc41e88:	90 1d 00 38 	stw     r0,56(r29)
ffc41e8c:	7f 80 01 24 	mtmsr   r28
          the_period->next_length = length;

          _ISR_Enable( level );

          _Thread_Executing->Wait.id = the_period->Object.id;
ffc41e90:	3d 20 00 00 	lis     r9,0
ffc41e94:	80 1d 00 08 	lwz     r0,8(r29)
ffc41e98:	81 29 36 58 	lwz     r9,13912(r9)
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc41e9c:	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;
ffc41ea0:	90 09 00 20 	stw     r0,32(r9)
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc41ea4:	7d 23 4b 78 	mr      r3,r9
ffc41ea8:	4b fc ed 19 	bl      ffc10bc0 <_Thread_Set_state>
static inline uint32_t ppc_interrupt_disable( void )
{
  uint32_t level;
  uint32_t mask;

  asm volatile (
ffc41eac:	7d 20 00 a6 	mfmsr   r9
ffc41eb0:	7c 10 42 a6 	mfsprg  r0,0
ffc41eb4:	7d 20 00 78 	andc    r0,r9,r0
ffc41eb8:	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;
ffc41ebc:	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;
ffc41ec0:	80 1d 00 38 	lwz     r0,56(r29)
            the_period->state = RATE_MONOTONIC_ACTIVE;
ffc41ec4:	91 7d 00 38 	stw     r11,56(r29)
  return level;
}

static inline void ppc_interrupt_enable( uint32_t level )
{
  asm volatile (
ffc41ec8:	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 )
ffc41ecc:	2f 80 00 03 	cmpwi   cr7,r0,3
ffc41ed0:	40 be 00 14 	bne+    cr7,ffc41ee4 <rtems_rate_monotonic_period+0x174>
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc41ed4:	3d 20 00 00 	lis     r9,0                                         	<== NOT EXECUTED
ffc41ed8:	80 69 36 58 	lwz     r3,13912(r9)                                 	<== NOT EXECUTED
ffc41edc:	38 80 40 00 	li      r4,16384                                     	<== NOT EXECUTED
ffc41ee0:	4b fc dd 71 	bl      ffc0fc50 <_Thread_Clear_state>               	<== NOT EXECUTED

          _Thread_Enable_dispatch();
ffc41ee4:	4b fc e2 51 	bl      ffc10134 <_Thread_Enable_dispatch>
ffc41ee8:	3b c0 00 00 	li      r30,0
          return RTEMS_SUCCESSFUL;
ffc41eec:	48 00 00 3c 	b       ffc41f28 <rtems_rate_monotonic_period+0x1b8>
        case RATE_MONOTONIC_EXPIRED:

          /*
           *  Update statistics from the concluding period
           */
          _Rate_monotonic_Update_statistics( the_period );
ffc41ef0:	4b ff fd 65 	bl      ffc41c54 <_Rate_monotonic_Update_statistics>
ffc41ef4:	7f 80 01 24 	mtmsr   r28

          _ISR_Enable( level );

          the_period->state = RATE_MONOTONIC_ACTIVE;
ffc41ef8:	38 00 00 02 	li      r0,2
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
ffc41efc:	93 fd 00 1c 	stw     r31,28(r29)

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc41f00:	3c 60 00 00 	lis     r3,0
ffc41f04:	90 1d 00 38 	stw     r0,56(r29)
ffc41f08:	38 63 65 e8 	addi    r3,r3,26088
ffc41f0c:	38 9d 00 10 	addi    r4,r29,16
          the_period->next_length = length;
ffc41f10:	93 fd 00 3c 	stw     r31,60(r29)

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
ffc41f14:	3b c0 00 06 	li      r30,6
ffc41f18:	4b fc f7 91 	bl      ffc116a8 <_Watchdog_Insert>
ffc41f1c:	4b fc e2 19 	bl      ffc10134 <_Thread_Enable_dispatch>
          return RTEMS_TIMEOUT;
ffc41f20:	48 00 00 08 	b       ffc41f28 <rtems_rate_monotonic_period+0x1b8>
ffc41f24:	3b c0 00 04 	li      r30,4
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
ffc41f28:	80 01 00 2c 	lwz     r0,44(r1)
ffc41f2c:	7f c3 f3 78 	mr      r3,r30
ffc41f30:	83 81 00 18 	lwz     r28,24(r1)
ffc41f34:	7c 08 03 a6 	mtlr    r0
ffc41f38:	83 a1 00 1c 	lwz     r29,28(r1)
ffc41f3c:	83 c1 00 20 	lwz     r30,32(r1)
ffc41f40:	83 e1 00 24 	lwz     r31,36(r1)
ffc41f44:	38 21 00 28 	addi    r1,r1,40
ffc41f48:	4e 80 00 20 	blr