===============================================================================
020173b8 <_CORE_message_queue_Broadcast>:                             
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif                                                              
  uint32_t                                  *count                    
)                                                                     
{                                                                     
 20173b8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Thread_Control          *the_thread;                                
  uint32_t                 number_broadcasted;                        
  Thread_Wait_information *waitp;                                     
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
 20173bc:	c2 06 20 4c 	ld  [ %i0 + 0x4c ], %g1                        
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif                                                              
  uint32_t                                  *count                    
)                                                                     
{                                                                     
 20173c0:	a0 10 00 18 	mov  %i0, %l0                                  
  Thread_Control          *the_thread;                                
  uint32_t                 number_broadcasted;                        
  Thread_Wait_information *waitp;                                     
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
 20173c4:	80 a6 80 01 	cmp  %i2, %g1                                  
 20173c8:	18 80 00 16 	bgu  2017420 <_CORE_message_queue_Broadcast+0x68><== NEVER TAKEN
 20173cc:	b0 10 20 01 	mov  1, %i0                                    
   *  NOTE: This check is critical because threads can block on       
   *        send and receive and this ensures that we are broadcasting
   *        the message to threads waiting to receive -- not to send. 
   */                                                                 
                                                                      
  if ( the_message_queue->number_of_pending_messages != 0 ) {         
 20173d0:	c2 04 20 48 	ld  [ %l0 + 0x48 ], %g1                        
 20173d4:	80 a0 60 00 	cmp  %g1, 0                                    
 20173d8:	02 80 00 0b 	be  2017404 <_CORE_message_queue_Broadcast+0x4c>
 20173dc:	a2 10 20 00 	clr  %l1                                       
    *count = 0;                                                       
 20173e0:	c0 27 40 00 	clr  [ %i5 ]                                   
    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                      
 20173e4:	81 c7 e0 08 	ret                                            
 20173e8:	91 e8 20 00 	restore  %g0, 0, %o0                           
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
 20173ec:	92 10 00 19 	mov  %i1, %o1                                  
 20173f0:	40 00 21 34 	call  201f8c0 <memcpy>                         
 20173f4:	94 10 00 1a 	mov  %i2, %o2                                  
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
 20173f8:	c2 04 a0 28 	ld  [ %l2 + 0x28 ], %g1                        
   */                                                                 
  number_broadcasted = 0;                                             
  while ((the_thread =                                                
          _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {   
    waitp = &the_thread->Wait;                                        
    number_broadcasted += 1;                                          
 20173fc:	a2 04 60 01 	inc  %l1                                       
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
 2017400:	f4 20 40 00 	st  %i2, [ %g1 ]                               
  /*                                                                  
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.                                              
   */                                                                 
  number_broadcasted = 0;                                             
  while ((the_thread =                                                
 2017404:	40 00 0b 57 	call  201a160 <_Thread_queue_Dequeue>          
 2017408:	90 10 00 10 	mov  %l0, %o0                                  
 201740c:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 2017410:	32 bf ff f7 	bne,a   20173ec <_CORE_message_queue_Broadcast+0x34>
 2017414:	d0 04 a0 2c 	ld  [ %l2 + 0x2c ], %o0                        
      if ( !_Objects_Is_local_id( the_thread->Object.id ) )           
        (*api_message_queue_mp_support) ( the_thread, id );           
    #endif                                                            
                                                                      
  }                                                                   
  *count = number_broadcasted;                                        
 2017418:	e2 27 40 00 	st  %l1, [ %i5 ]                               
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                        
 201741c:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 2017420:	81 c7 e0 08 	ret                                            
 2017424:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200fca8 <_CORE_message_queue_Initialize>:                            
  CORE_message_queue_Control    *the_message_queue,                   
  CORE_message_queue_Attributes *the_message_queue_attributes,        
  uint32_t                       maximum_pending_messages,            
  size_t                         maximum_message_size                 
)                                                                     
{                                                                     
 200fca8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t message_buffering_required;                                  
  size_t allocated_message_size;                                      
                                                                      
  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
 200fcac:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
  the_message_queue->number_of_pending_messages = 0;                  
 200fcb0:	c0 26 20 48 	clr  [ %i0 + 0x48 ]                            
  the_message_queue->maximum_message_size       = maximum_message_size;
 200fcb4:	f6 26 20 4c 	st  %i3, [ %i0 + 0x4c ]                        
  CORE_message_queue_Control    *the_message_queue,                   
  CORE_message_queue_Attributes *the_message_queue_attributes,        
  uint32_t                       maximum_pending_messages,            
  size_t                         maximum_message_size                 
)                                                                     
{                                                                     
 200fcb8:	a0 10 00 18 	mov  %i0, %l0                                  
  /*                                                                  
   *  Round size up to multiple of a pointer for chain init and       
   *  check for overflow on adding overhead to each message.          
   */                                                                 
  allocated_message_size = maximum_message_size;                      
  if (allocated_message_size & (sizeof(uint32_t) - 1)) {              
 200fcbc:	80 8e e0 03 	btst  3, %i3                                   
 200fcc0:	02 80 00 07 	be  200fcdc <_CORE_message_queue_Initialize+0x34>
 200fcc4:	a4 10 00 1b 	mov  %i3, %l2                                  
    allocated_message_size += sizeof(uint32_t);                       
 200fcc8:	a4 06 e0 04 	add  %i3, 4, %l2                               
    allocated_message_size &= ~(sizeof(uint32_t) - 1);                
 200fccc:	a4 0c bf fc 	and  %l2, -4, %l2                              
  }                                                                   
                                                                      
  if (allocated_message_size < maximum_message_size)                  
 200fcd0:	80 a4 80 1b 	cmp  %l2, %i3                                  
 200fcd4:	0a 80 00 22 	bcs  200fd5c <_CORE_message_queue_Initialize+0xb4><== NEVER TAKEN
 200fcd8:	b0 10 20 00 	clr  %i0                                       
  /*                                                                  
   *  Calculate how much total memory is required for message buffering and
   *  check for overflow on the multiplication.                       
   */                                                                 
  message_buffering_required = (size_t) maximum_pending_messages *    
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
 200fcdc:	a2 04 a0 10 	add  %l2, 0x10, %l1                            
                                                                      
  /*                                                                  
   *  Calculate how much total memory is required for message buffering and
   *  check for overflow on the multiplication.                       
   */                                                                 
  message_buffering_required = (size_t) maximum_pending_messages *    
 200fce0:	92 10 00 1a 	mov  %i2, %o1                                  
 200fce4:	90 10 00 11 	mov  %l1, %o0                                  
 200fce8:	40 00 3f 0d 	call  201f91c <.umul>                          
 200fcec:	b0 10 20 00 	clr  %i0                                       
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
                                                                      
  if (message_buffering_required < allocated_message_size)            
 200fcf0:	80 a2 00 12 	cmp  %o0, %l2                                  
 200fcf4:	0a 80 00 1a 	bcs  200fd5c <_CORE_message_queue_Initialize+0xb4><== NEVER TAKEN
 200fcf8:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
     _Workspace_Allocate( message_buffering_required );               
 200fcfc:	40 00 0c 0f 	call  2012d38 <_Workspace_Allocate>            
 200fd00:	01 00 00 00 	nop                                            
    return false;                                                     
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
 200fd04:	d0 24 20 5c 	st  %o0, [ %l0 + 0x5c ]                        
     _Workspace_Allocate( message_buffering_required );               
                                                                      
  if (the_message_queue->message_buffers == 0)                        
 200fd08:	80 a2 20 00 	cmp  %o0, 0                                    
 200fd0c:	02 80 00 14 	be  200fd5c <_CORE_message_queue_Initialize+0xb4>
 200fd10:	92 10 00 08 	mov  %o0, %o1                                  
                                                                      
  /*                                                                  
   *  Initialize the pool of inactive messages, pending messages,     
   *  and set of waiting threads.                                     
   */                                                                 
  _Chain_Initialize (                                                 
 200fd14:	90 04 20 60 	add  %l0, 0x60, %o0                            
 200fd18:	94 10 00 1a 	mov  %i2, %o2                                  
 200fd1c:	40 00 14 60 	call  2014e9c <_Chain_Initialize>              
 200fd20:	96 10 00 11 	mov  %l1, %o3                                  
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
 200fd24:	82 04 20 54 	add  %l0, 0x54, %g1                            
                                                                      
  head->next = tail;                                                  
 200fd28:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
 200fd2c:	82 04 20 50 	add  %l0, 0x50, %g1                            
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
 200fd30:	c0 24 20 54 	clr  [ %l0 + 0x54 ]                            
  tail->previous = head;                                              
 200fd34:	c2 24 20 58 	st  %g1, [ %l0 + 0x58 ]                        
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );                                                                  
                                                                      
  _Chain_Initialize_empty( &the_message_queue->Pending_messages );    
                                                                      
  _Thread_queue_Initialize(                                           
 200fd38:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 200fd3c:	90 10 00 10 	mov  %l0, %o0                                  
 200fd40:	82 18 60 01 	xor  %g1, 1, %g1                               
 200fd44:	80 a0 00 01 	cmp  %g0, %g1                                  
 200fd48:	94 10 20 80 	mov  0x80, %o2                                 
 200fd4c:	92 60 3f ff 	subx  %g0, -1, %o1                             
 200fd50:	96 10 20 06 	mov  6, %o3                                    
 200fd54:	40 00 09 7e 	call  201234c <_Thread_queue_Initialize>       
 200fd58:	b0 10 20 01 	mov  1, %i0                                    
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
}                                                                     
 200fd5c:	81 c7 e0 08 	ret                                            
 200fd60:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200fd64 <_CORE_message_queue_Seize>:                                 
  void                            *buffer,                            
  size_t                          *size_p,                            
  bool                             wait,                              
  Watchdog_Interval                timeout                            
)                                                                     
{                                                                     
 200fd64:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
 200fd68:	27 00 80 91 	sethi  %hi(0x2024400), %l3                     
 200fd6c:	a6 14 e0 4c 	or  %l3, 0x4c, %l3	! 202444c <_Per_CPU_Information>
 200fd70:	e4 04 e0 0c 	ld  [ %l3 + 0xc ], %l2                         
  void                            *buffer,                            
  size_t                          *size_p,                            
  bool                             wait,                              
  Watchdog_Interval                timeout                            
)                                                                     
{                                                                     
 200fd74:	a0 10 00 19 	mov  %i1, %l0                                  
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 
  _ISR_Disable( level );                                              
 200fd78:	7f ff dd e2 	call  2007500 <sparc_disable_interrupts>       
 200fd7c:	c0 24 a0 34 	clr  [ %l2 + 0x34 ]                            
 200fd80:	82 10 00 08 	mov  %o0, %g1                                  
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
 200fd84:	e2 06 20 50 	ld  [ %i0 + 0x50 ], %l1                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 200fd88:	84 06 20 54 	add  %i0, 0x54, %g2                            
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
 200fd8c:	80 a4 40 02 	cmp  %l1, %g2                                  
 200fd90:	02 80 00 15 	be  200fde4 <_CORE_message_queue_Seize+0x80>   
 200fd94:	86 06 20 50 	add  %i0, 0x50, %g3                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
 200fd98:	c4 04 40 00 	ld  [ %l1 ], %g2                               
                                                                      
  head->next = new_first;                                             
 200fd9c:	c4 26 20 50 	st  %g2, [ %i0 + 0x50 ]                        
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 
  _ISR_Disable( level );                                              
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {                                        
 200fda0:	80 a4 60 00 	cmp  %l1, 0                                    
 200fda4:	02 80 00 10 	be  200fde4 <_CORE_message_queue_Seize+0x80>   <== NEVER TAKEN
 200fda8:	c6 20 a0 04 	st  %g3, [ %g2 + 4 ]                           
    the_message_queue->number_of_pending_messages -= 1;               
 200fdac:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
 200fdb0:	82 00 7f ff 	add  %g1, -1, %g1                              
 200fdb4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
    _ISR_Enable( level );                                             
 200fdb8:	7f ff dd d6 	call  2007510 <sparc_enable_interrupts>        
 200fdbc:	b0 06 20 60 	add  %i0, 0x60, %i0                            
                                                                      
    *size_p = the_message->Contents.size;                             
 200fdc0:	d4 04 60 08 	ld  [ %l1 + 8 ], %o2                           
    _Thread_Executing->Wait.count =                                   
 200fdc4:	c2 04 e0 0c 	ld  [ %l3 + 0xc ], %g1                         
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {                                        
    the_message_queue->number_of_pending_messages -= 1;               
    _ISR_Enable( level );                                             
                                                                      
    *size_p = the_message->Contents.size;                             
 200fdc8:	d4 26 c0 00 	st  %o2, [ %i3 ]                               
    _Thread_Executing->Wait.count =                                   
 200fdcc:	c0 20 60 24 	clr  [ %g1 + 0x24 ]                            
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
 200fdd0:	90 10 00 1a 	mov  %i2, %o0                                  
 200fdd4:	40 00 1e a7 	call  2017870 <memcpy>                         
 200fdd8:	92 04 60 0c 	add  %l1, 0xc, %o1                             
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (   
  CORE_message_queue_Control        *the_message_queue,               
  CORE_message_queue_Buffer_control *the_message                      
)                                                                     
{                                                                     
  _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
 200fddc:	7f ff ff 83 	call  200fbe8 <_Chain_Append>                  
 200fde0:	93 e8 00 11 	restore  %g0, %l1, %o1                         
      return;                                                         
    }                                                                 
    #endif                                                            
  }                                                                   
                                                                      
  if ( !wait ) {                                                      
 200fde4:	80 8f 20 ff 	btst  0xff, %i4                                
 200fde8:	32 80 00 08 	bne,a   200fe08 <_CORE_message_queue_Seize+0xa4>
 200fdec:	84 10 20 01 	mov  1, %g2                                    
    _ISR_Enable( level );                                             
 200fdf0:	7f ff dd c8 	call  2007510 <sparc_enable_interrupts>        
 200fdf4:	90 10 00 01 	mov  %g1, %o0                                  
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
 200fdf8:	82 10 20 04 	mov  4, %g1                                    
 200fdfc:	c2 24 a0 34 	st  %g1, [ %l2 + 0x34 ]                        
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
 200fe00:	81 c7 e0 08 	ret                                            
 200fe04:	81 e8 00 00 	restore                                        
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
 200fe08:	c4 26 20 30 	st  %g2, [ %i0 + 0x30 ]                        
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
    return;                                                           
  }                                                                   
                                                                      
  _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
  executing->Wait.queue = &the_message_queue->Wait_queue;             
 200fe0c:	f0 24 a0 44 	st  %i0, [ %l2 + 0x44 ]                        
  executing->Wait.id = id;                                            
 200fe10:	e0 24 a0 20 	st  %l0, [ %l2 + 0x20 ]                        
  executing->Wait.return_argument_second.mutable_object = buffer;     
 200fe14:	f4 24 a0 2c 	st  %i2, [ %l2 + 0x2c ]                        
  executing->Wait.return_argument = size_p;                           
 200fe18:	f6 24 a0 28 	st  %i3, [ %l2 + 0x28 ]                        
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
 200fe1c:	90 10 00 01 	mov  %g1, %o0                                  
 200fe20:	7f ff dd bc 	call  2007510 <sparc_enable_interrupts>        
 200fe24:	35 00 80 49 	sethi  %hi(0x2012400), %i2                     
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
 200fe28:	b2 10 00 1d 	mov  %i5, %i1                                  
 200fe2c:	40 00 08 9e 	call  20120a4 <_Thread_queue_Enqueue_with_handler>
 200fe30:	95 ee a0 2c 	restore  %i2, 0x2c, %o2                        
                                                                      
===============================================================================
02006b18 <_CORE_mutex_Seize>:                                         
  Objects_Id           _id,                                           
  bool                 _wait,                                         
  Watchdog_Interval    _timeout,                                      
  ISR_Level            _level                                         
)                                                                     
{                                                                     
 2006b18:	9d e3 bf a0 	save  %sp, -96, %sp                            
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
 2006b1c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2006b20:	c2 00 61 30 	ld  [ %g1 + 0x130 ], %g1	! 2014d30 <_Thread_Dispatch_disable_level>
 2006b24:	80 a0 60 00 	cmp  %g1, 0                                    
 2006b28:	02 80 00 0d 	be  2006b5c <_CORE_mutex_Seize+0x44>           
 2006b2c:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
 2006b30:	80 8e a0 ff 	btst  0xff, %i2                                
 2006b34:	02 80 00 0b 	be  2006b60 <_CORE_mutex_Seize+0x48>           <== NEVER TAKEN
 2006b38:	90 10 00 18 	mov  %i0, %o0                                  
 2006b3c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2006b40:	c2 00 62 8c 	ld  [ %g1 + 0x28c ], %g1	! 2014e8c <_System_state_Current>
 2006b44:	80 a0 60 01 	cmp  %g1, 1                                    
 2006b48:	08 80 00 05 	bleu  2006b5c <_CORE_mutex_Seize+0x44>         
 2006b4c:	90 10 20 00 	clr  %o0                                       
 2006b50:	92 10 20 00 	clr  %o1                                       
 2006b54:	40 00 01 da 	call  20072bc <_Internal_error_Occurred>       
 2006b58:	94 10 20 12 	mov  0x12, %o2                                 
 2006b5c:	90 10 00 18 	mov  %i0, %o0                                  
 2006b60:	40 00 13 7c 	call  200b950 <_CORE_mutex_Seize_interrupt_trylock>
 2006b64:	92 07 a0 54 	add  %fp, 0x54, %o1                            
 2006b68:	80 a2 20 00 	cmp  %o0, 0                                    
 2006b6c:	02 80 00 0a 	be  2006b94 <_CORE_mutex_Seize+0x7c>           
 2006b70:	80 8e a0 ff 	btst  0xff, %i2                                
 2006b74:	35 00 80 53 	sethi  %hi(0x2014c00), %i2                     
 2006b78:	12 80 00 09 	bne  2006b9c <_CORE_mutex_Seize+0x84>          
 2006b7c:	b4 16 a3 5c 	or  %i2, 0x35c, %i2	! 2014f5c <_Per_CPU_Information>
 2006b80:	7f ff ec dd 	call  2001ef4 <sparc_enable_interrupts>        
 2006b84:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
 2006b88:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
 2006b8c:	84 10 20 01 	mov  1, %g2                                    
 2006b90:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
 2006b94:	81 c7 e0 08 	ret                                            
 2006b98:	81 e8 00 00 	restore                                        
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
 2006b9c:	82 10 20 01 	mov  1, %g1                                    
 2006ba0:	c2 26 20 30 	st  %g1, [ %i0 + 0x30 ]                        
 2006ba4:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
 2006ba8:	f0 20 60 44 	st  %i0, [ %g1 + 0x44 ]                        
 2006bac:	f2 20 60 20 	st  %i1, [ %g1 + 0x20 ]                        
 2006bb0:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2006bb4:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 2014d30 <_Thread_Dispatch_disable_level>
 2006bb8:	84 00 a0 01 	inc  %g2                                       
 2006bbc:	c4 20 61 30 	st  %g2, [ %g1 + 0x130 ]                       
 2006bc0:	7f ff ec cd 	call  2001ef4 <sparc_enable_interrupts>        
 2006bc4:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
 2006bc8:	90 10 00 18 	mov  %i0, %o0                                  
 2006bcc:	7f ff ff ba 	call  2006ab4 <_CORE_mutex_Seize_interrupt_blocking>
 2006bd0:	92 10 00 1b 	mov  %i3, %o1                                  
 2006bd4:	81 c7 e0 08 	ret                                            
 2006bd8:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02006d58 <_CORE_semaphore_Surrender>:                                 
CORE_semaphore_Status _CORE_semaphore_Surrender(                      
  CORE_semaphore_Control                *the_semaphore,               
  Objects_Id                             id,                          
  CORE_semaphore_API_mp_support_callout  api_semaphore_mp_support     
)                                                                     
{                                                                     
 2006d58:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
 2006d5c:	90 10 00 18 	mov  %i0, %o0                                  
 2006d60:	40 00 07 13 	call  20089ac <_Thread_queue_Dequeue>          
 2006d64:	a0 10 00 18 	mov  %i0, %l0                                  
 2006d68:	80 a2 20 00 	cmp  %o0, 0                                    
 2006d6c:	12 80 00 0e 	bne  2006da4 <_CORE_semaphore_Surrender+0x4c>  
 2006d70:	b0 10 20 00 	clr  %i0                                       
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_semaphore_mp_support) ( the_thread, id );                 
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
 2006d74:	7f ff ec 5c 	call  2001ee4 <sparc_disable_interrupts>       
 2006d78:	01 00 00 00 	nop                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
 2006d7c:	c2 04 20 48 	ld  [ %l0 + 0x48 ], %g1                        
 2006d80:	c4 04 20 40 	ld  [ %l0 + 0x40 ], %g2                        
 2006d84:	80 a0 40 02 	cmp  %g1, %g2                                  
 2006d88:	1a 80 00 05 	bcc  2006d9c <_CORE_semaphore_Surrender+0x44>  <== NEVER TAKEN
 2006d8c:	b0 10 20 04 	mov  4, %i0                                    
        the_semaphore->count += 1;                                    
 2006d90:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
 2006d94:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;                                    
 2006d98:	c2 24 20 48 	st  %g1, [ %l0 + 0x48 ]                        
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
 2006d9c:	7f ff ec 56 	call  2001ef4 <sparc_enable_interrupts>        
 2006da0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
 2006da4:	81 c7 e0 08 	ret                                            
 2006da8:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02005b14 <_Event_Surrender>:                                          
 */                                                                   
                                                                      
void _Event_Surrender(                                                
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
 2005b14:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_event_set     event_condition;                                
  rtems_event_set     seized_events;                                  
  rtems_option        option_set;                                     
  RTEMS_API_Control  *api;                                            
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
 2005b18:	e2 06 21 58 	ld  [ %i0 + 0x158 ], %l1                       
                                                                      
  option_set = (rtems_option) the_thread->Wait.option;                
 2005b1c:	e4 06 20 30 	ld  [ %i0 + 0x30 ], %l2                        
                                                                      
  _ISR_Disable( level );                                              
 2005b20:	7f ff f0 f1 	call  2001ee4 <sparc_disable_interrupts>       
 2005b24:	a0 10 00 18 	mov  %i0, %l0                                  
 2005b28:	b0 10 00 08 	mov  %o0, %i0                                  
  pending_events  = api->pending_events;                              
 2005b2c:	c4 04 40 00 	ld  [ %l1 ], %g2                               
  event_condition = (rtems_event_set) the_thread->Wait.count;         
 2005b30:	c6 04 20 24 	ld  [ %l0 + 0x24 ], %g3                        
  seized_events = _Event_sets_Get( pending_events, event_condition ); 
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
 2005b34:	82 88 c0 02 	andcc  %g3, %g2, %g1                           
 2005b38:	12 80 00 03 	bne  2005b44 <_Event_Surrender+0x30>           
 2005b3c:	09 00 80 53 	sethi  %hi(0x2014c00), %g4                     
    _ISR_Enable( level );                                             
 2005b40:	30 80 00 42 	b,a   2005c48 <_Event_Surrender+0x134>         
                                                                      
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
 2005b44:	88 11 23 5c 	or  %g4, 0x35c, %g4	! 2014f5c <_Per_CPU_Information>
 2005b48:	da 01 20 08 	ld  [ %g4 + 8 ], %o5                           
 2005b4c:	80 a3 60 00 	cmp  %o5, 0                                    
 2005b50:	22 80 00 1d 	be,a   2005bc4 <_Event_Surrender+0xb0>         
 2005b54:	c8 04 20 10 	ld  [ %l0 + 0x10 ], %g4                        
 2005b58:	c8 01 20 0c 	ld  [ %g4 + 0xc ], %g4                         
 2005b5c:	80 a4 00 04 	cmp  %l0, %g4                                  
 2005b60:	32 80 00 19 	bne,a   2005bc4 <_Event_Surrender+0xb0>        
 2005b64:	c8 04 20 10 	ld  [ %l0 + 0x10 ], %g4                        
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
 2005b68:	09 00 80 53 	sethi  %hi(0x2014c00), %g4                     
 2005b6c:	da 01 23 b0 	ld  [ %g4 + 0x3b0 ], %o5	! 2014fb0 <_Event_Sync_state>
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
 2005b70:	80 a3 60 02 	cmp  %o5, 2                                    
 2005b74:	02 80 00 07 	be  2005b90 <_Event_Surrender+0x7c>            <== NEVER TAKEN
 2005b78:	80 a0 40 03 	cmp  %g1, %g3                                  
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
 2005b7c:	c8 01 23 b0 	ld  [ %g4 + 0x3b0 ], %g4                       
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
 2005b80:	80 a1 20 01 	cmp  %g4, 1                                    
 2005b84:	32 80 00 10 	bne,a   2005bc4 <_Event_Surrender+0xb0>        
 2005b88:	c8 04 20 10 	ld  [ %l0 + 0x10 ], %g4                        
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
 2005b8c:	80 a0 40 03 	cmp  %g1, %g3                                  
 2005b90:	02 80 00 04 	be  2005ba0 <_Event_Surrender+0x8c>            
 2005b94:	80 8c a0 02 	btst  2, %l2                                   
 2005b98:	02 80 00 0a 	be  2005bc0 <_Event_Surrender+0xac>            <== NEVER TAKEN
 2005b9c:	01 00 00 00 	nop                                            
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(               
 rtems_event_set the_event_set,                                       
 rtems_event_set the_mask                                             
)                                                                     
{                                                                     
   return ( the_event_set & ~(the_mask) );                            
 2005ba0:	84 28 80 01 	andn  %g2, %g1, %g2                            
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
 2005ba4:	c4 24 40 00 	st  %g2, [ %l1 ]                               
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
 2005ba8:	c4 04 20 28 	ld  [ %l0 + 0x28 ], %g2                        
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
      the_thread->Wait.count = 0;                                     
 2005bac:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
 2005bb0:	c2 20 80 00 	st  %g1, [ %g2 ]                               
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;        
 2005bb4:	84 10 20 03 	mov  3, %g2                                    
 2005bb8:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2005bbc:	c4 20 63 b0 	st  %g2, [ %g1 + 0x3b0 ]	! 2014fb0 <_Event_Sync_state>
    }                                                                 
    _ISR_Enable( level );                                             
 2005bc0:	30 80 00 22 	b,a   2005c48 <_Event_Surrender+0x134>         
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
 2005bc4:	80 89 21 00 	btst  0x100, %g4                               
 2005bc8:	02 80 00 20 	be  2005c48 <_Event_Surrender+0x134>           
 2005bcc:	80 a0 40 03 	cmp  %g1, %g3                                  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
 2005bd0:	02 80 00 04 	be  2005be0 <_Event_Surrender+0xcc>            
 2005bd4:	80 8c a0 02 	btst  2, %l2                                   
 2005bd8:	02 80 00 1c 	be  2005c48 <_Event_Surrender+0x134>           <== NEVER TAKEN
 2005bdc:	01 00 00 00 	nop                                            
 2005be0:	84 28 80 01 	andn  %g2, %g1, %g2                            
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
 2005be4:	c4 24 40 00 	st  %g2, [ %l1 ]                               
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
 2005be8:	c4 04 20 28 	ld  [ %l0 + 0x28 ], %g2                        
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
      the_thread->Wait.count = 0;                                     
 2005bec:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
 2005bf0:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _ISR_Flash( level );                                            
 2005bf4:	7f ff f0 c0 	call  2001ef4 <sparc_enable_interrupts>        
 2005bf8:	90 10 00 18 	mov  %i0, %o0                                  
 2005bfc:	7f ff f0 ba 	call  2001ee4 <sparc_disable_interrupts>       
 2005c00:	01 00 00 00 	nop                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
 2005c04:	c2 04 20 50 	ld  [ %l0 + 0x50 ], %g1                        
 2005c08:	80 a0 60 02 	cmp  %g1, 2                                    
 2005c0c:	02 80 00 06 	be  2005c24 <_Event_Surrender+0x110>           
 2005c10:	82 10 20 03 	mov  3, %g1                                    
        _ISR_Enable( level );                                         
 2005c14:	7f ff f0 b8 	call  2001ef4 <sparc_enable_interrupts>        
 2005c18:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
 2005c1c:	10 80 00 08 	b  2005c3c <_Event_Surrender+0x128>            
 2005c20:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
 2005c24:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
 2005c28:	7f ff f0 b3 	call  2001ef4 <sparc_enable_interrupts>        
 2005c2c:	90 10 00 18 	mov  %i0, %o0                                  
        (void) _Watchdog_Remove( &the_thread->Timer );                
 2005c30:	40 00 0e 7c 	call  2009620 <_Watchdog_Remove>               
 2005c34:	90 04 20 48 	add  %l0, 0x48, %o0                            
 2005c38:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
 2005c3c:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1003fff8 <RAM_END+0xdc3fff8>
 2005c40:	40 00 09 ad 	call  20082f4 <_Thread_Clear_state>            
 2005c44:	91 e8 00 10 	restore  %g0, %l0, %o0                         
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
 2005c48:	7f ff f0 ab 	call  2001ef4 <sparc_enable_interrupts>        
 2005c4c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02005c54 <_Event_Timeout>:                                            
                                                                      
void _Event_Timeout(                                                  
  Objects_Id  id,                                                     
  void       *ignored                                                 
)                                                                     
{                                                                     
 2005c54:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
  ISR_Level          level;                                           
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 2005c58:	90 10 00 18 	mov  %i0, %o0                                  
 2005c5c:	40 00 0a 91 	call  20086a0 <_Thread_Get>                    
 2005c60:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 2005c64:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2005c68:	80 a0 60 00 	cmp  %g1, 0                                    
 2005c6c:	12 80 00 1c 	bne  2005cdc <_Event_Timeout+0x88>             <== NEVER TAKEN
 2005c70:	a0 10 00 08 	mov  %o0, %l0                                  
       *                                                              
       *  If it is not satisfied, then it is "nothing happened" and   
       *  this is the "timeout" transition.  After a request is satisfied,
       *  a timeout is not allowed to occur.                          
       */                                                             
      _ISR_Disable( level );                                          
 2005c74:	7f ff f0 9c 	call  2001ee4 <sparc_disable_interrupts>       
 2005c78:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
 2005c7c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
 2005c80:	c2 00 63 68 	ld  [ %g1 + 0x368 ], %g1	! 2014f68 <_Per_CPU_Information+0xc>
 2005c84:	80 a4 00 01 	cmp  %l0, %g1                                  
 2005c88:	12 80 00 09 	bne  2005cac <_Event_Timeout+0x58>             
 2005c8c:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
          if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
 2005c90:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2005c94:	c4 00 63 b0 	ld  [ %g1 + 0x3b0 ], %g2	! 2014fb0 <_Event_Sync_state>
 2005c98:	80 a0 a0 01 	cmp  %g2, 1                                    
 2005c9c:	32 80 00 05 	bne,a   2005cb0 <_Event_Timeout+0x5c>          
 2005ca0:	82 10 20 06 	mov  6, %g1                                    
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
 2005ca4:	84 10 20 02 	mov  2, %g2                                    
 2005ca8:	c4 20 63 b0 	st  %g2, [ %g1 + 0x3b0 ]                       
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
 2005cac:	82 10 20 06 	mov  6, %g1                                    
 2005cb0:	c2 24 20 34 	st  %g1, [ %l0 + 0x34 ]                        
      _ISR_Enable( level );                                           
 2005cb4:	7f ff f0 90 	call  2001ef4 <sparc_enable_interrupts>        
 2005cb8:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
 2005cbc:	90 10 00 10 	mov  %l0, %o0                                  
 2005cc0:	13 04 00 ff 	sethi  %hi(0x1003fc00), %o1                    
 2005cc4:	40 00 09 8c 	call  20082f4 <_Thread_Clear_state>            
 2005cc8:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1003fff8 <RAM_END+0xdc3fff8>
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
 2005ccc:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2005cd0:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 2014d30 <_Thread_Dispatch_disable_level>
 2005cd4:	84 00 bf ff 	add  %g2, -1, %g2                              
 2005cd8:	c4 20 61 30 	st  %g2, [ %g1 + 0x130 ]                       
 2005cdc:	81 c7 e0 08 	ret                                            
 2005ce0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200bfac <_Heap_Extend>:                                              
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
 200bfac:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Heap_Block *start_block = first_block;                              
  Heap_Block *merge_below_block = NULL;                               
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
 200bfb0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  Heap_Block *extend_last_block = NULL;                               
 200bfb4:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
 200bfb8:	a0 10 00 18 	mov  %i0, %l0                                  
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const first_block = heap->first_block;                  
 200bfbc:	e4 06 20 20 	ld  [ %i0 + 0x20 ], %l2                        
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
 200bfc0:	e6 06 20 10 	ld  [ %i0 + 0x10 ], %l3                        
  uintptr_t const min_block_size = heap->min_block_size;              
 200bfc4:	d6 06 20 14 	ld  [ %i0 + 0x14 ], %o3                        
  uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
  uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
 200bfc8:	a2 06 40 1a 	add  %i1, %i2, %l1                             
  uintptr_t const free_size = stats->free_size;                       
 200bfcc:	e8 06 20 30 	ld  [ %i0 + 0x30 ], %l4                        
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
 200bfd0:	92 10 00 1a 	mov  %i2, %o1                                  
  uintptr_t const free_size = stats->free_size;                       
  uintptr_t extend_first_block_size = 0;                              
  uintptr_t extended_size = 0;                                        
  bool extend_area_ok = false;                                        
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
 200bfd4:	80 a4 40 19 	cmp  %l1, %i1                                  
 200bfd8:	0a 80 00 9f 	bcs  200c254 <_Heap_Extend+0x2a8>              
 200bfdc:	b0 10 20 00 	clr  %i0                                       
    return false;                                                     
  }                                                                   
                                                                      
  extend_area_ok = _Heap_Get_first_and_last_block(                    
 200bfe0:	90 10 00 19 	mov  %i1, %o0                                  
 200bfe4:	94 10 00 13 	mov  %l3, %o2                                  
 200bfe8:	98 07 bf fc 	add  %fp, -4, %o4                              
 200bfec:	7f ff ec d0 	call  200732c <_Heap_Get_first_and_last_block> 
 200bff0:	9a 07 bf f8 	add  %fp, -8, %o5                              
    page_size,                                                        
    min_block_size,                                                   
    &extend_first_block,                                              
    &extend_last_block                                                
  );                                                                  
  if (!extend_area_ok ) {                                             
 200bff4:	80 8a 20 ff 	btst  0xff, %o0                                
 200bff8:	02 80 00 97 	be  200c254 <_Heap_Extend+0x2a8>               
 200bffc:	aa 10 00 12 	mov  %l2, %l5                                  
 200c000:	ba 10 20 00 	clr  %i5                                       
 200c004:	b8 10 20 00 	clr  %i4                                       
 200c008:	b0 10 20 00 	clr  %i0                                       
 200c00c:	ae 10 20 00 	clr  %l7                                       
 200c010:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
      (uintptr_t) start_block : heap->area_begin;                     
    uintptr_t const sub_area_end = start_block->prev_size;            
    Heap_Block *const end_block =                                     
      _Heap_Block_of_alloc_area( sub_area_end, page_size );           
                                                                      
    if (                                                              
 200c014:	80 a0 40 11 	cmp  %g1, %l1                                  
 200c018:	1a 80 00 05 	bcc  200c02c <_Heap_Extend+0x80>               
 200c01c:	ec 05 40 00 	ld  [ %l5 ], %l6                               
 200c020:	80 a6 40 16 	cmp  %i1, %l6                                  
 200c024:	2a 80 00 8c 	bcs,a   200c254 <_Heap_Extend+0x2a8>           
 200c028:	b0 10 20 00 	clr  %i0                                       
      sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
    ) {                                                               
      return false;                                                   
    }                                                                 
                                                                      
    if ( extend_area_end == sub_area_begin ) {                        
 200c02c:	80 a4 40 01 	cmp  %l1, %g1                                  
 200c030:	02 80 00 06 	be  200c048 <_Heap_Extend+0x9c>                
 200c034:	80 a4 40 16 	cmp  %l1, %l6                                  
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
 200c038:	2a 80 00 05 	bcs,a   200c04c <_Heap_Extend+0xa0>            
 200c03c:	b8 10 00 15 	mov  %l5, %i4                                  
 200c040:	10 80 00 04 	b  200c050 <_Heap_Extend+0xa4>                 
 200c044:	90 10 00 16 	mov  %l6, %o0                                  
 200c048:	ae 10 00 15 	mov  %l5, %l7                                  
 200c04c:	90 10 00 16 	mov  %l6, %o0                                  
 200c050:	40 00 16 73 	call  2011a1c <.urem>                          
 200c054:	92 10 00 13 	mov  %l3, %o1                                  
 200c058:	b4 05 bf f8 	add  %l6, -8, %i2                              
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
 200c05c:	80 a5 80 19 	cmp  %l6, %i1                                  
 200c060:	12 80 00 05 	bne  200c074 <_Heap_Extend+0xc8>               
 200c064:	90 26 80 08 	sub  %i2, %o0, %o0                             
      start_block->prev_size = extend_area_end;                       
 200c068:	e2 25 40 00 	st  %l1, [ %l5 ]                               
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(           
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
 200c06c:	10 80 00 04 	b  200c07c <_Heap_Extend+0xd0>                 
 200c070:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
      merge_above_block = end_block;                                  
    } else if ( sub_area_end < extend_area_begin ) {                  
 200c074:	2a 80 00 02 	bcs,a   200c07c <_Heap_Extend+0xd0>            
 200c078:	ba 10 00 08 	mov  %o0, %i5                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 200c07c:	ea 02 20 04 	ld  [ %o0 + 4 ], %l5                           
 200c080:	aa 0d 7f fe 	and  %l5, -2, %l5                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200c084:	aa 02 00 15 	add  %o0, %l5, %l5                             
      link_above_block = end_block;                                   
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
 200c088:	80 a5 40 12 	cmp  %l5, %l2                                  
 200c08c:	12 bf ff e2 	bne  200c014 <_Heap_Extend+0x68>               
 200c090:	82 10 00 15 	mov  %l5, %g1                                  
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
 200c094:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
 200c098:	80 a6 40 01 	cmp  %i1, %g1                                  
 200c09c:	3a 80 00 04 	bcc,a   200c0ac <_Heap_Extend+0x100>           
 200c0a0:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
    heap->area_begin = extend_area_begin;                             
 200c0a4:	10 80 00 05 	b  200c0b8 <_Heap_Extend+0x10c>                
 200c0a8:	f2 24 20 18 	st  %i1, [ %l0 + 0x18 ]                        
  } else if ( heap->area_end < extend_area_end ) {                    
 200c0ac:	80 a0 40 11 	cmp  %g1, %l1                                  
 200c0b0:	2a 80 00 02 	bcs,a   200c0b8 <_Heap_Extend+0x10c>           
 200c0b4:	e2 24 20 1c 	st  %l1, [ %l0 + 0x1c ]                        
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
 200c0b8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
 200c0bc:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
 200c0c0:	e2 20 80 00 	st  %l1, [ %g2 ]                               
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
 200c0c4:	86 20 40 02 	sub  %g1, %g2, %g3                             
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
  extend_first_block->size_and_flag =                                 
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
 200c0c8:	88 10 e0 01 	or  %g3, 1, %g4                                
  _Heap_Protection_block_initialize( heap, extend_first_block );      
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
 200c0cc:	c6 20 40 00 	st  %g3, [ %g1 ]                               
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
  extend_first_block->size_and_flag =                                 
 200c0d0:	c8 20 a0 04 	st  %g4, [ %g2 + 4 ]                           
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
 200c0d4:	c6 04 20 20 	ld  [ %l0 + 0x20 ], %g3                        
 200c0d8:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200c0dc:	08 80 00 04 	bleu  200c0ec <_Heap_Extend+0x140>             
 200c0e0:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
    heap->first_block = extend_first_block;                           
 200c0e4:	10 80 00 06 	b  200c0fc <_Heap_Extend+0x150>                
 200c0e8:	c4 24 20 20 	st  %g2, [ %l0 + 0x20 ]                        
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
 200c0ec:	c4 04 20 24 	ld  [ %l0 + 0x24 ], %g2                        
 200c0f0:	80 a0 80 01 	cmp  %g2, %g1                                  
 200c0f4:	2a 80 00 02 	bcs,a   200c0fc <_Heap_Extend+0x150>           
 200c0f8:	c2 24 20 24 	st  %g1, [ %l0 + 0x24 ]                        
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
 200c0fc:	80 a5 e0 00 	cmp  %l7, 0                                    
 200c100:	02 80 00 14 	be  200c150 <_Heap_Extend+0x1a4>               
 200c104:	b2 06 60 08 	add  %i1, 8, %i1                               
  Heap_Control *heap,                                                 
  uintptr_t extend_area_begin,                                        
  Heap_Block *first_block                                             
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
 200c108:	e4 04 20 10 	ld  [ %l0 + 0x10 ], %l2                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(                        
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  uintptr_t remainder = value % alignment;                            
 200c10c:	92 10 00 12 	mov  %l2, %o1                                  
 200c110:	40 00 16 43 	call  2011a1c <.urem>                          
 200c114:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( remainder != 0 ) {                                             
 200c118:	80 a2 20 00 	cmp  %o0, 0                                    
 200c11c:	02 80 00 04 	be  200c12c <_Heap_Extend+0x180>               
 200c120:	c2 05 c0 00 	ld  [ %l7 ], %g1                               
    return value - remainder + alignment;                             
 200c124:	b2 06 40 12 	add  %i1, %l2, %i1                             
 200c128:	b2 26 40 08 	sub  %i1, %o0, %i1                             
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
 200c12c:	92 06 7f f8 	add  %i1, -8, %o1                              
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
 200c130:	c2 26 7f f8 	st  %g1, [ %i1 + -8 ]                          
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
    new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;             
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
 200c134:	82 25 c0 09 	sub  %l7, %o1, %g1                             
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
  new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
 200c138:	82 10 60 01 	or  %g1, 1, %g1                                
                                                                      
  _Heap_Free_block( heap, new_first_block );                          
 200c13c:	90 10 00 10 	mov  %l0, %o0                                  
 200c140:	7f ff ff 90 	call  200bf80 <_Heap_Free_block>               
 200c144:	c2 22 60 04 	st  %g1, [ %o1 + 4 ]                           
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
 200c148:	10 80 00 09 	b  200c16c <_Heap_Extend+0x1c0>                
 200c14c:	80 a6 20 00 	cmp  %i0, 0                                    
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
    _Heap_Merge_below( heap, extend_area_begin, merge_below_block );  
  } else if ( link_below_block != NULL ) {                            
 200c150:	80 a7 20 00 	cmp  %i4, 0                                    
 200c154:	02 80 00 05 	be  200c168 <_Heap_Extend+0x1bc>               
 200c158:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
{                                                                     
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const link_begin = (uintptr_t) link;                      
                                                                      
  last_block->size_and_flag =                                         
    (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;           
 200c15c:	b8 27 00 01 	sub  %i4, %g1, %i4                             
 200c160:	b8 17 20 01 	or  %i4, 1, %i4                                
)                                                                     
{                                                                     
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const link_begin = (uintptr_t) link;                      
                                                                      
  last_block->size_and_flag =                                         
 200c164:	f8 20 60 04 	st  %i4, [ %g1 + 4 ]                           
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
 200c168:	80 a6 20 00 	cmp  %i0, 0                                    
 200c16c:	02 80 00 15 	be  200c1c0 <_Heap_Extend+0x214>               
 200c170:	a2 04 7f f8 	add  %l1, -8, %l1                              
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
 200c174:	d2 04 20 10 	ld  [ %l0 + 0x10 ], %o1                        
  uintptr_t extend_area_end                                           
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const last_block_new_size = _Heap_Align_down(             
 200c178:	a2 24 40 18 	sub  %l1, %i0, %l1                             
 200c17c:	40 00 16 28 	call  2011a1c <.urem>                          
 200c180:	90 10 00 11 	mov  %l1, %o0                                  
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
    (last_block->size_and_flag - last_block_new_size)                 
 200c184:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
 200c188:	a2 24 40 08 	sub  %l1, %o0, %l1                             
    page_size                                                         
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
 200c18c:	82 04 40 18 	add  %l1, %i0, %g1                             
    (last_block->size_and_flag - last_block_new_size)                 
 200c190:	84 20 80 11 	sub  %g2, %l1, %g2                             
      | HEAP_PREV_BLOCK_USED;                                         
 200c194:	84 10 a0 01 	or  %g2, 1, %g2                                
    page_size                                                         
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
 200c198:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
 200c19c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
    (last_block->size_and_flag - last_block_new_size)                 
      | HEAP_PREV_BLOCK_USED;                                         
                                                                      
  _Heap_Block_set_size( last_block, last_block_new_size );            
                                                                      
  _Heap_Free_block( heap, last_block );                               
 200c1a0:	90 10 00 10 	mov  %l0, %o0                                  
 200c1a4:	82 08 60 01 	and  %g1, 1, %g1                               
 200c1a8:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
  block->size_and_flag = size | flag;                                 
 200c1ac:	a2 14 40 01 	or  %l1, %g1, %l1                              
 200c1b0:	7f ff ff 74 	call  200bf80 <_Heap_Free_block>               
 200c1b4:	e2 26 20 04 	st  %l1, [ %i0 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
 200c1b8:	10 80 00 0f 	b  200c1f4 <_Heap_Extend+0x248>                
 200c1bc:	80 a6 20 00 	cmp  %i0, 0                                    
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
    _Heap_Merge_above( heap, merge_above_block, extend_area_end );    
  } else if ( link_above_block != NULL ) {                            
 200c1c0:	80 a7 60 00 	cmp  %i5, 0                                    
 200c1c4:	02 80 00 0b 	be  200c1f0 <_Heap_Extend+0x244>               
 200c1c8:	c6 07 bf fc 	ld  [ %fp + -4 ], %g3                          
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
 200c1cc:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
    _Heap_Link_above(                                                 
 200c1d0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
)                                                                     
{                                                                     
  uintptr_t const link_begin = (uintptr_t) link;                      
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
                                                                      
  _Heap_Block_set_size( link, first_block_begin - link_begin );       
 200c1d4:	86 20 c0 1d 	sub  %g3, %i5, %g3                             
 200c1d8:	84 08 a0 01 	and  %g2, 1, %g2                               
                                                                      
  block->size_and_flag = size | flag;                                 
 200c1dc:	84 10 c0 02 	or  %g3, %g2, %g2                              
 200c1e0:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
                                                                      
  last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                  
 200c1e4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
 200c1e8:	84 10 a0 01 	or  %g2, 1, %g2                                
 200c1ec:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
 200c1f0:	80 a6 20 00 	cmp  %i0, 0                                    
 200c1f4:	32 80 00 09 	bne,a   200c218 <_Heap_Extend+0x26c>           
 200c1f8:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
 200c1fc:	80 a5 e0 00 	cmp  %l7, 0                                    
 200c200:	32 80 00 06 	bne,a   200c218 <_Heap_Extend+0x26c>           
 200c204:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
    _Heap_Free_block( heap, extend_first_block );                     
 200c208:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 200c20c:	7f ff ff 5d 	call  200bf80 <_Heap_Free_block>               
 200c210:	90 10 00 10 	mov  %l0, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
    heap->last_block,                                                 
    (uintptr_t) heap->first_block - (uintptr_t) heap->last_block      
 200c214:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
 * This feature will be used to terminate the scattered heap area list.  See
 * also _Heap_Extend().                                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
 200c218:	c6 04 20 20 	ld  [ %l0 + 0x20 ], %g3                        
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
 200c21c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
 * This feature will be used to terminate the scattered heap area list.  See
 * also _Heap_Extend().                                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
 200c220:	86 20 c0 01 	sub  %g3, %g1, %g3                             
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
 200c224:	84 08 a0 01 	and  %g2, 1, %g2                               
                                                                      
  block->size_and_flag = size | flag;                                 
 200c228:	84 10 c0 02 	or  %g3, %g2, %g2                              
 200c22c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
 200c230:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
  stats->size += extended_size;                                       
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
 200c234:	b0 10 20 01 	mov  1, %i0                                    
    _Heap_Free_block( heap, extend_first_block );                     
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
 200c238:	a8 20 40 14 	sub  %g1, %l4, %l4                             
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
 200c23c:	c2 04 20 2c 	ld  [ %l0 + 0x2c ], %g1                        
                                                                      
  if ( extended_size_ptr != NULL )                                    
 200c240:	80 a6 e0 00 	cmp  %i3, 0                                    
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
 200c244:	82 00 40 14 	add  %g1, %l4, %g1                             
                                                                      
  if ( extended_size_ptr != NULL )                                    
 200c248:	02 80 00 03 	be  200c254 <_Heap_Extend+0x2a8>               <== NEVER TAKEN
 200c24c:	c2 24 20 2c 	st  %g1, [ %l0 + 0x2c ]                        
    *extended_size_ptr = extended_size;                               
 200c250:	e8 26 c0 00 	st  %l4, [ %i3 ]                               
 200c254:	81 c7 e0 08 	ret                                            
 200c258:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200bcac <_Heap_Free>:                                                
    return do_free;                                                   
  }                                                                   
#endif                                                                
                                                                      
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )          
{                                                                     
 200bcac:	9d e3 bf a0 	save  %sp, -96, %sp                            
 200bcb0:	a0 10 00 18 	mov  %i0, %l0                                  
 200bcb4:	90 10 00 19 	mov  %i1, %o0                                  
  /*                                                                  
   * If NULL return true so a free on NULL is considered a valid release. This
   * is a special case that could be handled by the in heap check how-ever that
   * would result in false being returned which is wrong.             
   */                                                                 
  if ( alloc_begin_ptr == NULL ) {                                    
 200bcb8:	80 a6 60 00 	cmp  %i1, 0                                    
 200bcbc:	02 80 00 78 	be  200be9c <_Heap_Free+0x1f0>                 
 200bcc0:	b0 10 20 01 	mov  1, %i0                                    
 200bcc4:	d2 04 20 10 	ld  [ %l0 + 0x10 ], %o1                        
 200bcc8:	40 00 16 17 	call  2011524 <.urem>                          
 200bccc:	a2 06 7f f8 	add  %i1, -8, %l1                              
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(                     
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
 200bcd0:	d8 04 20 20 	ld  [ %l0 + 0x20 ], %o4                        
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
 200bcd4:	90 24 40 08 	sub  %l1, %o0, %o0                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 200bcd8:	80 a2 00 0c 	cmp  %o0, %o4                                  
 200bcdc:	0a 80 00 05 	bcs  200bcf0 <_Heap_Free+0x44>                 
 200bce0:	82 10 20 00 	clr  %g1                                       
 200bce4:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
 200bce8:	80 a0 40 08 	cmp  %g1, %o0                                  
 200bcec:	82 60 3f ff 	subx  %g0, -1, %g1                             
  }                                                                   
                                                                      
  alloc_begin = (uintptr_t) alloc_begin_ptr;                          
  block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );  
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, block ) ) {                     
 200bcf0:	80 a0 60 00 	cmp  %g1, 0                                    
 200bcf4:	02 80 00 6a 	be  200be9c <_Heap_Free+0x1f0>                 
 200bcf8:	b0 10 20 00 	clr  %i0                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
 200bcfc:	da 02 20 04 	ld  [ %o0 + 4 ], %o5                           
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 200bd00:	84 0b 7f fe 	and  %o5, -2, %g2                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200bd04:	82 02 00 02 	add  %o0, %g2, %g1                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 200bd08:	80 a0 40 0c 	cmp  %g1, %o4                                  
 200bd0c:	0a 80 00 05 	bcs  200bd20 <_Heap_Free+0x74>                 <== NEVER TAKEN
 200bd10:	86 10 20 00 	clr  %g3                                       
 200bd14:	c6 04 20 24 	ld  [ %l0 + 0x24 ], %g3                        
 200bd18:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200bd1c:	86 60 3f ff 	subx  %g0, -1, %g3                             
  _Heap_Protection_block_check( heap, block );                        
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {                
 200bd20:	80 a0 e0 00 	cmp  %g3, 0                                    
 200bd24:	02 80 00 5e 	be  200be9c <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200bd28:	b0 10 20 00 	clr  %i0                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
 200bd2c:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
    return false;                                                     
  }                                                                   
                                                                      
  _Heap_Protection_block_check( heap, next_block );                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
 200bd30:	80 89 20 01 	btst  1, %g4                                   
 200bd34:	02 80 00 5a 	be  200be9c <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200bd38:	88 09 3f fe 	and  %g4, -2, %g4                              
  if ( !_Heap_Protection_determine_block_free( heap, block ) ) {      
    return true;                                                      
  }                                                                   
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
 200bd3c:	d2 04 20 24 	ld  [ %l0 + 0x24 ], %o1                        
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
 200bd40:	80 a0 40 09 	cmp  %g1, %o1                                  
 200bd44:	02 80 00 07 	be  200bd60 <_Heap_Free+0xb4>                  
 200bd48:	96 10 20 00 	clr  %o3                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
 200bd4c:	86 00 40 04 	add  %g1, %g4, %g3                             
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
 200bd50:	c6 00 e0 04 	ld  [ %g3 + 4 ], %g3                           
 200bd54:	86 08 e0 01 	and  %g3, 1, %g3                               
    return true;                                                      
  }                                                                   
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
 200bd58:	80 a0 00 03 	cmp  %g0, %g3                                  
 200bd5c:	96 60 3f ff 	subx  %g0, -1, %o3                             
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
 200bd60:	80 8b 60 01 	btst  1, %o5                                   
 200bd64:	12 80 00 26 	bne  200bdfc <_Heap_Free+0x150>                
 200bd68:	80 8a e0 ff 	btst  0xff, %o3                                
    uintptr_t const prev_size = block->prev_size;                     
 200bd6c:	da 02 00 00 	ld  [ %o0 ], %o5                               
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200bd70:	86 22 00 0d 	sub  %o0, %o5, %g3                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 200bd74:	80 a0 c0 0c 	cmp  %g3, %o4                                  
 200bd78:	0a 80 00 04 	bcs  200bd88 <_Heap_Free+0xdc>                 <== NEVER TAKEN
 200bd7c:	94 10 20 00 	clr  %o2                                       
 200bd80:	80 a2 40 03 	cmp  %o1, %g3                                  
 200bd84:	94 60 3f ff 	subx  %g0, -1, %o2                             
    Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
                                                                      
    if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {              
 200bd88:	80 a2 a0 00 	cmp  %o2, 0                                    
 200bd8c:	02 80 00 44 	be  200be9c <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200bd90:	b0 10 20 00 	clr  %i0                                       
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
 200bd94:	d8 00 e0 04 	ld  [ %g3 + 4 ], %o4                           
      return( false );                                                
    }                                                                 
                                                                      
    /* As we always coalesce free blocks, the block that preceedes prev_block
       must have been used. */                                        
    if ( !_Heap_Is_prev_used ( prev_block) ) {                        
 200bd98:	80 8b 20 01 	btst  1, %o4                                   
 200bd9c:	02 80 00 40 	be  200be9c <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200bda0:	80 8a e0 ff 	btst  0xff, %o3                                
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
 200bda4:	22 80 00 0f 	be,a   200bde0 <_Heap_Free+0x134>              
 200bda8:	9a 00 80 0d 	add  %g2, %o5, %o5                             
      uintptr_t const size = block_size + prev_size + next_block_size;
 200bdac:	88 00 80 04 	add  %g2, %g4, %g4                             
 200bdb0:	9a 01 00 0d 	add  %g4, %o5, %o5                             
  return _Heap_Free_list_tail(heap)->prev;                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
 200bdb4:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
  Heap_Block *prev = block->prev;                                     
 200bdb8:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
                                                                      
  prev->next = next;                                                  
 200bdbc:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
  next->prev = prev;                                                  
 200bdc0:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
 200bdc4:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
 200bdc8:	82 00 7f ff 	add  %g1, -1, %g1                              
 200bdcc:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
 200bdd0:	da 20 c0 0d 	st  %o5, [ %g3 + %o5 ]                         
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
 200bdd4:	82 13 60 01 	or  %o5, 1, %g1                                
 200bdd8:	10 80 00 27 	b  200be74 <_Heap_Free+0x1c8>                  
 200bddc:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    } else {                      /* coalesce prev */                 
      uintptr_t const size = block_size + prev_size;                  
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
 200bde0:	88 13 60 01 	or  %o5, 1, %g4                                
 200bde4:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
 200bde8:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
      next_block->prev_size = size;                                   
 200bdec:	da 22 00 02 	st  %o5, [ %o0 + %g2 ]                         
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    } else {                      /* coalesce prev */                 
      uintptr_t const size = block_size + prev_size;                  
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
 200bdf0:	86 08 ff fe 	and  %g3, -2, %g3                              
 200bdf4:	10 80 00 20 	b  200be74 <_Heap_Free+0x1c8>                  
 200bdf8:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
 200bdfc:	22 80 00 0d 	be,a   200be30 <_Heap_Free+0x184>              
 200be00:	c6 04 20 08 	ld  [ %l0 + 8 ], %g3                           
    uintptr_t const size = block_size + next_block_size;              
 200be04:	86 01 00 02 	add  %g4, %g2, %g3                             
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(                    
  Heap_Block *old_block,                                              
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = old_block->next;                                 
 200be08:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
  Heap_Block *prev = old_block->prev;                                 
 200be0c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
                                                                      
  new_block->next = next;                                             
 200be10:	c8 22 20 08 	st  %g4, [ %o0 + 8 ]                           
  new_block->prev = prev;                                             
 200be14:	c2 22 20 0c 	st  %g1, [ %o0 + 0xc ]                         
                                                                      
  next->prev = new_block;                                             
  prev->next = new_block;                                             
 200be18:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
  new_block->prev = prev;                                             
                                                                      
  next->prev = new_block;                                             
 200be1c:	d0 21 20 0c 	st  %o0, [ %g4 + 0xc ]                         
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
 200be20:	82 10 e0 01 	or  %g3, 1, %g1                                
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
 200be24:	c6 22 00 03 	st  %g3, [ %o0 + %g3 ]                         
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
    uintptr_t const size = block_size + next_block_size;              
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
 200be28:	10 80 00 13 	b  200be74 <_Heap_Free+0x1c8>                  
 200be2c:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
 200be30:	e0 22 20 0c 	st  %l0, [ %o0 + 0xc ]                         
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
 200be34:	c6 22 20 08 	st  %g3, [ %o0 + 8 ]                           
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
 200be38:	d0 20 e0 0c 	st  %o0, [ %g3 + 0xc ]                         
    next_block->prev_size = size;                                     
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
 200be3c:	86 10 a0 01 	or  %g2, 1, %g3                                
 200be40:	c6 22 20 04 	st  %g3, [ %o0 + 4 ]                           
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
 200be44:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
    next_block->prev_size = block_size;                               
 200be48:	c4 22 00 02 	st  %g2, [ %o0 + %g2 ]                         
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
 200be4c:	86 08 ff fe 	and  %g3, -2, %g3                              
 200be50:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
 200be54:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
    if ( stats->max_free_blocks < stats->free_blocks ) {              
 200be58:	c6 04 20 3c 	ld  [ %l0 + 0x3c ], %g3                        
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
 200be5c:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
 200be60:	d0 24 20 08 	st  %o0, [ %l0 + 8 ]                           
    if ( stats->max_free_blocks < stats->free_blocks ) {              
 200be64:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200be68:	1a 80 00 03 	bcc  200be74 <_Heap_Free+0x1c8>                
 200be6c:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
 200be70:	c2 24 20 3c 	st  %g1, [ %l0 + 0x3c ]                        
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
 200be74:	c2 04 20 40 	ld  [ %l0 + 0x40 ], %g1                        
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
 200be78:	b0 10 20 01 	mov  1, %i0                                    
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
 200be7c:	82 00 7f ff 	add  %g1, -1, %g1                              
 200be80:	c2 24 20 40 	st  %g1, [ %l0 + 0x40 ]                        
  ++stats->frees;                                                     
 200be84:	c2 04 20 50 	ld  [ %l0 + 0x50 ], %g1                        
 200be88:	82 00 60 01 	inc  %g1                                       
 200be8c:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
  stats->free_size += block_size;                                     
 200be90:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
 200be94:	84 00 40 02 	add  %g1, %g2, %g2                             
 200be98:	c4 24 20 30 	st  %g2, [ %l0 + 0x30 ]                        
                                                                      
  return( true );                                                     
}                                                                     
 200be9c:	81 c7 e0 08 	ret                                            
 200bea0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02012e14 <_Heap_Size_of_alloc_area>:                                  
bool _Heap_Size_of_alloc_area(                                        
  Heap_Control *heap,                                                 
  void *alloc_begin_ptr,                                              
  uintptr_t *alloc_size                                               
)                                                                     
{                                                                     
 2012e14:	9d e3 bf a0 	save  %sp, -96, %sp                            
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
 2012e18:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
 2012e1c:	7f ff f9 c2 	call  2011524 <.urem>                          
 2012e20:	90 10 00 19 	mov  %i1, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(                     
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
 2012e24:	c4 06 20 20 	ld  [ %i0 + 0x20 ], %g2                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
 2012e28:	a2 06 7f f8 	add  %i1, -8, %l1                              
 2012e2c:	a0 10 00 18 	mov  %i0, %l0                                  
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
 2012e30:	90 24 40 08 	sub  %l1, %o0, %o0                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 2012e34:	80 a2 00 02 	cmp  %o0, %g2                                  
 2012e38:	0a 80 00 05 	bcs  2012e4c <_Heap_Size_of_alloc_area+0x38>   
 2012e3c:	82 10 20 00 	clr  %g1                                       
 2012e40:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 2012e44:	80 a0 40 08 	cmp  %g1, %o0                                  
 2012e48:	82 60 3f ff 	subx  %g0, -1, %g1                             
  uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;          
  Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
  Heap_Block *next_block = NULL;                                      
  uintptr_t block_size = 0;                                           
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, block ) ) {                     
 2012e4c:	80 a0 60 00 	cmp  %g1, 0                                    
 2012e50:	02 80 00 15 	be  2012ea4 <_Heap_Size_of_alloc_area+0x90>    
 2012e54:	b0 10 20 00 	clr  %i0                                       
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 2012e58:	e2 02 20 04 	ld  [ %o0 + 4 ], %l1                           
 2012e5c:	a2 0c 7f fe 	and  %l1, -2, %l1                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 2012e60:	a2 02 00 11 	add  %o0, %l1, %l1                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 2012e64:	80 a4 40 02 	cmp  %l1, %g2                                  
 2012e68:	0a 80 00 05 	bcs  2012e7c <_Heap_Size_of_alloc_area+0x68>   <== NEVER TAKEN
 2012e6c:	82 10 20 00 	clr  %g1                                       
 2012e70:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
 2012e74:	80 a0 40 11 	cmp  %g1, %l1                                  
 2012e78:	82 60 3f ff 	subx  %g0, -1, %g1                             
  }                                                                   
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if (                                                                
 2012e7c:	80 a0 60 00 	cmp  %g1, 0                                    
 2012e80:	02 80 00 09 	be  2012ea4 <_Heap_Size_of_alloc_area+0x90>    <== NEVER TAKEN
 2012e84:	b0 10 20 00 	clr  %i0                                       
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
 2012e88:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
 2012e8c:	80 88 60 01 	btst  1, %g1                                   
 2012e90:	02 80 00 05 	be  2012ea4 <_Heap_Size_of_alloc_area+0x90>    <== NEVER TAKEN
 2012e94:	a2 24 40 19 	sub  %l1, %i1, %l1                             
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
                                                                      
  return true;                                                        
 2012e98:	b0 10 20 01 	mov  1, %i0                                    
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
 2012e9c:	a2 04 60 04 	add  %l1, 4, %l1                               
 2012ea0:	e2 26 80 00 	st  %l1, [ %i2 ]                               
                                                                      
  return true;                                                        
}                                                                     
 2012ea4:	81 c7 e0 08 	ret                                            
 2012ea8:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02008174 <_Heap_Walk>:                                                
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
 2008174:	9d e3 bf 80 	save  %sp, -128, %sp                           
  uintptr_t const min_block_size = heap->min_block_size;              
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
 2008178:	23 00 80 20 	sethi  %hi(0x2008000), %l1                     
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
 200817c:	a0 10 00 18 	mov  %i0, %l0                                  
  uintptr_t const page_size = heap->page_size;                        
 2008180:	e4 06 20 10 	ld  [ %i0 + 0x10 ], %l2                        
  uintptr_t const min_block_size = heap->min_block_size;              
 2008184:	e8 06 20 14 	ld  [ %i0 + 0x14 ], %l4                        
  Heap_Block *const first_block = heap->first_block;                  
 2008188:	e6 06 20 20 	ld  [ %i0 + 0x20 ], %l3                        
  Heap_Block *const last_block = heap->last_block;                    
 200818c:	ea 06 20 24 	ld  [ %i0 + 0x24 ], %l5                        
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
 2008190:	80 8e a0 ff 	btst  0xff, %i2                                
 2008194:	02 80 00 04 	be  20081a4 <_Heap_Walk+0x30>                  
 2008198:	a2 14 61 20 	or  %l1, 0x120, %l1                            
 200819c:	23 00 80 20 	sethi  %hi(0x2008000), %l1                     
 20081a0:	a2 14 61 28 	or  %l1, 0x128, %l1	! 2008128 <_Heap_Walk_print>
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
 20081a4:	03 00 80 5d 	sethi  %hi(0x2017400), %g1                     
 20081a8:	c2 00 61 6c 	ld  [ %g1 + 0x16c ], %g1	! 201756c <_System_state_Current>
 20081ac:	80 a0 60 03 	cmp  %g1, 3                                    
 20081b0:	12 80 01 2d 	bne  2008664 <_Heap_Walk+0x4f0>                
 20081b4:	b0 10 20 01 	mov  1, %i0                                    
  Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); 
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
                                                                      
  (*printer)(                                                         
 20081b8:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 20081bc:	da 04 20 18 	ld  [ %l0 + 0x18 ], %o5                        
 20081c0:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 20081c4:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
 20081c8:	e6 23 a0 60 	st  %l3, [ %sp + 0x60 ]                        
 20081cc:	c2 23 a0 68 	st  %g1, [ %sp + 0x68 ]                        
 20081d0:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
 20081d4:	ea 23 a0 64 	st  %l5, [ %sp + 0x64 ]                        
 20081d8:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
 20081dc:	90 10 00 19 	mov  %i1, %o0                                  
 20081e0:	92 10 20 00 	clr  %o1                                       
 20081e4:	15 00 80 52 	sethi  %hi(0x2014800), %o2                     
 20081e8:	96 10 00 12 	mov  %l2, %o3                                  
 20081ec:	94 12 a3 20 	or  %o2, 0x320, %o2                            
 20081f0:	9f c4 40 00 	call  %l1                                      
 20081f4:	98 10 00 14 	mov  %l4, %o4                                  
    heap->area_begin, heap->area_end,                                 
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
 20081f8:	80 a4 a0 00 	cmp  %l2, 0                                    
 20081fc:	12 80 00 07 	bne  2008218 <_Heap_Walk+0xa4>                 
 2008200:	80 8c a0 07 	btst  7, %l2                                   
    (*printer)( source, true, "page size is zero\n" );                
 2008204:	15 00 80 52 	sethi  %hi(0x2014800), %o2                     
 2008208:	90 10 00 19 	mov  %i1, %o0                                  
 200820c:	92 10 20 01 	mov  1, %o1                                    
 2008210:	10 80 00 38 	b  20082f0 <_Heap_Walk+0x17c>                  
 2008214:	94 12 a3 b8 	or  %o2, 0x3b8, %o2                            
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
 2008218:	22 80 00 08 	be,a   2008238 <_Heap_Walk+0xc4>               
 200821c:	90 10 00 14 	mov  %l4, %o0                                  
    (*printer)(                                                       
 2008220:	15 00 80 52 	sethi  %hi(0x2014800), %o2                     
 2008224:	90 10 00 19 	mov  %i1, %o0                                  
 2008228:	92 10 20 01 	mov  1, %o1                                    
 200822c:	94 12 a3 d0 	or  %o2, 0x3d0, %o2                            
 2008230:	10 80 01 0b 	b  200865c <_Heap_Walk+0x4e8>                  
 2008234:	96 10 00 12 	mov  %l2, %o3                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
 2008238:	7f ff e6 30 	call  2001af8 <.urem>                          
 200823c:	92 10 00 12 	mov  %l2, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
 2008240:	80 a2 20 00 	cmp  %o0, 0                                    
 2008244:	22 80 00 08 	be,a   2008264 <_Heap_Walk+0xf0>               
 2008248:	90 04 e0 08 	add  %l3, 8, %o0                               
    (*printer)(                                                       
 200824c:	15 00 80 52 	sethi  %hi(0x2014800), %o2                     
 2008250:	90 10 00 19 	mov  %i1, %o0                                  
 2008254:	92 10 20 01 	mov  1, %o1                                    
 2008258:	94 12 a3 f0 	or  %o2, 0x3f0, %o2                            
 200825c:	10 80 01 00 	b  200865c <_Heap_Walk+0x4e8>                  
 2008260:	96 10 00 14 	mov  %l4, %o3                                  
 2008264:	7f ff e6 25 	call  2001af8 <.urem>                          
 2008268:	92 10 00 12 	mov  %l2, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
 200826c:	80 a2 20 00 	cmp  %o0, 0                                    
 2008270:	22 80 00 08 	be,a   2008290 <_Heap_Walk+0x11c>              
 2008274:	c2 04 e0 04 	ld  [ %l3 + 4 ], %g1                           
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
 2008278:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 200827c:	90 10 00 19 	mov  %i1, %o0                                  
 2008280:	92 10 20 01 	mov  1, %o1                                    
 2008284:	94 12 a0 18 	or  %o2, 0x18, %o2                             
 2008288:	10 80 00 f5 	b  200865c <_Heap_Walk+0x4e8>                  
 200828c:	96 10 00 13 	mov  %l3, %o3                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
 2008290:	80 88 60 01 	btst  1, %g1                                   
 2008294:	32 80 00 07 	bne,a   20082b0 <_Heap_Walk+0x13c>             
 2008298:	ec 05 60 04 	ld  [ %l5 + 4 ], %l6                           
    (*printer)(                                                       
 200829c:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 20082a0:	90 10 00 19 	mov  %i1, %o0                                  
 20082a4:	92 10 20 01 	mov  1, %o1                                    
 20082a8:	10 80 00 12 	b  20082f0 <_Heap_Walk+0x17c>                  
 20082ac:	94 12 a0 50 	or  %o2, 0x50, %o2                             
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 20082b0:	ac 0d bf fe 	and  %l6, -2, %l6                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 20082b4:	ac 05 40 16 	add  %l5, %l6, %l6                             
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
 20082b8:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
 20082bc:	80 88 60 01 	btst  1, %g1                                   
 20082c0:	12 80 00 07 	bne  20082dc <_Heap_Walk+0x168>                
 20082c4:	80 a5 80 13 	cmp  %l6, %l3                                  
    (*printer)(                                                       
 20082c8:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 20082cc:	90 10 00 19 	mov  %i1, %o0                                  
 20082d0:	92 10 20 01 	mov  1, %o1                                    
 20082d4:	10 80 00 07 	b  20082f0 <_Heap_Walk+0x17c>                  
 20082d8:	94 12 a0 80 	or  %o2, 0x80, %o2                             
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
 20082dc:	02 80 00 08 	be  20082fc <_Heap_Walk+0x188>                 
 20082e0:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
 20082e4:	90 10 00 19 	mov  %i1, %o0                                  
 20082e8:	92 10 20 01 	mov  1, %o1                                    
 20082ec:	94 12 a0 98 	or  %o2, 0x98, %o2                             
 20082f0:	9f c4 40 00 	call  %l1                                      
 20082f4:	b0 10 20 00 	clr  %i0                                       
 20082f8:	30 80 00 db 	b,a   2008664 <_Heap_Walk+0x4f0>               
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
 20082fc:	d6 04 20 08 	ld  [ %l0 + 8 ], %o3                           
  int source,                                                         
  Heap_Walk_printer printer,                                          
  Heap_Control *heap                                                  
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
 2008300:	fa 04 20 10 	ld  [ %l0 + 0x10 ], %i5                        
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
 2008304:	ae 10 00 10 	mov  %l0, %l7                                  
 2008308:	10 80 00 32 	b  20083d0 <_Heap_Walk+0x25c>                  
 200830c:	b8 10 00 0b 	mov  %o3, %i4                                  
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 2008310:	80 a0 80 1c 	cmp  %g2, %i4                                  
 2008314:	18 80 00 05 	bgu  2008328 <_Heap_Walk+0x1b4>                
 2008318:	82 10 20 00 	clr  %g1                                       
 200831c:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
 2008320:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2008324:	82 60 3f ff 	subx  %g0, -1, %g1                             
  const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
  const Heap_Block *prev_block = free_list_tail;                      
  const Heap_Block *free_block = first_free_block;                    
                                                                      
  while ( free_block != free_list_tail ) {                            
    if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {              
 2008328:	80 a0 60 00 	cmp  %g1, 0                                    
 200832c:	32 80 00 08 	bne,a   200834c <_Heap_Walk+0x1d8>             
 2008330:	90 07 20 08 	add  %i4, 8, %o0                               
      (*printer)(                                                     
 2008334:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 2008338:	96 10 00 1c 	mov  %i4, %o3                                  
 200833c:	90 10 00 19 	mov  %i1, %o0                                  
 2008340:	92 10 20 01 	mov  1, %o1                                    
 2008344:	10 80 00 c6 	b  200865c <_Heap_Walk+0x4e8>                  
 2008348:	94 12 a0 c8 	or  %o2, 0xc8, %o2                             
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
 200834c:	7f ff e5 eb 	call  2001af8 <.urem>                          
 2008350:	92 10 00 1d 	mov  %i5, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
 2008354:	80 a2 20 00 	cmp  %o0, 0                                    
 2008358:	22 80 00 08 	be,a   2008378 <_Heap_Walk+0x204>              
 200835c:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
 2008360:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 2008364:	96 10 00 1c 	mov  %i4, %o3                                  
 2008368:	90 10 00 19 	mov  %i1, %o0                                  
 200836c:	92 10 20 01 	mov  1, %o1                                    
 2008370:	10 80 00 bb 	b  200865c <_Heap_Walk+0x4e8>                  
 2008374:	94 12 a0 e8 	or  %o2, 0xe8, %o2                             
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 2008378:	82 08 7f fe 	and  %g1, -2, %g1                              
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
 200837c:	82 07 00 01 	add  %i4, %g1, %g1                             
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
 2008380:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
 2008384:	80 88 60 01 	btst  1, %g1                                   
 2008388:	22 80 00 08 	be,a   20083a8 <_Heap_Walk+0x234>              
 200838c:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
      (*printer)(                                                     
 2008390:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 2008394:	96 10 00 1c 	mov  %i4, %o3                                  
 2008398:	90 10 00 19 	mov  %i1, %o0                                  
 200839c:	92 10 20 01 	mov  1, %o1                                    
 20083a0:	10 80 00 af 	b  200865c <_Heap_Walk+0x4e8>                  
 20083a4:	94 12 a1 18 	or  %o2, 0x118, %o2                            
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
 20083a8:	80 a3 00 17 	cmp  %o4, %l7                                  
 20083ac:	22 80 00 08 	be,a   20083cc <_Heap_Walk+0x258>              
 20083b0:	ae 10 00 1c 	mov  %i4, %l7                                  
      (*printer)(                                                     
 20083b4:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 20083b8:	96 10 00 1c 	mov  %i4, %o3                                  
 20083bc:	90 10 00 19 	mov  %i1, %o0                                  
 20083c0:	92 10 20 01 	mov  1, %o1                                    
 20083c4:	10 80 00 49 	b  20084e8 <_Heap_Walk+0x374>                  
 20083c8:	94 12 a1 38 	or  %o2, 0x138, %o2                            
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    prev_block = free_block;                                          
    free_block = free_block->next;                                    
 20083cc:	f8 07 20 08 	ld  [ %i4 + 8 ], %i4                           
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
  const Heap_Block *prev_block = free_list_tail;                      
  const Heap_Block *free_block = first_free_block;                    
                                                                      
  while ( free_block != free_list_tail ) {                            
 20083d0:	80 a7 00 10 	cmp  %i4, %l0                                  
 20083d4:	32 bf ff cf 	bne,a   2008310 <_Heap_Walk+0x19c>             
 20083d8:	c4 04 20 20 	ld  [ %l0 + 0x20 ], %g2                        
 20083dc:	35 00 80 53 	sethi  %hi(0x2014c00), %i2                     
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
      (*printer)(                                                     
 20083e0:	31 00 80 53 	sethi  %hi(0x2014c00), %i0                     
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
 20083e4:	b4 16 a2 f8 	or  %i2, 0x2f8, %i2                            
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
      (*printer)(                                                     
 20083e8:	b0 16 22 e0 	or  %i0, 0x2e0, %i0                            
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
 20083ec:	37 00 80 53 	sethi  %hi(0x2014c00), %i3                     
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
 20083f0:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 20083f4:	c6 04 20 20 	ld  [ %l0 + 0x20 ], %g3                        
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 20083f8:	ae 08 7f fe 	and  %g1, -2, %l7                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 20083fc:	ba 05 80 17 	add  %l6, %l7, %i5                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
 2008400:	80 a0 c0 1d 	cmp  %g3, %i5                                  
 2008404:	18 80 00 05 	bgu  2008418 <_Heap_Walk+0x2a4>                <== NEVER TAKEN
 2008408:	84 10 20 00 	clr  %g2                                       
 200840c:	c4 04 20 24 	ld  [ %l0 + 0x24 ], %g2                        
 2008410:	80 a0 80 1d 	cmp  %g2, %i5                                  
 2008414:	84 60 3f ff 	subx  %g0, -1, %g2                             
    bool const prev_used = _Heap_Is_prev_used( block );               
    Heap_Block *const next_block = _Heap_Block_at( block, block_size );
    uintptr_t const next_block_begin = (uintptr_t) next_block;        
    bool const is_not_last_block = block != last_block;               
                                                                      
    if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {              
 2008418:	80 a0 a0 00 	cmp  %g2, 0                                    
 200841c:	12 80 00 07 	bne  2008438 <_Heap_Walk+0x2c4>                
 2008420:	84 1d 80 15 	xor  %l6, %l5, %g2                             
      (*printer)(                                                     
 2008424:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 2008428:	90 10 00 19 	mov  %i1, %o0                                  
 200842c:	92 10 20 01 	mov  1, %o1                                    
 2008430:	10 80 00 2c 	b  20084e0 <_Heap_Walk+0x36c>                  
 2008434:	94 12 a1 70 	or  %o2, 0x170, %o2                            
    uintptr_t const block_begin = (uintptr_t) block;                  
    uintptr_t const block_size = _Heap_Block_size( block );           
    bool const prev_used = _Heap_Is_prev_used( block );               
    Heap_Block *const next_block = _Heap_Block_at( block, block_size );
    uintptr_t const next_block_begin = (uintptr_t) next_block;        
    bool const is_not_last_block = block != last_block;               
 2008438:	80 a0 00 02 	cmp  %g0, %g2                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
 200843c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
 2008440:	b8 40 20 00 	addx  %g0, 0, %i4                              
 2008444:	90 10 00 17 	mov  %l7, %o0                                  
 2008448:	7f ff e5 ac 	call  2001af8 <.urem>                          
 200844c:	92 10 00 12 	mov  %l2, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
 2008450:	80 a2 20 00 	cmp  %o0, 0                                    
 2008454:	02 80 00 0c 	be  2008484 <_Heap_Walk+0x310>                 
 2008458:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200845c:	80 8f 20 ff 	btst  0xff, %i4                                
 2008460:	02 80 00 0a 	be  2008488 <_Heap_Walk+0x314>                 
 2008464:	80 a5 c0 14 	cmp  %l7, %l4                                  
      (*printer)(                                                     
 2008468:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 200846c:	90 10 00 19 	mov  %i1, %o0                                  
 2008470:	92 10 20 01 	mov  1, %o1                                    
 2008474:	94 12 a1 a0 	or  %o2, 0x1a0, %o2                            
 2008478:	96 10 00 16 	mov  %l6, %o3                                  
 200847c:	10 80 00 1b 	b  20084e8 <_Heap_Walk+0x374>                  
 2008480:	98 10 00 17 	mov  %l7, %o4                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
 2008484:	80 a5 c0 14 	cmp  %l7, %l4                                  
 2008488:	1a 80 00 0d 	bcc  20084bc <_Heap_Walk+0x348>                
 200848c:	80 a7 40 16 	cmp  %i5, %l6                                  
 2008490:	80 8f 20 ff 	btst  0xff, %i4                                
 2008494:	02 80 00 0a 	be  20084bc <_Heap_Walk+0x348>                 <== NEVER TAKEN
 2008498:	80 a7 40 16 	cmp  %i5, %l6                                  
      (*printer)(                                                     
 200849c:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 20084a0:	90 10 00 19 	mov  %i1, %o0                                  
 20084a4:	92 10 20 01 	mov  1, %o1                                    
 20084a8:	94 12 a1 d0 	or  %o2, 0x1d0, %o2                            
 20084ac:	96 10 00 16 	mov  %l6, %o3                                  
 20084b0:	98 10 00 17 	mov  %l7, %o4                                  
 20084b4:	10 80 00 3f 	b  20085b0 <_Heap_Walk+0x43c>                  
 20084b8:	9a 10 00 14 	mov  %l4, %o5                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
 20084bc:	38 80 00 0e 	bgu,a   20084f4 <_Heap_Walk+0x380>             
 20084c0:	b8 08 60 01 	and  %g1, 1, %i4                               
 20084c4:	80 8f 20 ff 	btst  0xff, %i4                                
 20084c8:	02 80 00 0b 	be  20084f4 <_Heap_Walk+0x380>                 
 20084cc:	b8 08 60 01 	and  %g1, 1, %i4                               
      (*printer)(                                                     
 20084d0:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 20084d4:	90 10 00 19 	mov  %i1, %o0                                  
 20084d8:	92 10 20 01 	mov  1, %o1                                    
 20084dc:	94 12 a2 00 	or  %o2, 0x200, %o2                            
 20084e0:	96 10 00 16 	mov  %l6, %o3                                  
 20084e4:	98 10 00 1d 	mov  %i5, %o4                                  
 20084e8:	9f c4 40 00 	call  %l1                                      
 20084ec:	b0 10 20 00 	clr  %i0                                       
 20084f0:	30 80 00 5d 	b,a   2008664 <_Heap_Walk+0x4f0>               
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
 20084f4:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
 20084f8:	80 88 60 01 	btst  1, %g1                                   
 20084fc:	12 80 00 3f 	bne  20085f8 <_Heap_Walk+0x484>                
 2008500:	80 a7 20 00 	cmp  %i4, 0                                    
    false,                                                            
    "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",          
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
 2008504:	da 05 a0 0c 	ld  [ %l6 + 0xc ], %o5                         
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
 2008508:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
 200850c:	05 00 80 52 	sethi  %hi(0x2014800), %g2                     
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
 2008510:	c8 04 20 0c 	ld  [ %l0 + 0xc ], %g4                         
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
 2008514:	80 a3 40 01 	cmp  %o5, %g1                                  
 2008518:	02 80 00 07 	be  2008534 <_Heap_Walk+0x3c0>                 
 200851c:	86 10 a2 e0 	or  %g2, 0x2e0, %g3                            
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
 2008520:	80 a3 40 10 	cmp  %o5, %l0                                  
 2008524:	12 80 00 04 	bne  2008534 <_Heap_Walk+0x3c0>                
 2008528:	86 16 e2 a8 	or  %i3, 0x2a8, %g3                            
 200852c:	19 00 80 52 	sethi  %hi(0x2014800), %o4                     
 2008530:	86 13 22 f0 	or  %o4, 0x2f0, %g3	! 2014af0 <_Status_Object_name_errors_to_status+0x48>
    block->next,                                                      
    block->next == last_free_block ?                                  
 2008534:	c4 05 a0 08 	ld  [ %l6 + 8 ], %g2                           
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
 2008538:	19 00 80 52 	sethi  %hi(0x2014800), %o4                     
 200853c:	80 a0 80 04 	cmp  %g2, %g4                                  
 2008540:	02 80 00 07 	be  200855c <_Heap_Walk+0x3e8>                 
 2008544:	82 13 23 00 	or  %o4, 0x300, %g1                            
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
 2008548:	80 a0 80 10 	cmp  %g2, %l0                                  
 200854c:	12 80 00 04 	bne  200855c <_Heap_Walk+0x3e8>                
 2008550:	82 16 e2 a8 	or  %i3, 0x2a8, %g1                            
 2008554:	09 00 80 52 	sethi  %hi(0x2014800), %g4                     
 2008558:	82 11 23 10 	or  %g4, 0x310, %g1	! 2014b10 <_Status_Object_name_errors_to_status+0x68>
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
 200855c:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
 2008560:	c4 23 a0 60 	st  %g2, [ %sp + 0x60 ]                        
 2008564:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
 2008568:	90 10 00 19 	mov  %i1, %o0                                  
 200856c:	92 10 20 00 	clr  %o1                                       
 2008570:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 2008574:	96 10 00 16 	mov  %l6, %o3                                  
 2008578:	94 12 a2 38 	or  %o2, 0x238, %o2                            
 200857c:	9f c4 40 00 	call  %l1                                      
 2008580:	98 10 00 17 	mov  %l7, %o4                                  
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
 2008584:	da 07 40 00 	ld  [ %i5 ], %o5                               
 2008588:	80 a5 c0 0d 	cmp  %l7, %o5                                  
 200858c:	02 80 00 0c 	be  20085bc <_Heap_Walk+0x448>                 
 2008590:	80 a7 20 00 	cmp  %i4, 0                                    
    (*printer)(                                                       
 2008594:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 2008598:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
 200859c:	90 10 00 19 	mov  %i1, %o0                                  
 20085a0:	92 10 20 01 	mov  1, %o1                                    
 20085a4:	94 12 a2 70 	or  %o2, 0x270, %o2                            
 20085a8:	96 10 00 16 	mov  %l6, %o3                                  
 20085ac:	98 10 00 17 	mov  %l7, %o4                                  
 20085b0:	9f c4 40 00 	call  %l1                                      
 20085b4:	b0 10 20 00 	clr  %i0                                       
 20085b8:	30 80 00 2b 	b,a   2008664 <_Heap_Walk+0x4f0>               
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
 20085bc:	32 80 00 0a 	bne,a   20085e4 <_Heap_Walk+0x470>             
 20085c0:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
    (*printer)(                                                       
 20085c4:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
 20085c8:	90 10 00 19 	mov  %i1, %o0                                  
 20085cc:	92 10 20 01 	mov  1, %o1                                    
 20085d0:	10 80 00 22 	b  2008658 <_Heap_Walk+0x4e4>                  
 20085d4:	94 12 a2 b0 	or  %o2, 0x2b0, %o2                            
{                                                                     
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *free_block = _Heap_Free_list_first( heap );       
                                                                      
  while ( free_block != free_list_tail ) {                            
    if ( free_block == block ) {                                      
 20085d8:	02 80 00 19 	be  200863c <_Heap_Walk+0x4c8>                 
 20085dc:	80 a7 40 13 	cmp  %i5, %l3                                  
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
 20085e0:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
)                                                                     
{                                                                     
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *free_block = _Heap_Free_list_first( heap );       
                                                                      
  while ( free_block != free_list_tail ) {                            
 20085e4:	80 a0 40 10 	cmp  %g1, %l0                                  
 20085e8:	12 bf ff fc 	bne  20085d8 <_Heap_Walk+0x464>                
 20085ec:	80 a0 40 16 	cmp  %g1, %l6                                  
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
 20085f0:	10 80 00 17 	b  200864c <_Heap_Walk+0x4d8>                  
 20085f4:	15 00 80 53 	sethi  %hi(0x2014c00), %o2                     
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
 20085f8:	22 80 00 0a 	be,a   2008620 <_Heap_Walk+0x4ac>              
 20085fc:	da 05 80 00 	ld  [ %l6 ], %o5                               
      (*printer)(                                                     
 2008600:	90 10 00 19 	mov  %i1, %o0                                  
 2008604:	92 10 20 00 	clr  %o1                                       
 2008608:	94 10 00 18 	mov  %i0, %o2                                  
 200860c:	96 10 00 16 	mov  %l6, %o3                                  
 2008610:	9f c4 40 00 	call  %l1                                      
 2008614:	98 10 00 17 	mov  %l7, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
 2008618:	10 80 00 09 	b  200863c <_Heap_Walk+0x4c8>                  
 200861c:	80 a7 40 13 	cmp  %i5, %l3                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
 2008620:	90 10 00 19 	mov  %i1, %o0                                  
 2008624:	92 10 20 00 	clr  %o1                                       
 2008628:	94 10 00 1a 	mov  %i2, %o2                                  
 200862c:	96 10 00 16 	mov  %l6, %o3                                  
 2008630:	9f c4 40 00 	call  %l1                                      
 2008634:	98 10 00 17 	mov  %l7, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
 2008638:	80 a7 40 13 	cmp  %i5, %l3                                  
 200863c:	12 bf ff 6d 	bne  20083f0 <_Heap_Walk+0x27c>                
 2008640:	ac 10 00 1d 	mov  %i5, %l6                                  
                                                                      
  return true;                                                        
}                                                                     
 2008644:	81 c7 e0 08 	ret                                            
 2008648:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
 200864c:	90 10 00 19 	mov  %i1, %o0                                  
 2008650:	92 10 20 01 	mov  1, %o1                                    
 2008654:	94 12 a3 20 	or  %o2, 0x320, %o2                            
 2008658:	96 10 00 16 	mov  %l6, %o3                                  
 200865c:	9f c4 40 00 	call  %l1                                      
 2008660:	b0 10 20 00 	clr  %i0                                       
 2008664:	81 c7 e0 08 	ret                                            
 2008668:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200736c <_Objects_Allocate>:                                         
 */                                                                   
                                                                      
Objects_Control *_Objects_Allocate(                                   
  Objects_Information *information                                    
)                                                                     
{                                                                     
 200736c:	9d e3 bf a0 	save  %sp, -96, %sp                            
   *  If the application is using the optional manager stubs and      
   *  still attempts to create the object, the information block      
   *  should be all zeroed out because it is in the BSS.  So let's    
   *  check that code for this manager is even present.               
   */                                                                 
  if ( information->size == 0 )                                       
 2007370:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 */                                                                   
                                                                      
Objects_Control *_Objects_Allocate(                                   
  Objects_Information *information                                    
)                                                                     
{                                                                     
 2007374:	a0 10 00 18 	mov  %i0, %l0                                  
   *  If the application is using the optional manager stubs and      
   *  still attempts to create the object, the information block      
   *  should be all zeroed out because it is in the BSS.  So let's    
   *  check that code for this manager is even present.               
   */                                                                 
  if ( information->size == 0 )                                       
 2007378:	80 a0 60 00 	cmp  %g1, 0                                    
 200737c:	02 80 00 20 	be  20073fc <_Objects_Allocate+0x90>           <== NEVER TAKEN
 2007380:	b0 10 20 00 	clr  %i0                                       
                                                                      
  /*                                                                  
   *  OK.  The manager should be initialized and configured to have objects.
   *  With any luck, it is safe to attempt to allocate an object.     
   */                                                                 
  the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
 2007384:	a2 04 20 20 	add  %l0, 0x20, %l1                            
 2007388:	7f ff fd 8b 	call  20069b4 <_Chain_Get>                     
 200738c:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
  if ( information->auto_extend ) {                                   
 2007390:	c2 0c 20 12 	ldub  [ %l0 + 0x12 ], %g1                      
 2007394:	80 a0 60 00 	cmp  %g1, 0                                    
 2007398:	02 80 00 19 	be  20073fc <_Objects_Allocate+0x90>           
 200739c:	b0 10 00 08 	mov  %o0, %i0                                  
    /*                                                                
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
 20073a0:	80 a2 20 00 	cmp  %o0, 0                                    
 20073a4:	32 80 00 0a 	bne,a   20073cc <_Objects_Allocate+0x60>       
 20073a8:	c2 14 20 0a 	lduh  [ %l0 + 0xa ], %g1                       
      _Objects_Extend_information( information );                     
 20073ac:	40 00 00 1e 	call  2007424 <_Objects_Extend_information>    
 20073b0:	90 10 00 10 	mov  %l0, %o0                                  
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
 20073b4:	7f ff fd 80 	call  20069b4 <_Chain_Get>                     
 20073b8:	90 10 00 11 	mov  %l1, %o0                                  
    }                                                                 
                                                                      
    if ( the_object ) {                                               
 20073bc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20073c0:	02 80 00 0f 	be  20073fc <_Objects_Allocate+0x90>           
 20073c4:	01 00 00 00 	nop                                            
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
 20073c8:	c2 14 20 0a 	lduh  [ %l0 + 0xa ], %g1                       
 20073cc:	d0 16 20 0a 	lduh  [ %i0 + 0xa ], %o0                       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
 20073d0:	d2 14 20 14 	lduh  [ %l0 + 0x14 ], %o1                      
 20073d4:	40 00 27 a8 	call  2011274 <.udiv>                          
 20073d8:	90 22 00 01 	sub  %o0, %g1, %o0                             
                                                                      
      information->inactive_per_block[ block ]--;                     
 20073dc:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
 20073e0:	91 2a 20 02 	sll  %o0, 2, %o0                               
 20073e4:	c4 00 40 08 	ld  [ %g1 + %o0 ], %g2                         
 20073e8:	84 00 bf ff 	add  %g2, -1, %g2                              
 20073ec:	c4 20 40 08 	st  %g2, [ %g1 + %o0 ]                         
      information->inactive--;                                        
 20073f0:	c2 14 20 2c 	lduh  [ %l0 + 0x2c ], %g1                      
 20073f4:	82 00 7f ff 	add  %g1, -1, %g1                              
 20073f8:	c2 34 20 2c 	sth  %g1, [ %l0 + 0x2c ]                       
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
 20073fc:	81 c7 e0 08 	ret                                            
 2007400:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02007774 <_Objects_Get_information>:                                  
                                                                      
Objects_Information *_Objects_Get_information(                        
  Objects_APIs   the_api,                                             
  uint16_t       the_class                                            
)                                                                     
{                                                                     
 2007774:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
 2007778:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
 200777c:	b3 36 60 10 	srl  %i1, 0x10, %i1                            
 2007780:	80 a6 60 00 	cmp  %i1, 0                                    
 2007784:	02 80 00 17 	be  20077e0 <_Objects_Get_information+0x6c>    
 2007788:	a0 10 20 00 	clr  %l0                                       
                                                                      
  /*                                                                  
   *  This call implicitly validates the_api so we do not call        
   *  _Objects_Is_api_valid above here.                               
   */                                                                 
  the_class_api_maximum = _Objects_API_maximum_class( the_api );      
 200778c:	40 00 11 c6 	call  200bea4 <_Objects_API_maximum_class>     
 2007790:	90 10 00 18 	mov  %i0, %o0                                  
  if ( the_class_api_maximum == 0 )                                   
 2007794:	80 a2 20 00 	cmp  %o0, 0                                    
 2007798:	02 80 00 12 	be  20077e0 <_Objects_Get_information+0x6c>    
 200779c:	80 a6 40 08 	cmp  %i1, %o0                                  
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
 20077a0:	18 80 00 10 	bgu  20077e0 <_Objects_Get_information+0x6c>   
 20077a4:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
 20077a8:	b1 2e 20 02 	sll  %i0, 2, %i0                               
 20077ac:	82 10 60 98 	or  %g1, 0x98, %g1                             
 20077b0:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
 20077b4:	80 a0 60 00 	cmp  %g1, 0                                    
 20077b8:	02 80 00 0a 	be  20077e0 <_Objects_Get_information+0x6c>    <== NEVER TAKEN
 20077bc:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
 20077c0:	e0 00 40 19 	ld  [ %g1 + %i1 ], %l0                         
  if ( !info )                                                        
 20077c4:	80 a4 20 00 	cmp  %l0, 0                                    
 20077c8:	02 80 00 06 	be  20077e0 <_Objects_Get_information+0x6c>    <== NEVER TAKEN
 20077cc:	01 00 00 00 	nop                                            
   *  In a multprocessing configuration, we may access remote objects.
   *  Thus we may have 0 local instances and still have a valid object
   *  pointer.                                                        
   */                                                                 
  #if !defined(RTEMS_MULTIPROCESSING)                                 
    if ( info->maximum == 0 )                                         
 20077d0:	c2 14 20 10 	lduh  [ %l0 + 0x10 ], %g1                      
      return NULL;                                                    
 20077d4:	80 a0 00 01 	cmp  %g0, %g1                                  
 20077d8:	82 60 20 00 	subx  %g0, 0, %g1                              
 20077dc:	a0 0c 00 01 	and  %l0, %g1, %l0                             
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
 20077e0:	81 c7 e0 08 	ret                                            
 20077e4:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      
===============================================================================
02018fc8 <_Objects_Get_no_protection>:                                
                                                                      
  /*                                                                  
   * You can't just extract the index portion or you can get tricked  
   * by a value between 1 and maximum.                                
   */                                                                 
  index = id - information->minimum_id + 1;                           
 2018fc8:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
                                                                      
  if ( information->maximum >= index ) {                              
 2018fcc:	c4 12 20 10 	lduh  [ %o0 + 0x10 ], %g2                      
                                                                      
  /*                                                                  
   * You can't just extract the index portion or you can get tricked  
   * by a value between 1 and maximum.                                
   */                                                                 
  index = id - information->minimum_id + 1;                           
 2018fd0:	82 22 40 01 	sub  %o1, %g1, %g1                             
 2018fd4:	82 00 60 01 	inc  %g1                                       
                                                                      
  if ( information->maximum >= index ) {                              
 2018fd8:	80 a0 80 01 	cmp  %g2, %g1                                  
 2018fdc:	0a 80 00 09 	bcs  2019000 <_Objects_Get_no_protection+0x38> 
 2018fe0:	83 28 60 02 	sll  %g1, 2, %g1                               
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
 2018fe4:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
 2018fe8:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0                         
 2018fec:	80 a2 20 00 	cmp  %o0, 0                                    
 2018ff0:	02 80 00 05 	be  2019004 <_Objects_Get_no_protection+0x3c>  <== NEVER TAKEN
 2018ff4:	82 10 20 01 	mov  1, %g1                                    
      *location = OBJECTS_LOCAL;                                      
      return the_object;                                              
 2018ff8:	81 c3 e0 08 	retl                                           
 2018ffc:	c0 22 80 00 	clr  [ %o2 ]                                   
                                                                      
  /*                                                                  
   *  This isn't supported or required yet for Global objects so      
   *  if it isn't local, we don't find it.                            
   */                                                                 
  *location = OBJECTS_ERROR;                                          
 2019000:	82 10 20 01 	mov  1, %g1                                    
  return NULL;                                                        
 2019004:	90 10 20 00 	clr  %o0                                       
}                                                                     
 2019008:	81 c3 e0 08 	retl                                           
 201900c:	c2 22 80 00 	st  %g1, [ %o2 ]                               
                                                                      
===============================================================================
02009050 <_Objects_Id_to_name>:                                       
 */                                                                   
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (                
  Objects_Id      id,                                                 
  Objects_Name   *name                                                
)                                                                     
{                                                                     
 2009050:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Caller is trusted for name != NULL.                             
   */                                                                 
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
 2009054:	92 96 20 00 	orcc  %i0, 0, %o1                              
 2009058:	12 80 00 06 	bne  2009070 <_Objects_Id_to_name+0x20>        
 200905c:	83 32 60 18 	srl  %o1, 0x18, %g1                            
 2009060:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 2009064:	c2 00 63 48 	ld  [ %g1 + 0x348 ], %g1	! 201d348 <_Per_CPU_Information+0xc>
 2009068:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
 200906c:	83 32 60 18 	srl  %o1, 0x18, %g1                            
 2009070:	82 08 60 07 	and  %g1, 7, %g1                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(                      
  uint32_t   the_api                                                  
)                                                                     
{                                                                     
  if ( !the_api || the_api > OBJECTS_APIS_LAST )                      
 2009074:	84 00 7f ff 	add  %g1, -1, %g2                              
 2009078:	80 a0 a0 02 	cmp  %g2, 2                                    
 200907c:	18 80 00 12 	bgu  20090c4 <_Objects_Id_to_name+0x74>        
 2009080:	a0 10 20 03 	mov  3, %l0                                    
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
 2009084:	10 80 00 12 	b  20090cc <_Objects_Id_to_name+0x7c>          
 2009088:	83 28 60 02 	sll  %g1, 2, %g1                               
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_class = _Objects_Get_class( tmpId );                            
                                                                      
  information = _Objects_Information_table[ the_api ][ the_class ];   
 200908c:	85 28 a0 02 	sll  %g2, 2, %g2                               
 2009090:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
  if ( !information )                                                 
 2009094:	80 a2 20 00 	cmp  %o0, 0                                    
 2009098:	02 80 00 0b 	be  20090c4 <_Objects_Id_to_name+0x74>         <== NEVER TAKEN
 200909c:	01 00 00 00 	nop                                            
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    if ( information->is_string )                                     
      return OBJECTS_INVALID_ID;                                      
  #endif                                                              
                                                                      
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
 20090a0:	7f ff ff cf 	call  2008fdc <_Objects_Get>                   
 20090a4:	94 07 bf fc 	add  %fp, -4, %o2                              
  if ( !the_object )                                                  
 20090a8:	80 a2 20 00 	cmp  %o0, 0                                    
 20090ac:	02 80 00 06 	be  20090c4 <_Objects_Id_to_name+0x74>         
 20090b0:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
 20090b4:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
 20090b8:	a0 10 20 00 	clr  %l0                                       
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
  if ( !the_object )                                                  
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
  _Thread_Enable_dispatch();                                          
 20090bc:	40 00 03 72 	call  2009e84 <_Thread_Enable_dispatch>        
 20090c0:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
}                                                                     
 20090c4:	81 c7 e0 08 	ret                                            
 20090c8:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
 20090cc:	05 00 80 74 	sethi  %hi(0x201d000), %g2                     
 20090d0:	84 10 a0 78 	or  %g2, 0x78, %g2	! 201d078 <_Objects_Information_table>
 20090d4:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 20090d8:	80 a0 60 00 	cmp  %g1, 0                                    
 20090dc:	12 bf ff ec 	bne  200908c <_Objects_Id_to_name+0x3c>        
 20090e0:	85 32 60 1b 	srl  %o1, 0x1b, %g2                            
 20090e4:	30 bf ff f8 	b,a   20090c4 <_Objects_Id_to_name+0x74>       
                                                                      
===============================================================================
0200b680 <_RTEMS_tasks_Post_switch_extension>:                        
 */                                                                   
                                                                      
void _RTEMS_tasks_Post_switch_extension(                              
  Thread_Control *executing                                           
)                                                                     
{                                                                     
 200b680:	9d e3 bf 98 	save  %sp, -104, %sp                           
  RTEMS_API_Control *api;                                             
  ASR_Information   *asr;                                             
  rtems_signal_set   signal_set;                                      
  Modes_Control      prev_mode;                                       
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
 200b684:	e0 06 21 58 	ld  [ %i0 + 0x158 ], %l0                       
  if ( !api )                                                         
 200b688:	80 a4 20 00 	cmp  %l0, 0                                    
 200b68c:	02 80 00 1d 	be  200b700 <_RTEMS_tasks_Post_switch_extension+0x80><== NEVER TAKEN
 200b690:	01 00 00 00 	nop                                            
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
 200b694:	7f ff da 14 	call  2001ee4 <sparc_disable_interrupts>       
 200b698:	01 00 00 00 	nop                                            
    signal_set = asr->signals_posted;                                 
 200b69c:	e6 04 20 14 	ld  [ %l0 + 0x14 ], %l3                        
    asr->signals_posted = 0;                                          
 200b6a0:	c0 24 20 14 	clr  [ %l0 + 0x14 ]                            
  _ISR_Enable( level );                                               
 200b6a4:	7f ff da 14 	call  2001ef4 <sparc_enable_interrupts>        
 200b6a8:	01 00 00 00 	nop                                            
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
 200b6ac:	80 a4 e0 00 	cmp  %l3, 0                                    
 200b6b0:	02 80 00 14 	be  200b700 <_RTEMS_tasks_Post_switch_extension+0x80>
 200b6b4:	a2 07 bf fc 	add  %fp, -4, %l1                              
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
 200b6b8:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
 200b6bc:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
 200b6c0:	82 00 60 01 	inc  %g1                                       
 200b6c4:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
 200b6c8:	94 10 00 11 	mov  %l1, %o2                                  
 200b6cc:	25 00 00 3f 	sethi  %hi(0xfc00), %l2                        
 200b6d0:	40 00 07 4c 	call  200d400 <rtems_task_mode>                
 200b6d4:	92 14 a3 ff 	or  %l2, 0x3ff, %o1	! ffff <PROM_START+0xffff> 
                                                                      
  (*asr->handler)( signal_set );                                      
 200b6d8:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
 200b6dc:	9f c0 40 00 	call  %g1                                      
 200b6e0:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
  asr->nest_level -= 1;                                               
 200b6e4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
 200b6e8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
                                                                      
  (*asr->handler)( signal_set );                                      
                                                                      
  asr->nest_level -= 1;                                               
 200b6ec:	82 00 7f ff 	add  %g1, -1, %g1                              
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
 200b6f0:	92 14 a3 ff 	or  %l2, 0x3ff, %o1                            
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
                                                                      
  (*asr->handler)( signal_set );                                      
                                                                      
  asr->nest_level -= 1;                                               
 200b6f4:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
 200b6f8:	40 00 07 42 	call  200d400 <rtems_task_mode>                
 200b6fc:	94 10 00 11 	mov  %l1, %o2                                  
 200b700:	81 c7 e0 08 	ret                                            
 200b704:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
020076c4 <_Rate_monotonic_Timeout>:                                   
                                                                      
void _Rate_monotonic_Timeout(                                         
  Objects_Id  id,                                                     
  void       *ignored                                                 
)                                                                     
{                                                                     
 20076c4:	9d e3 bf 98 	save  %sp, -104, %sp                           
 20076c8:	11 00 80 75 	sethi  %hi(0x201d400), %o0                     
 20076cc:	92 10 00 18 	mov  %i0, %o1                                  
 20076d0:	90 12 21 f4 	or  %o0, 0x1f4, %o0                            
 20076d4:	40 00 07 c2 	call  20095dc <_Objects_Get>                   
 20076d8:	94 07 bf fc 	add  %fp, -4, %o2                              
  /*                                                                  
   *  When we get here, the Timer is already off the chain so we do not
   *  have to worry about that -- hence no _Watchdog_Remove().        
   */                                                                 
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
 20076dc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20076e0:	80 a0 60 00 	cmp  %g1, 0                                    
 20076e4:	12 80 00 24 	bne  2007774 <_Rate_monotonic_Timeout+0xb0>    <== NEVER TAKEN
 20076e8:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
 20076ec:	d0 02 20 40 	ld  [ %o0 + 0x40 ], %o0                        
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
 20076f0:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (             
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_FOR_PERIOD);                   
 20076f4:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
 20076f8:	80 88 80 01 	btst  %g2, %g1                                 
 20076fc:	22 80 00 0b 	be,a   2007728 <_Rate_monotonic_Timeout+0x64>  
 2007700:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
 2007704:	c4 02 20 20 	ld  [ %o0 + 0x20 ], %g2                        
 2007708:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
 200770c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2007710:	32 80 00 06 	bne,a   2007728 <_Rate_monotonic_Timeout+0x64> 
 2007714:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
 2007718:	13 04 00 ff 	sethi  %hi(0x1003fc00), %o1                    
 200771c:	40 00 0a 56 	call  200a074 <_Thread_Clear_state>            
 2007720:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1003fff8 <RAM_END+0xdc3fff8>
 2007724:	30 80 00 06 	b,a   200773c <_Rate_monotonic_Timeout+0x78>   
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
 2007728:	80 a0 60 01 	cmp  %g1, 1                                    
 200772c:	12 80 00 0d 	bne  2007760 <_Rate_monotonic_Timeout+0x9c>    
 2007730:	82 10 20 04 	mov  4, %g1                                    
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
 2007734:	82 10 20 03 	mov  3, %g1                                    
 2007738:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
 200773c:	7f ff fe 66 	call  20070d4 <_Rate_monotonic_Initiate_statistics>
 2007740:	90 10 00 10 	mov  %l0, %o0                                  
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 2007744:	c2 04 20 3c 	ld  [ %l0 + 0x3c ], %g1                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2007748:	11 00 80 76 	sethi  %hi(0x201d800), %o0                     
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 200774c:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2007750:	90 12 20 24 	or  %o0, 0x24, %o0                             
 2007754:	40 00 0f 2e 	call  200b40c <_Watchdog_Insert>               
 2007758:	92 04 20 10 	add  %l0, 0x10, %o1                            
 200775c:	30 80 00 02 	b,a   2007764 <_Rate_monotonic_Timeout+0xa0>   
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
 2007760:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
 2007764:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2007768:	c4 00 63 60 	ld  [ %g1 + 0x360 ], %g2	! 201d760 <_Thread_Dispatch_disable_level>
 200776c:	84 00 bf ff 	add  %g2, -1, %g2                              
 2007770:	c4 20 63 60 	st  %g2, [ %g1 + 0x360 ]                       
 2007774:	81 c7 e0 08 	ret                                            
 2007778:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02007bd4 <_Scheduler_priority_Block>:                                 
#include <rtems/score/thread.h>                                       
                                                                      
void _Scheduler_priority_Block(                                       
  Thread_Control   *the_thread                                        
)                                                                     
{                                                                     
 2007bd4:	9d e3 bf a0 	save  %sp, -96, %sp                            
)                                                                     
{                                                                     
  Scheduler_priority_Per_thread *sched_info;                          
  Chain_Control                 *ready;                               
                                                                      
  sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
 2007bd8:	c4 06 20 8c 	ld  [ %i0 + 0x8c ], %g2                        
  ready      = sched_info->ready_chain;                               
 2007bdc:	c2 00 80 00 	ld  [ %g2 ], %g1                               
                                                                      
  if ( _Chain_Has_only_one_node( ready ) ) {                          
 2007be0:	c8 00 40 00 	ld  [ %g1 ], %g4                               
 2007be4:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
 2007be8:	80 a1 00 03 	cmp  %g4, %g3                                  
 2007bec:	32 80 00 16 	bne,a   2007c44 <_Scheduler_priority_Block+0x70>
 2007bf0:	c4 06 00 00 	ld  [ %i0 ], %g2                               
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
 2007bf4:	86 00 60 04 	add  %g1, 4, %g3                               
                                                                      
  head->next = tail;                                                  
 2007bf8:	c6 20 40 00 	st  %g3, [ %g1 ]                               
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (                  
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor &= the_priority_map->block_minor;          
 2007bfc:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
  head->previous = NULL;                                              
 2007c00:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
  tail->previous = head;                                              
 2007c04:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
 2007c08:	c2 10 a0 0e 	lduh  [ %g2 + 0xe ], %g1                       
 2007c0c:	c8 10 c0 00 	lduh  [ %g3 ], %g4                             
 2007c10:	82 09 00 01 	and  %g4, %g1, %g1                             
 2007c14:	c2 30 c0 00 	sth  %g1, [ %g3 ]                              
  if ( *the_priority_map->minor == 0 )                                
 2007c18:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2007c1c:	80 a0 60 00 	cmp  %g1, 0                                    
 2007c20:	32 80 00 0d 	bne,a   2007c54 <_Scheduler_priority_Block+0x80>
 2007c24:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
    _Priority_Major_bit_map &= the_priority_map->block_major;         
 2007c28:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2007c2c:	c4 10 a0 0c 	lduh  [ %g2 + 0xc ], %g2                       
 2007c30:	c6 10 63 80 	lduh  [ %g1 + 0x380 ], %g3                     
 2007c34:	84 08 80 03 	and  %g2, %g3, %g2                             
 2007c38:	c4 30 63 80 	sth  %g2, [ %g1 + 0x380 ]                      
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (                           
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
 2007c3c:	10 80 00 06 	b  2007c54 <_Scheduler_priority_Block+0x80>    
 2007c40:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 2007c44:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
  next->previous = previous;                                          
 2007c48:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 2007c4c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 2007c50:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
  _Scheduler_priority_Ready_queue_extract( the_thread );              
                                                                      
  /* TODO: flash critical section? */                                 
                                                                      
  if ( _Thread_Is_heir( the_thread ) )                                
 2007c54:	c2 00 63 6c 	ld  [ %g1 + 0x36c ], %g1	! 2014f6c <_Per_CPU_Information+0x10>
 2007c58:	80 a6 00 01 	cmp  %i0, %g1                                  
 2007c5c:	32 80 00 33 	bne,a   2007d28 <_Scheduler_priority_Block+0x154>
 2007c60:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
    (Chain_Control *) _Scheduler.information                          
 2007c64:	03 00 80 50 	sethi  %hi(0x2014000), %g1                     
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
 2007c68:	c6 00 60 90 	ld  [ %g1 + 0x90 ], %g3	! 2014090 <_Scheduler> 
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
 2007c6c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2007c70:	c4 10 63 80 	lduh  [ %g1 + 0x380 ], %g2	! 2014f80 <_Priority_Major_bit_map>
 2007c74:	03 00 80 4d 	sethi  %hi(0x2013400), %g1                     
 2007c78:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2007c7c:	89 30 a0 10 	srl  %g2, 0x10, %g4                            
 2007c80:	80 a1 20 ff 	cmp  %g4, 0xff                                 
 2007c84:	18 80 00 05 	bgu  2007c98 <_Scheduler_priority_Block+0xc4>  
 2007c88:	82 10 63 88 	or  %g1, 0x388, %g1                            
 2007c8c:	c4 08 40 04 	ldub  [ %g1 + %g4 ], %g2                       
 2007c90:	10 80 00 04 	b  2007ca0 <_Scheduler_priority_Block+0xcc>    
 2007c94:	84 00 a0 08 	add  %g2, 8, %g2                               
 2007c98:	85 30 a0 18 	srl  %g2, 0x18, %g2                            
 2007c9c:	c4 08 40 02 	ldub  [ %g1 + %g2 ], %g2                       
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
 2007ca0:	83 28 a0 10 	sll  %g2, 0x10, %g1                            
 2007ca4:	09 00 80 53 	sethi  %hi(0x2014c00), %g4                     
 2007ca8:	83 30 60 0f 	srl  %g1, 0xf, %g1                             
 2007cac:	88 11 23 90 	or  %g4, 0x390, %g4                            
 2007cb0:	c8 11 00 01 	lduh  [ %g4 + %g1 ], %g4                       
 2007cb4:	03 00 80 4d 	sethi  %hi(0x2013400), %g1                     
 2007cb8:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 2007cbc:	9b 31 20 10 	srl  %g4, 0x10, %o5                            
 2007cc0:	80 a3 60 ff 	cmp  %o5, 0xff                                 
 2007cc4:	18 80 00 05 	bgu  2007cd8 <_Scheduler_priority_Block+0x104> 
 2007cc8:	82 10 63 88 	or  %g1, 0x388, %g1                            
 2007ccc:	c2 08 40 0d 	ldub  [ %g1 + %o5 ], %g1                       
 2007cd0:	10 80 00 04 	b  2007ce0 <_Scheduler_priority_Block+0x10c>   
 2007cd4:	82 00 60 08 	add  %g1, 8, %g1                               
 2007cd8:	89 31 20 18 	srl  %g4, 0x18, %g4                            
 2007cdc:	c2 08 40 04 	ldub  [ %g1 + %g4 ], %g1                       
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
          _Priority_Bits_index( minor );                              
 2007ce0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
 2007ce4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
          _Priority_Bits_index( minor );                              
 2007ce8:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
 2007cec:	85 30 a0 0c 	srl  %g2, 0xc, %g2                             
 2007cf0:	84 00 40 02 	add  %g1, %g2, %g2                             
  Chain_Control       *the_ready_queue                                
)                                                                     
{                                                                     
  Priority_Control index = _Priority_bit_map_Get_highest();           
                                                                      
  if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )                
 2007cf4:	89 28 a0 02 	sll  %g2, 2, %g4                               
 2007cf8:	83 28 a0 04 	sll  %g2, 4, %g1                               
 2007cfc:	82 20 40 04 	sub  %g1, %g4, %g1                             
     _Scheduler_priority_Schedule_body();                             
                                                                      
  if ( _Thread_Is_executing( the_thread ) )                           
    _Thread_Dispatch_necessary = true;                                
                                                                      
}                                                                     
 2007d00:	c4 00 c0 01 	ld  [ %g3 + %g1 ], %g2                         
 2007d04:	88 00 c0 01 	add  %g3, %g1, %g4                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 2007d08:	86 01 20 04 	add  %g4, 4, %g3                               
 2007d0c:	80 a0 80 03 	cmp  %g2, %g3                                  
 2007d10:	02 80 00 03 	be  2007d1c <_Scheduler_priority_Block+0x148>  <== NEVER TAKEN
 2007d14:	82 10 20 00 	clr  %g1                                       
    return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
 2007d18:	82 10 00 02 	mov  %g2, %g1                                  
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
 2007d1c:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
 2007d20:	c2 20 a3 6c 	st  %g1, [ %g2 + 0x36c ]	! 2014f6c <_Per_CPU_Information+0x10>
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
 2007d24:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2007d28:	82 10 63 5c 	or  %g1, 0x35c, %g1	! 2014f5c <_Per_CPU_Information>
  /* TODO: flash critical section? */                                 
                                                                      
  if ( _Thread_Is_heir( the_thread ) )                                
     _Scheduler_priority_Schedule_body();                             
                                                                      
  if ( _Thread_Is_executing( the_thread ) )                           
 2007d2c:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 2007d30:	80 a6 00 02 	cmp  %i0, %g2                                  
 2007d34:	12 80 00 03 	bne  2007d40 <_Scheduler_priority_Block+0x16c> 
 2007d38:	84 10 20 01 	mov  1, %g2                                    
    _Thread_Dispatch_necessary = true;                                
 2007d3c:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
 2007d40:	81 c7 e0 08 	ret                                            
 2007d44:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02007ef8 <_Scheduler_priority_Schedule>:                              
#include <rtems/system.h>                                             
#include <rtems/score/scheduler.h>                                    
#include <rtems/score/schedulerpriority.h>                            
                                                                      
void _Scheduler_priority_Schedule(void)                               
{                                                                     
 2007ef8:	9d e3 bf a0 	save  %sp, -96, %sp                            
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
    (Chain_Control *) _Scheduler.information                          
 2007efc:	03 00 80 50 	sethi  %hi(0x2014000), %g1                     
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
 2007f00:	c6 00 60 90 	ld  [ %g1 + 0x90 ], %g3	! 2014090 <_Scheduler> 
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
 2007f04:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2007f08:	c4 10 63 80 	lduh  [ %g1 + 0x380 ], %g2	! 2014f80 <_Priority_Major_bit_map>
 2007f0c:	03 00 80 4d 	sethi  %hi(0x2013400), %g1                     
 2007f10:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2007f14:	89 30 a0 10 	srl  %g2, 0x10, %g4                            
 2007f18:	80 a1 20 ff 	cmp  %g4, 0xff                                 
 2007f1c:	18 80 00 05 	bgu  2007f30 <_Scheduler_priority_Schedule+0x38>
 2007f20:	82 10 63 88 	or  %g1, 0x388, %g1                            
 2007f24:	c4 08 40 04 	ldub  [ %g1 + %g4 ], %g2                       
 2007f28:	10 80 00 04 	b  2007f38 <_Scheduler_priority_Schedule+0x40> 
 2007f2c:	84 00 a0 08 	add  %g2, 8, %g2                               
 2007f30:	85 30 a0 18 	srl  %g2, 0x18, %g2                            
 2007f34:	c4 08 40 02 	ldub  [ %g1 + %g2 ], %g2                       
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
 2007f38:	83 28 a0 10 	sll  %g2, 0x10, %g1                            
 2007f3c:	09 00 80 53 	sethi  %hi(0x2014c00), %g4                     
 2007f40:	83 30 60 0f 	srl  %g1, 0xf, %g1                             
 2007f44:	88 11 23 90 	or  %g4, 0x390, %g4                            
 2007f48:	c8 11 00 01 	lduh  [ %g4 + %g1 ], %g4                       
 2007f4c:	03 00 80 4d 	sethi  %hi(0x2013400), %g1                     
 2007f50:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 2007f54:	9b 31 20 10 	srl  %g4, 0x10, %o5                            
 2007f58:	80 a3 60 ff 	cmp  %o5, 0xff                                 
 2007f5c:	18 80 00 05 	bgu  2007f70 <_Scheduler_priority_Schedule+0x78>
 2007f60:	82 10 63 88 	or  %g1, 0x388, %g1                            
 2007f64:	c2 08 40 0d 	ldub  [ %g1 + %o5 ], %g1                       
 2007f68:	10 80 00 04 	b  2007f78 <_Scheduler_priority_Schedule+0x80> 
 2007f6c:	82 00 60 08 	add  %g1, 8, %g1                               
 2007f70:	89 31 20 18 	srl  %g4, 0x18, %g4                            
 2007f74:	c2 08 40 04 	ldub  [ %g1 + %g4 ], %g1                       
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
          _Priority_Bits_index( minor );                              
 2007f78:	83 28 60 10 	sll  %g1, 0x10, %g1                            
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
 2007f7c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
          _Priority_Bits_index( minor );                              
 2007f80:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
 2007f84:	85 30 a0 0c 	srl  %g2, 0xc, %g2                             
 2007f88:	84 00 40 02 	add  %g1, %g2, %g2                             
  Chain_Control       *the_ready_queue                                
)                                                                     
{                                                                     
  Priority_Control index = _Priority_bit_map_Get_highest();           
                                                                      
  if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )                
 2007f8c:	89 28 a0 02 	sll  %g2, 2, %g4                               
 2007f90:	83 28 a0 04 	sll  %g2, 4, %g1                               
 2007f94:	82 20 40 04 	sub  %g1, %g4, %g1                             
  _Scheduler_priority_Schedule_body();                                
}                                                                     
 2007f98:	c4 00 c0 01 	ld  [ %g3 + %g1 ], %g2                         
 2007f9c:	88 00 c0 01 	add  %g3, %g1, %g4                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 2007fa0:	86 01 20 04 	add  %g4, 4, %g3                               
 2007fa4:	80 a0 80 03 	cmp  %g2, %g3                                  
 2007fa8:	02 80 00 03 	be  2007fb4 <_Scheduler_priority_Schedule+0xbc><== NEVER TAKEN
 2007fac:	82 10 20 00 	clr  %g1                                       
    return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
 2007fb0:	82 10 00 02 	mov  %g2, %g1                                  
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
 2007fb4:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
 2007fb8:	c2 20 a3 6c 	st  %g1, [ %g2 + 0x36c ]	! 2014f6c <_Per_CPU_Information+0x10>
 2007fbc:	81 c7 e0 08 	ret                                            
 2007fc0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
020080dc <_Scheduler_priority_Yield>:                                 
 *    ready chain                                                     
 *    select heir                                                     
 */                                                                   
                                                                      
void _Scheduler_priority_Yield(void)                                  
{                                                                     
 20080dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Scheduler_priority_Per_thread *sched_info;                          
  ISR_Level                      level;                               
  Thread_Control                *executing;                           
  Chain_Control                 *ready;                               
                                                                      
  executing  = _Thread_Executing;                                     
 20080e0:	25 00 80 53 	sethi  %hi(0x2014c00), %l2                     
 20080e4:	a4 14 a3 5c 	or  %l2, 0x35c, %l2	! 2014f5c <_Per_CPU_Information>
 20080e8:	e0 04 a0 0c 	ld  [ %l2 + 0xc ], %l0                         
  sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
  ready      = sched_info->ready_chain;                               
 20080ec:	c2 04 20 8c 	ld  [ %l0 + 0x8c ], %g1                        
  _ISR_Disable( level );                                              
 20080f0:	7f ff e7 7d 	call  2001ee4 <sparc_disable_interrupts>       
 20080f4:	e2 00 40 00 	ld  [ %g1 ], %l1                               
 20080f8:	b0 10 00 08 	mov  %o0, %i0                                  
    if ( !_Chain_Has_only_one_node( ready ) ) {                       
 20080fc:	c4 04 40 00 	ld  [ %l1 ], %g2                               
 2008100:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
 2008104:	80 a0 80 01 	cmp  %g2, %g1                                  
 2008108:	22 80 00 1a 	be,a   2008170 <_Scheduler_priority_Yield+0x94>
 200810c:	c2 04 a0 10 	ld  [ %l2 + 0x10 ], %g1                        
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 2008110:	c4 04 00 00 	ld  [ %l0 ], %g2                               
  previous       = the_node->previous;                                
 2008114:	c2 04 20 04 	ld  [ %l0 + 4 ], %g1                           
  next->previous = previous;                                          
 2008118:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 200811c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 2008120:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
 2008124:	84 04 60 04 	add  %l1, 4, %g2                               
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
 2008128:	e0 24 60 08 	st  %l0, [ %l1 + 8 ]                           
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200812c:	c4 24 00 00 	st  %g2, [ %l0 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 2008130:	e0 20 40 00 	st  %l0, [ %g1 ]                               
  the_node->previous = old_last;                                      
 2008134:	c2 24 20 04 	st  %g1, [ %l0 + 4 ]                           
      _Chain_Extract_unprotected( &executing->Object.Node );          
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
 2008138:	7f ff e7 6f 	call  2001ef4 <sparc_enable_interrupts>        
 200813c:	01 00 00 00 	nop                                            
 2008140:	7f ff e7 69 	call  2001ee4 <sparc_disable_interrupts>       
 2008144:	01 00 00 00 	nop                                            
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
 2008148:	c2 04 a0 10 	ld  [ %l2 + 0x10 ], %g1                        
 200814c:	80 a4 00 01 	cmp  %l0, %g1                                  
 2008150:	12 80 00 04 	bne  2008160 <_Scheduler_priority_Yield+0x84>  <== NEVER TAKEN
 2008154:	84 10 20 01 	mov  1, %g2                                    
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );      
 2008158:	c2 04 40 00 	ld  [ %l1 ], %g1                               
 200815c:	c2 24 a0 10 	st  %g1, [ %l2 + 0x10 ]                        
      _Thread_Dispatch_necessary = true;                              
 2008160:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2008164:	82 10 63 5c 	or  %g1, 0x35c, %g1	! 2014f5c <_Per_CPU_Information>
 2008168:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
 200816c:	30 80 00 05 	b,a   2008180 <_Scheduler_priority_Yield+0xa4> 
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
 2008170:	80 a4 00 01 	cmp  %l0, %g1                                  
 2008174:	02 80 00 03 	be  2008180 <_Scheduler_priority_Yield+0xa4>   
 2008178:	82 10 20 01 	mov  1, %g1                                    
      _Thread_Dispatch_necessary = true;                              
 200817c:	c2 2c a0 18 	stb  %g1, [ %l2 + 0x18 ]                       
                                                                      
  _ISR_Enable( level );                                               
 2008180:	7f ff e7 5d 	call  2001ef4 <sparc_enable_interrupts>        
 2008184:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02007104 <_TOD_Validate>:                                             
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
 2007104:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
	    rtems_configuration_get_microseconds_per_tick();                 
 2007108:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
 200710c:	a0 10 00 18 	mov  %i0, %l0                                  
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
	    rtems_configuration_get_microseconds_per_tick();                 
 2007110:	d2 00 63 e4 	ld  [ %g1 + 0x3e4 ], %o1                       
  if ((!the_tod)                                  ||                  
 2007114:	80 a4 20 00 	cmp  %l0, 0                                    
 2007118:	02 80 00 2b 	be  20071c4 <_TOD_Validate+0xc0>               <== NEVER TAKEN
 200711c:	b0 10 20 00 	clr  %i0                                       
)                                                                     
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
 2007120:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
 2007124:	40 00 48 2c 	call  20191d4 <.udiv>                          
 2007128:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
 200712c:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
 2007130:	80 a0 40 08 	cmp  %g1, %o0                                  
 2007134:	1a 80 00 24 	bcc  20071c4 <_TOD_Validate+0xc0>              
 2007138:	01 00 00 00 	nop                                            
      (the_tod->ticks  >= ticks_per_second)       ||                  
 200713c:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
 2007140:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
 2007144:	18 80 00 20 	bgu  20071c4 <_TOD_Validate+0xc0>              
 2007148:	01 00 00 00 	nop                                            
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
 200714c:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
 2007150:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
 2007154:	18 80 00 1c 	bgu  20071c4 <_TOD_Validate+0xc0>              
 2007158:	01 00 00 00 	nop                                            
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
 200715c:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
 2007160:	80 a0 60 17 	cmp  %g1, 0x17                                 
 2007164:	18 80 00 18 	bgu  20071c4 <_TOD_Validate+0xc0>              
 2007168:	01 00 00 00 	nop                                            
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
 200716c:	c2 04 20 04 	ld  [ %l0 + 4 ], %g1                           
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
      (the_tod->ticks  >= ticks_per_second)       ||                  
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
 2007170:	80 a0 60 00 	cmp  %g1, 0                                    
 2007174:	02 80 00 14 	be  20071c4 <_TOD_Validate+0xc0>               <== NEVER TAKEN
 2007178:	80 a0 60 0c 	cmp  %g1, 0xc                                  
      (the_tod->month  == 0)                      ||                  
 200717c:	18 80 00 12 	bgu  20071c4 <_TOD_Validate+0xc0>              
 2007180:	01 00 00 00 	nop                                            
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
 2007184:	c6 04 00 00 	ld  [ %l0 ], %g3                               
      (the_tod->ticks  >= ticks_per_second)       ||                  
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
 2007188:	80 a0 e7 c3 	cmp  %g3, 0x7c3                                
 200718c:	08 80 00 0e 	bleu  20071c4 <_TOD_Validate+0xc0>             
 2007190:	01 00 00 00 	nop                                            
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
 2007194:	c4 04 20 08 	ld  [ %l0 + 8 ], %g2                           
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
 2007198:	80 a0 a0 00 	cmp  %g2, 0                                    
 200719c:	02 80 00 0a 	be  20071c4 <_TOD_Validate+0xc0>               <== NEVER TAKEN
 20071a0:	80 88 e0 03 	btst  3, %g3                                   
 20071a4:	07 00 80 70 	sethi  %hi(0x201c000), %g3                     
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
 20071a8:	12 80 00 03 	bne  20071b4 <_TOD_Validate+0xb0>              
 20071ac:	86 10 e0 30 	or  %g3, 0x30, %g3	! 201c030 <_TOD_Days_per_month>
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
 20071b0:	82 00 60 0d 	add  %g1, 0xd, %g1                             
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
 20071b4:	83 28 60 02 	sll  %g1, 2, %g1                               
 20071b8:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
 *    false - if the the_tod is invalid                               
 *                                                                    
 *  NOTE: This routine only works for leap-years through 2099.        
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
 20071bc:	80 a0 40 02 	cmp  %g1, %g2                                  
 20071c0:	b0 60 3f ff 	subx  %g0, -1, %i0                             
                                                                      
  if ( the_tod->day > days_in_month )                                 
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
 20071c4:	81 c7 e0 08 	ret                                            
 20071c8:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
020081e0 <_Thread_Change_priority>:                                   
void _Thread_Change_priority(                                         
  Thread_Control   *the_thread,                                       
  Priority_Control  new_priority,                                     
  bool              prepend_it                                        
)                                                                     
{                                                                     
 20081e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  States_Control state, original_state;                               
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
 20081e4:	e2 06 20 10 	ld  [ %i0 + 0x10 ], %l1                        
  /*                                                                  
   * Set a transient state for the thread so it is pulled off the Ready chains.
   * This will prevent it from being scheduled no matter what happens in an
   * ISR.                                                             
   */                                                                 
  _Thread_Set_transient( the_thread );                                
 20081e8:	40 00 03 60 	call  2008f68 <_Thread_Set_transient>          
 20081ec:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   *  Do not bother recomputing all the priority related information if
   *  we are not REALLY changing priority.                            
   */                                                                 
 if ( the_thread->current_priority != new_priority )                  
 20081f0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 20081f4:	80 a0 40 19 	cmp  %g1, %i1                                  
 20081f8:	02 80 00 05 	be  200820c <_Thread_Change_priority+0x2c>     
 20081fc:	a0 10 00 18 	mov  %i0, %l0                                  
    _Thread_Set_priority( the_thread, new_priority );                 
 2008200:	90 10 00 18 	mov  %i0, %o0                                  
 2008204:	40 00 03 3f 	call  2008f00 <_Thread_Set_priority>           
 2008208:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  _ISR_Disable( level );                                              
 200820c:	7f ff e7 36 	call  2001ee4 <sparc_disable_interrupts>       
 2008210:	01 00 00 00 	nop                                            
 2008214:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  /*                                                                  
   *  If the thread has more than STATES_TRANSIENT set, then it is blocked,
   *  If it is blocked on a thread queue, then we need to requeue it. 
   */                                                                 
  state = the_thread->current_state;                                  
 2008218:	f2 04 20 10 	ld  [ %l0 + 0x10 ], %i1                        
  if ( state != STATES_TRANSIENT ) {                                  
 200821c:	80 a6 60 04 	cmp  %i1, 4                                    
 2008220:	02 80 00 10 	be  2008260 <_Thread_Change_priority+0x80>     
 2008224:	a2 0c 60 04 	and  %l1, 4, %l1                               
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
 2008228:	80 a4 60 00 	cmp  %l1, 0                                    
 200822c:	12 80 00 03 	bne  2008238 <_Thread_Change_priority+0x58>    <== NEVER TAKEN
 2008230:	82 0e 7f fb 	and  %i1, -5, %g1                              
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
 2008234:	c2 24 20 10 	st  %g1, [ %l0 + 0x10 ]                        
    _ISR_Enable( level );                                             
 2008238:	7f ff e7 2f 	call  2001ef4 <sparc_enable_interrupts>        
 200823c:	90 10 00 18 	mov  %i0, %o0                                  
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
 2008240:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
 2008244:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
 2008248:	80 8e 40 01 	btst  %i1, %g1                                 
 200824c:	02 80 00 28 	be  20082ec <_Thread_Change_priority+0x10c>    
 2008250:	01 00 00 00 	nop                                            
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
 2008254:	f0 04 20 44 	ld  [ %l0 + 0x44 ], %i0                        
 2008258:	40 00 02 fd 	call  2008e4c <_Thread_queue_Requeue>          
 200825c:	93 e8 00 10 	restore  %g0, %l0, %o1                         
    }                                                                 
    return;                                                           
  }                                                                   
                                                                      
  /* Only clear the transient state if it wasn't set already */       
  if ( ! _States_Is_transient( original_state ) ) {                   
 2008260:	80 a4 60 00 	cmp  %l1, 0                                    
 2008264:	12 80 00 0b 	bne  2008290 <_Thread_Change_priority+0xb0>    <== NEVER TAKEN
 2008268:	03 00 80 50 	sethi  %hi(0x2014000), %g1                     
     *  Interrupts are STILL disabled.                                
     *  We now know the thread will be in the READY state when we remove
     *  the TRANSIENT state.  So we have to place it on the appropriate
     *  Ready Queue with interrupts off.                              
     */                                                               
    the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
 200826c:	c0 24 20 10 	clr  [ %l0 + 0x10 ]                            
                                                                      
    if ( prepend_it )                                                 
 2008270:	80 8e a0 ff 	btst  0xff, %i2                                
 2008274:	02 80 00 04 	be  2008284 <_Thread_Change_priority+0xa4>     
 2008278:	82 10 60 90 	or  %g1, 0x90, %g1                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(                   
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue_first( the_thread );                  
 200827c:	10 80 00 03 	b  2008288 <_Thread_Change_priority+0xa8>      
 2008280:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue( the_thread );                        
 2008284:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
 2008288:	9f c0 40 00 	call  %g1                                      
 200828c:	90 10 00 10 	mov  %l0, %o0                                  
      _Scheduler_Enqueue_first( the_thread );                         
    else                                                              
      _Scheduler_Enqueue( the_thread );                               
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
 2008290:	7f ff e7 19 	call  2001ef4 <sparc_enable_interrupts>        
 2008294:	90 10 00 18 	mov  %i0, %o0                                  
 2008298:	7f ff e7 13 	call  2001ee4 <sparc_disable_interrupts>       
 200829c:	01 00 00 00 	nop                                            
 *  This kernel routine implements the scheduling decision logic for  
 *  the scheduler. It does NOT dispatch.                              
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )                 
{                                                                     
  _Scheduler.Operations.schedule();                                   
 20082a0:	03 00 80 50 	sethi  %hi(0x2014000), %g1                     
 20082a4:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1	! 2014098 <_Scheduler+0x8>
 20082a8:	9f c0 40 00 	call  %g1                                      
 20082ac:	01 00 00 00 	nop                                            
 *  is also the heir thread, and false otherwise.                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )  
{                                                                     
  return ( _Thread_Executing == _Thread_Heir );                       
 20082b0:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 20082b4:	82 10 63 5c 	or  %g1, 0x35c, %g1	! 2014f5c <_Per_CPU_Information>
 20082b8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
   *  We altered the set of thread priorities.  So let's figure out   
   *  who is the heir and if we need to switch to them.               
   */                                                                 
  _Scheduler_Schedule();                                              
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
 20082bc:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
 20082c0:	80 a0 80 03 	cmp  %g2, %g3                                  
 20082c4:	02 80 00 08 	be  20082e4 <_Thread_Change_priority+0x104>    
 20082c8:	01 00 00 00 	nop                                            
 20082cc:	c4 08 a0 74 	ldub  [ %g2 + 0x74 ], %g2                      
 20082d0:	80 a0 a0 00 	cmp  %g2, 0                                    
 20082d4:	02 80 00 04 	be  20082e4 <_Thread_Change_priority+0x104>    
 20082d8:	01 00 00 00 	nop                                            
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
 20082dc:	84 10 20 01 	mov  1, %g2	! 1 <PROM_START+0x1>               
 20082e0:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
  _ISR_Enable( level );                                               
 20082e4:	7f ff e7 04 	call  2001ef4 <sparc_enable_interrupts>        
 20082e8:	81 e8 00 00 	restore                                        
 20082ec:	81 c7 e0 08 	ret                                            
 20082f0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
020084e0 <_Thread_Delay_ended>:                                       
                                                                      
void _Thread_Delay_ended(                                             
  Objects_Id  id,                                                     
  void       *ignored __attribute__((unused))                         
)                                                                     
{                                                                     
 20084e0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 20084e4:	90 10 00 18 	mov  %i0, %o0                                  
 20084e8:	40 00 00 6e 	call  20086a0 <_Thread_Get>                    
 20084ec:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 20084f0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20084f4:	80 a0 60 00 	cmp  %g1, 0                                    
 20084f8:	12 80 00 08 	bne  2008518 <_Thread_Delay_ended+0x38>        <== NEVER TAKEN
 20084fc:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
 2008500:	7f ff ff 7d 	call  20082f4 <_Thread_Clear_state>            
 2008504:	92 12 60 18 	or  %o1, 0x18, %o1	! 10000018 <RAM_END+0xdc00018>
 2008508:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200850c:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 2014d30 <_Thread_Dispatch_disable_level>
 2008510:	84 00 bf ff 	add  %g2, -1, %g2                              
 2008514:	c4 20 61 30 	st  %g2, [ %g1 + 0x130 ]                       
 2008518:	81 c7 e0 08 	ret                                            
 200851c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02008520 <_Thread_Dispatch>:                                          
 *    dispatch thread                                                 
 *    no dispatch thread                                              
 */                                                                   
                                                                      
void _Thread_Dispatch( void )                                         
{                                                                     
 2008520:	9d e3 bf 90 	save  %sp, -112, %sp                           
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
 2008524:	2d 00 80 53 	sethi  %hi(0x2014c00), %l6                     
 2008528:	82 15 a3 5c 	or  %l6, 0x35c, %g1	! 2014f5c <_Per_CPU_Information>
  _ISR_Disable( level );                                              
 200852c:	7f ff e6 6e 	call  2001ee4 <sparc_disable_interrupts>       
 2008530:	e0 00 60 0c 	ld  [ %g1 + 0xc ], %l0                         
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
        _Timestamp_Subtract(                                          
 2008534:	25 00 80 53 	sethi  %hi(0x2014c00), %l2                     
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
 2008538:	37 00 80 53 	sethi  %hi(0x2014c00), %i3                     
 200853c:	b8 10 20 01 	mov  1, %i4                                    
#if __RTEMS_ADA__                                                     
    executing->rtems_ada_self = rtems_ada_self;                       
    rtems_ada_self = heir->rtems_ada_self;                            
#endif                                                                
    if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
 2008540:	3b 00 80 53 	sethi  %hi(0x2014c00), %i5                     
    _ISR_Enable( level );                                             
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
 2008544:	aa 07 bf f8 	add  %fp, -8, %l5                              
        _Timestamp_Subtract(                                          
 2008548:	a8 07 bf f0 	add  %fp, -16, %l4                             
 200854c:	a4 14 a1 e0 	or  %l2, 0x1e0, %l2                            
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
 2008550:	2f 00 80 53 	sethi  %hi(0x2014c00), %l7                     
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
 2008554:	10 80 00 39 	b  2008638 <_Thread_Dispatch+0x118>            
 2008558:	27 00 80 53 	sethi  %hi(0x2014c00), %l3                     
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
 200855c:	f8 26 e1 30 	st  %i4, [ %i3 + 0x130 ]                       
    _Thread_Dispatch_necessary = false;                               
 2008560:	c0 28 60 18 	clrb  [ %g1 + 0x18 ]                           
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
 2008564:	80 a4 40 10 	cmp  %l1, %l0                                  
 2008568:	02 80 00 39 	be  200864c <_Thread_Dispatch+0x12c>           
 200856c:	e2 20 60 0c 	st  %l1, [ %g1 + 0xc ]                         
     */                                                               
#if __RTEMS_ADA__                                                     
    executing->rtems_ada_self = rtems_ada_self;                       
    rtems_ada_self = heir->rtems_ada_self;                            
#endif                                                                
    if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
 2008570:	c2 04 60 7c 	ld  [ %l1 + 0x7c ], %g1                        
 2008574:	80 a0 60 01 	cmp  %g1, 1                                    
 2008578:	12 80 00 03 	bne  2008584 <_Thread_Dispatch+0x64>           
 200857c:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
 2008580:	c2 24 60 78 	st  %g1, [ %l1 + 0x78 ]                        
                                                                      
    _ISR_Enable( level );                                             
 2008584:	7f ff e6 5c 	call  2001ef4 <sparc_enable_interrupts>        
 2008588:	01 00 00 00 	nop                                            
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
 200858c:	40 00 0d 39 	call  200ba70 <_TOD_Get_uptime>                
 2008590:	90 10 00 15 	mov  %l5, %o0                                  
        _Timestamp_Subtract(                                          
 2008594:	90 10 00 12 	mov  %l2, %o0                                  
 2008598:	92 10 00 15 	mov  %l5, %o1                                  
 200859c:	40 00 03 06 	call  20091b4 <_Timespec_Subtract>             
 20085a0:	94 10 00 14 	mov  %l4, %o2                                  
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
 20085a4:	90 04 20 84 	add  %l0, 0x84, %o0                            
 20085a8:	40 00 02 ea 	call  2009150 <_Timespec_Add_to>               
 20085ac:	92 10 00 14 	mov  %l4, %o1                                  
        _Thread_Time_of_last_context_switch = uptime;                 
 20085b0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 20085b4:	c2 24 80 00 	st  %g1, [ %l2 ]                               
 20085b8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20085bc:	c2 24 a0 04 	st  %g1, [ %l2 + 4 ]                           
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
 20085c0:	c2 05 e1 b8 	ld  [ %l7 + 0x1b8 ], %g1                       
 20085c4:	80 a0 60 00 	cmp  %g1, 0                                    
 20085c8:	02 80 00 06 	be  20085e0 <_Thread_Dispatch+0xc0>            <== NEVER TAKEN
 20085cc:	90 10 00 10 	mov  %l0, %o0                                  
      executing->libc_reent = *_Thread_libc_reent;                    
 20085d0:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 20085d4:	c4 24 21 54 	st  %g2, [ %l0 + 0x154 ]                       
      *_Thread_libc_reent = heir->libc_reent;                         
 20085d8:	c4 04 61 54 	ld  [ %l1 + 0x154 ], %g2                       
 20085dc:	c4 20 40 00 	st  %g2, [ %g1 ]                               
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
 20085e0:	40 00 03 a5 	call  2009474 <_User_extensions_Thread_switch> 
 20085e4:	92 10 00 11 	mov  %l1, %o1                                  
    if ( executing->fp_context != NULL )                              
      _Context_Save_fp( &executing->fp_context );                     
#endif                                                                
#endif                                                                
                                                                      
    _Context_Switch( &executing->Registers, &heir->Registers );       
 20085e8:	90 04 20 c8 	add  %l0, 0xc8, %o0                            
 20085ec:	40 00 04 d0 	call  200992c <_CPU_Context_switch>            
 20085f0:	92 04 60 c8 	add  %l1, 0xc8, %o1                            
                                                                      
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )                            
    if ( (executing->fp_context != NULL) &&                           
 20085f4:	c2 04 21 50 	ld  [ %l0 + 0x150 ], %g1                       
 20085f8:	80 a0 60 00 	cmp  %g1, 0                                    
 20085fc:	02 80 00 0c 	be  200862c <_Thread_Dispatch+0x10c>           
 2008600:	d0 04 e1 b4 	ld  [ %l3 + 0x1b4 ], %o0                       
 2008604:	80 a4 00 08 	cmp  %l0, %o0                                  
 2008608:	02 80 00 09 	be  200862c <_Thread_Dispatch+0x10c>           
 200860c:	80 a2 20 00 	cmp  %o0, 0                                    
         !_Thread_Is_allocated_fp( executing ) ) {                    
      if ( _Thread_Allocated_fp != NULL )                             
 2008610:	02 80 00 04 	be  2008620 <_Thread_Dispatch+0x100>           
 2008614:	01 00 00 00 	nop                                            
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );        
 2008618:	40 00 04 8b 	call  2009844 <_CPU_Context_save_fp>           
 200861c:	90 02 21 50 	add  %o0, 0x150, %o0                           
      _Context_Restore_fp( &executing->fp_context );                  
 2008620:	40 00 04 a6 	call  20098b8 <_CPU_Context_restore_fp>        
 2008624:	90 04 21 50 	add  %l0, 0x150, %o0                           
      _Thread_Allocated_fp = executing;                               
 2008628:	e0 24 e1 b4 	st  %l0, [ %l3 + 0x1b4 ]                       
    if ( executing->fp_context != NULL )                              
      _Context_Restore_fp( &executing->fp_context );                  
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
 200862c:	82 15 a3 5c 	or  %l6, 0x35c, %g1                            
                                                                      
    _ISR_Disable( level );                                            
 2008630:	7f ff e6 2d 	call  2001ee4 <sparc_disable_interrupts>       
 2008634:	e0 00 60 0c 	ld  [ %g1 + 0xc ], %l0                         
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
 2008638:	82 15 a3 5c 	or  %l6, 0x35c, %g1                            
 200863c:	c4 08 60 18 	ldub  [ %g1 + 0x18 ], %g2                      
 2008640:	80 a0 a0 00 	cmp  %g2, 0                                    
 2008644:	32 bf ff c6 	bne,a   200855c <_Thread_Dispatch+0x3c>        
 2008648:	e2 00 60 10 	ld  [ %g1 + 0x10 ], %l1                        
                                                                      
    _ISR_Disable( level );                                            
  }                                                                   
                                                                      
post_switch:                                                          
  _Thread_Dispatch_disable_level = 0;                                 
 200864c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2008650:	c0 20 61 30 	clr  [ %g1 + 0x130 ]	! 2014d30 <_Thread_Dispatch_disable_level>
                                                                      
  _ISR_Enable( level );                                               
 2008654:	7f ff e6 28 	call  2001ef4 <sparc_enable_interrupts>        
 2008658:	01 00 00 00 	nop                                            
                                                                      
  _API_extensions_Run_postswitch();                                   
 200865c:	7f ff f8 76 	call  2006834 <_API_extensions_Run_postswitch> 
 2008660:	01 00 00 00 	nop                                            
}                                                                     
 2008664:	81 c7 e0 08 	ret                                            
 2008668:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200d730 <_Thread_Handler>:                                           
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Thread_Handler( void )                                          
{                                                                     
 200d730:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static char doneConstructors;                                     
    char doneCons;                                                    
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
 200d734:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200d738:	e0 00 63 68 	ld  [ %g1 + 0x368 ], %l0	! 2014f68 <_Per_CPU_Information+0xc>
  /*                                                                  
   * Some CPUs need to tinker with the call frame or registers when the
   * thread actually begins to execute for the first time.  This is a 
   * hook point where the port gets a shot at doing whatever it requires.
   */                                                                 
  _Context_Initialization_at_thread_begin();                          
 200d73c:	3f 00 80 35 	sethi  %hi(0x200d400), %i7                     
 200d740:	be 17 e3 30 	or  %i7, 0x330, %i7	! 200d730 <_Thread_Handler>
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
                                                                      
  level = executing->Start.isr_level;                                 
 200d744:	d0 04 20 ac 	ld  [ %l0 + 0xac ], %o0                        
  _ISR_Set_level(level);                                              
 200d748:	7f ff d1 eb 	call  2001ef4 <sparc_enable_interrupts>        
 200d74c:	91 2a 20 08 	sll  %o0, 8, %o0                               
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
 200d750:	03 00 80 52 	sethi  %hi(0x2014800), %g1                     
    doneConstructors = 1;                                             
 200d754:	84 10 20 01 	mov  1, %g2                                    
                                                                      
  level = executing->Start.isr_level;                                 
  _ISR_Set_level(level);                                              
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
 200d758:	e2 08 61 f0 	ldub  [ %g1 + 0x1f0 ], %l1                     
    doneConstructors = 1;                                             
 200d75c:	c4 28 61 f0 	stb  %g2, [ %g1 + 0x1f0 ]                      
  #endif                                                              
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )                        
      if ( (executing->fp_context != NULL) &&                         
 200d760:	c2 04 21 50 	ld  [ %l0 + 0x150 ], %g1                       
 200d764:	80 a0 60 00 	cmp  %g1, 0                                    
 200d768:	02 80 00 0c 	be  200d798 <_Thread_Handler+0x68>             
 200d76c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (                   
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Allocated_fp );                      
 200d770:	d0 00 61 b4 	ld  [ %g1 + 0x1b4 ], %o0	! 2014db4 <_Thread_Allocated_fp>
 200d774:	80 a4 00 08 	cmp  %l0, %o0                                  
 200d778:	02 80 00 08 	be  200d798 <_Thread_Handler+0x68>             
 200d77c:	80 a2 20 00 	cmp  %o0, 0                                    
            !_Thread_Is_allocated_fp( executing ) ) {                 
        if ( _Thread_Allocated_fp != NULL )                           
 200d780:	22 80 00 06 	be,a   200d798 <_Thread_Handler+0x68>          
 200d784:	e0 20 61 b4 	st  %l0, [ %g1 + 0x1b4 ]                       
          _Context_Save_fp( &_Thread_Allocated_fp->fp_context );      
 200d788:	7f ff f0 2f 	call  2009844 <_CPU_Context_save_fp>           
 200d78c:	90 02 21 50 	add  %o0, 0x150, %o0                           
        _Thread_Allocated_fp = executing;                             
 200d790:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200d794:	e0 20 61 b4 	st  %l0, [ %g1 + 0x1b4 ]	! 2014db4 <_Thread_Allocated_fp>
  /*                                                                  
   * Take care that 'begin' extensions get to complete before         
   * 'switch' extensions can run.  This means must keep dispatch      
   * disabled until all 'begin' extensions complete.                  
   */                                                                 
  _User_extensions_Thread_begin( executing );                         
 200d798:	7f ff ee c7 	call  20092b4 <_User_extensions_Thread_begin>  
 200d79c:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
 200d7a0:	7f ff eb b3 	call  200866c <_Thread_Enable_dispatch>        
 200d7a4:	a3 2c 60 18 	sll  %l1, 0x18, %l1                            
    /*                                                                
     *  _init could be a weak symbol and we SHOULD test it but it isn't
     *  in any configuration I know of and it generates a warning on every
     *  RTEMS target configuration.  --joel (12 May 2007)             
     */                                                               
    if (!doneCons) /* && (volatile void *)_init) */ {                 
 200d7a8:	80 a4 60 00 	cmp  %l1, 0                                    
 200d7ac:	32 80 00 05 	bne,a   200d7c0 <_Thread_Handler+0x90>         
 200d7b0:	c2 04 20 94 	ld  [ %l0 + 0x94 ], %g1                        
      INIT_NAME ();                                                   
 200d7b4:	40 00 1a 23 	call  2014040 <_init>                          
 200d7b8:	01 00 00 00 	nop                                            
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
 200d7bc:	c2 04 20 94 	ld  [ %l0 + 0x94 ], %g1                        
 200d7c0:	80 a0 60 00 	cmp  %g1, 0                                    
 200d7c4:	12 80 00 06 	bne  200d7dc <_Thread_Handler+0xac>            <== NEVER TAKEN
 200d7c8:	01 00 00 00 	nop                                            
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
 200d7cc:	c2 04 20 90 	ld  [ %l0 + 0x90 ], %g1                        
 200d7d0:	9f c0 40 00 	call  %g1                                      
 200d7d4:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
      INIT_NAME ();                                                   
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
    executing->Wait.return_argument =                                 
 200d7d8:	d0 24 20 28 	st  %o0, [ %l0 + 0x28 ]                        
   *  was placed in return_argument.  This assumed that if it returned
   *  anything (which is not supporting in all APIs), then it would be
   *  able to fit in a (void *).                                      
   */                                                                 
                                                                      
  _User_extensions_Thread_exitted( executing );                       
 200d7dc:	7f ff ee c7 	call  20092f8 <_User_extensions_Thread_exitted>
 200d7e0:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  _Internal_error_Occurred(                                           
 200d7e4:	90 10 20 00 	clr  %o0                                       
 200d7e8:	92 10 20 01 	mov  1, %o1                                    
 200d7ec:	7f ff e6 b4 	call  20072bc <_Internal_error_Occurred>       
 200d7f0:	94 10 20 05 	mov  5, %o2                                    
                                                                      
===============================================================================
0200874c <_Thread_Initialize>:                                        
  Thread_CPU_budget_algorithms          budget_algorithm,             
  Thread_CPU_budget_algorithm_callout   budget_callout,               
  uint32_t                              isr_level,                    
  Objects_Name                          name                          
)                                                                     
{                                                                     
 200874c:	9d e3 bf a0 	save  %sp, -96, %sp                            
 2008750:	c2 07 a0 6c 	ld  [ %fp + 0x6c ], %g1                        
 2008754:	e4 0f a0 5f 	ldub  [ %fp + 0x5f ], %l2                      
 2008758:	e0 00 40 00 	ld  [ %g1 ], %l0                               
                                                                      
  /*                                                                  
   *  Zero out all the allocated memory fields                        
   */                                                                 
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    the_thread->API_Extensions[i] = NULL;                             
 200875c:	c0 26 61 58 	clr  [ %i1 + 0x158 ]                           
 2008760:	c0 26 61 5c 	clr  [ %i1 + 0x15c ]                           
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
 2008764:	c0 26 61 54 	clr  [ %i1 + 0x154 ]                           
                                                                      
  /*                                                                  
   *  Allocate and Initialize the stack for this thread.              
   */                                                                 
  #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) 
    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
 2008768:	90 10 00 19 	mov  %i1, %o0                                  
 200876c:	40 00 02 0f 	call  2008fa8 <_Thread_Stack_Allocate>         
 2008770:	92 10 00 1b 	mov  %i3, %o1                                  
    if ( !actual_stack_size || actual_stack_size < stack_size )       
 2008774:	80 a2 00 1b 	cmp  %o0, %i3                                  
 2008778:	0a 80 00 63 	bcs  2008904 <_Thread_Initialize+0x1b8>        
 200877c:	80 a2 20 00 	cmp  %o0, 0                                    
 2008780:	02 80 00 61 	be  2008904 <_Thread_Initialize+0x1b8>         <== NEVER TAKEN
 2008784:	80 8f 20 ff 	btst  0xff, %i4                                
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
 2008788:	c2 06 60 c0 	ld  [ %i1 + 0xc0 ], %g1                        
  the_stack->size = size;                                             
 200878c:	d0 26 60 b4 	st  %o0, [ %i1 + 0xb4 ]                        
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
 2008790:	c2 26 60 b8 	st  %g1, [ %i1 + 0xb8 ]                        
                                                                      
  /*                                                                  
   *  Allocate the floating point area for this thread                
   */                                                                 
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    if ( is_fp ) {                                                    
 2008794:	02 80 00 07 	be  20087b0 <_Thread_Initialize+0x64>          
 2008798:	a2 10 20 00 	clr  %l1                                       
      fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );               
 200879c:	40 00 04 0c 	call  20097cc <_Workspace_Allocate>            
 20087a0:	90 10 20 88 	mov  0x88, %o0                                 
      if ( !fp_area )                                                 
 20087a4:	a2 92 20 00 	orcc  %o0, 0, %l1                              
 20087a8:	02 80 00 45 	be  20088bc <_Thread_Initialize+0x170>         
 20087ac:	b6 10 20 00 	clr  %i3                                       
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
 20087b0:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 20087b4:	d0 00 61 c4 	ld  [ %g1 + 0x1c4 ], %o0	! 2014dc4 <_Thread_Maximum_extensions>
      fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );               
      if ( !fp_area )                                                 
        goto failed;                                                  
      fp_area = _Context_Fp_start( fp_area, 0 );                      
    }                                                                 
    the_thread->fp_context       = fp_area;                           
 20087b8:	e2 26 61 50 	st  %l1, [ %i1 + 0x150 ]                       
    the_thread->Start.fp_context = fp_area;                           
 20087bc:	e2 26 60 bc 	st  %l1, [ %i1 + 0xbc ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 20087c0:	c0 26 60 50 	clr  [ %i1 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
 20087c4:	c0 26 60 64 	clr  [ %i1 + 0x64 ]                            
  the_watchdog->id        = id;                                       
 20087c8:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
  the_watchdog->user_data = user_data;                                
 20087cc:	c0 26 60 6c 	clr  [ %i1 + 0x6c ]                            
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
 20087d0:	80 a2 20 00 	cmp  %o0, 0                                    
 20087d4:	02 80 00 08 	be  20087f4 <_Thread_Initialize+0xa8>          
 20087d8:	b6 10 20 00 	clr  %i3                                       
    extensions_area = _Workspace_Allocate(                            
 20087dc:	90 02 20 01 	inc  %o0                                       
 20087e0:	40 00 03 fb 	call  20097cc <_Workspace_Allocate>            
 20087e4:	91 2a 20 02 	sll  %o0, 2, %o0                               
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
 20087e8:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 20087ec:	22 80 00 35 	be,a   20088c0 <_Thread_Initialize+0x174>      
 20087f0:	a4 10 20 00 	clr  %l2                                       
   * if they are linked to the thread. An extension user may          
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
 20087f4:	80 a6 e0 00 	cmp  %i3, 0                                    
 20087f8:	02 80 00 0b 	be  2008824 <_Thread_Initialize+0xd8>          
 20087fc:	f6 26 61 60 	st  %i3, [ %i1 + 0x160 ]                       
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
 2008800:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2008804:	c4 00 61 c4 	ld  [ %g1 + 0x1c4 ], %g2	! 2014dc4 <_Thread_Maximum_extensions>
 2008808:	10 80 00 04 	b  2008818 <_Thread_Initialize+0xcc>           
 200880c:	82 10 20 00 	clr  %g1                                       
 2008810:	82 00 60 01 	inc  %g1                                       
      the_thread->extensions[i] = NULL;                               
 2008814:	c0 26 c0 03 	clr  [ %i3 + %g3 ]                             
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
 2008818:	80 a0 40 02 	cmp  %g1, %g2                                  
 200881c:	08 bf ff fd 	bleu  2008810 <_Thread_Initialize+0xc4>        
 2008820:	87 28 60 02 	sll  %g1, 2, %g3                               
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
 2008824:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
 2008828:	e4 2e 60 a0 	stb  %l2, [ %i1 + 0xa0 ]                       
  the_thread->Start.budget_algorithm = budget_algorithm;              
 200882c:	c2 26 60 a4 	st  %g1, [ %i1 + 0xa4 ]                        
  the_thread->Start.budget_callout   = budget_callout;                
 2008830:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
 2008834:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
 2008838:	c2 26 60 a8 	st  %g1, [ %i1 + 0xa8 ]                        
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
 200883c:	c2 07 a0 68 	ld  [ %fp + 0x68 ], %g1                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
 2008840:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
 2008844:	c2 26 60 ac 	st  %g1, [ %i1 + 0xac ]                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
 2008848:	82 10 20 01 	mov  1, %g1                                    
 200884c:	c2 26 60 10 	st  %g1, [ %i1 + 0x10 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.allocate( the_thread );                
 2008850:	03 00 80 50 	sethi  %hi(0x2014000), %g1                     
 2008854:	c2 00 60 a8 	ld  [ %g1 + 0xa8 ], %g1	! 20140a8 <_Scheduler+0x18>
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
  the_thread->real_priority           = priority;                     
 2008858:	fa 26 60 18 	st  %i5, [ %i1 + 0x18 ]                        
  the_thread->Start.initial_priority  = priority;                     
 200885c:	fa 26 60 b0 	st  %i5, [ %i1 + 0xb0 ]                        
 2008860:	9f c0 40 00 	call  %g1                                      
 2008864:	90 10 00 19 	mov  %i1, %o0                                  
  sched =_Scheduler_Allocate( the_thread );                           
  if ( !sched )                                                       
 2008868:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 200886c:	22 80 00 16 	be,a   20088c4 <_Thread_Initialize+0x178>      
 2008870:	d0 06 61 54 	ld  [ %i1 + 0x154 ], %o0                       
    goto failed;                                                      
  _Thread_Set_priority( the_thread, priority );                       
 2008874:	90 10 00 19 	mov  %i1, %o0                                  
 2008878:	40 00 01 a2 	call  2008f00 <_Thread_Set_priority>           
 200887c:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
   _Workspace_Free( sched );                                          
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
}                                                                     
 2008880:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 2008884:	c2 16 60 0a 	lduh  [ %i1 + 0xa ], %g1                       
                                                                      
  /*                                                                  
   *  Initialize the CPU usage statistics                             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Set_to_zero( &the_thread->cpu_time_used );             
 2008888:	c0 26 60 84 	clr  [ %i1 + 0x84 ]                            
 200888c:	c0 26 60 88 	clr  [ %i1 + 0x88 ]                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 2008890:	83 28 60 02 	sll  %g1, 2, %g1                               
 2008894:	f2 20 80 01 	st  %i1, [ %g2 + %g1 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
 2008898:	e0 26 60 0c 	st  %l0, [ %i1 + 0xc ]                         
   *  enabled when we get here.  We want to be able to run the        
   *  user extensions with dispatching enabled.  The Allocator        
   *  Mutex provides sufficient protection to let the user extensions 
   *  run safely.                                                     
   */                                                                 
  extension_status = _User_extensions_Thread_create( the_thread );    
 200889c:	90 10 00 19 	mov  %i1, %o0                                  
 20088a0:	40 00 02 b8 	call  2009380 <_User_extensions_Thread_create> 
 20088a4:	b0 10 20 01 	mov  1, %i0                                    
  if ( extension_status )                                             
 20088a8:	80 8a 20 ff 	btst  0xff, %o0                                
 20088ac:	22 80 00 06 	be,a   20088c4 <_Thread_Initialize+0x178>      
 20088b0:	d0 06 61 54 	ld  [ %i1 + 0x154 ], %o0                       
 20088b4:	81 c7 e0 08 	ret                                            
 20088b8:	81 e8 00 00 	restore                                        
  size_t               actual_stack_size = 0;                         
  void                *stack = NULL;                                  
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    void              *fp_area;                                       
  #endif                                                              
  void                *sched = NULL;                                  
 20088bc:	a4 10 20 00 	clr  %l2                                       
  extension_status = _User_extensions_Thread_create( the_thread );    
  if ( extension_status )                                             
    return true;                                                      
                                                                      
failed:                                                               
  _Workspace_Free( the_thread->libc_reent );                          
 20088c0:	d0 06 61 54 	ld  [ %i1 + 0x154 ], %o0                       
 20088c4:	40 00 03 cb 	call  20097f0 <_Workspace_Free>                
 20088c8:	b0 10 20 00 	clr  %i0                                       
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    _Workspace_Free( the_thread->API_Extensions[i] );                 
 20088cc:	40 00 03 c9 	call  20097f0 <_Workspace_Free>                
 20088d0:	d0 06 61 58 	ld  [ %i1 + 0x158 ], %o0                       
 20088d4:	40 00 03 c7 	call  20097f0 <_Workspace_Free>                
 20088d8:	d0 06 61 5c 	ld  [ %i1 + 0x15c ], %o0                       
                                                                      
  _Workspace_Free( extensions_area );                                 
 20088dc:	40 00 03 c5 	call  20097f0 <_Workspace_Free>                
 20088e0:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    _Workspace_Free( fp_area );                                       
 20088e4:	40 00 03 c3 	call  20097f0 <_Workspace_Free>                
 20088e8:	90 10 00 11 	mov  %l1, %o0                                  
  #endif                                                              
                                                                      
   _Workspace_Free( sched );                                          
 20088ec:	40 00 03 c1 	call  20097f0 <_Workspace_Free>                
 20088f0:	90 10 00 12 	mov  %l2, %o0                                  
                                                                      
   _Thread_Stack_Free( the_thread );                                  
 20088f4:	40 00 01 c4 	call  2009004 <_Thread_Stack_Free>             
 20088f8:	90 10 00 19 	mov  %i1, %o0                                  
  return false;                                                       
 20088fc:	81 c7 e0 08 	ret                                            
 2008900:	81 e8 00 00 	restore                                        
}                                                                     
 2008904:	81 c7 e0 08 	ret                                            
 2008908:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
===============================================================================
0200c4dc <_Thread_Resume>:                                            
 */                                                                   
void _Thread_Resume(                                                  
  Thread_Control   *the_thread,                                       
  bool              force                                             
)                                                                     
{                                                                     
 200c4dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
 200c4e0:	7f ff d6 d1 	call  2002024 <sparc_disable_interrupts>       
 200c4e4:	a0 10 00 18 	mov  %i0, %l0                                  
 200c4e8:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  current_state = the_thread->current_state;                          
 200c4ec:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
  if ( current_state & STATES_SUSPENDED ) {                           
 200c4f0:	80 88 60 02 	btst  2, %g1                                   
 200c4f4:	02 80 00 09 	be  200c518 <_Thread_Resume+0x3c>              <== NEVER TAKEN
 200c4f8:	82 08 7f fd 	and  %g1, -3, %g1                              
    current_state =                                                   
    the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
                                                                      
    if ( _States_Is_ready( current_state ) ) {                        
 200c4fc:	80 a0 60 00 	cmp  %g1, 0                                    
 200c500:	12 80 00 06 	bne  200c518 <_Thread_Resume+0x3c>             
 200c504:	c2 24 20 10 	st  %g1, [ %l0 + 0x10 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(                         
    Thread_Control    *the_thread                                     
)                                                                     
{                                                                     
  _Scheduler.Operations.unblock( the_thread );                        
 200c508:	03 00 80 5e 	sethi  %hi(0x2017800), %g1                     
 200c50c:	c2 00 62 94 	ld  [ %g1 + 0x294 ], %g1	! 2017a94 <_Scheduler+0x14>
 200c510:	9f c0 40 00 	call  %g1                                      
 200c514:	90 10 00 10 	mov  %l0, %o0                                  
      _Scheduler_Unblock( the_thread );                               
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
 200c518:	7f ff d6 c7 	call  2002034 <sparc_enable_interrupts>        
 200c51c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02008e4c <_Thread_queue_Requeue>:                                     
                                                                      
void _Thread_queue_Requeue(                                           
  Thread_queue_Control *the_thread_queue,                             
  Thread_Control       *the_thread                                    
)                                                                     
{                                                                     
 2008e4c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  /*                                                                  
   * Just in case the thread really wasn't blocked on a thread queue  
   * when we get here.                                                
   */                                                                 
  if ( !the_thread_queue )                                            
 2008e50:	80 a6 20 00 	cmp  %i0, 0                                    
 2008e54:	02 80 00 19 	be  2008eb8 <_Thread_queue_Requeue+0x6c>       <== NEVER TAKEN
 2008e58:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If queueing by FIFO, there is nothing to do. This only applies to
   * priority blocking discipline.                                    
   */                                                                 
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
 2008e5c:	e2 06 20 34 	ld  [ %i0 + 0x34 ], %l1                        
 2008e60:	80 a4 60 01 	cmp  %l1, 1                                    
 2008e64:	12 80 00 15 	bne  2008eb8 <_Thread_queue_Requeue+0x6c>      <== NEVER TAKEN
 2008e68:	01 00 00 00 	nop                                            
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
 2008e6c:	7f ff e4 1e 	call  2001ee4 <sparc_disable_interrupts>       
 2008e70:	01 00 00 00 	nop                                            
 2008e74:	a0 10 00 08 	mov  %o0, %l0                                  
 2008e78:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
 2008e7c:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
 2008e80:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
 2008e84:	80 88 80 01 	btst  %g2, %g1                                 
 2008e88:	02 80 00 0a 	be  2008eb0 <_Thread_queue_Requeue+0x64>       <== NEVER TAKEN
 2008e8c:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
 2008e90:	92 10 00 19 	mov  %i1, %o1                                  
 2008e94:	94 10 20 01 	mov  1, %o2                                    
 2008e98:	40 00 0c 6c 	call  200c048 <_Thread_queue_Extract_priority_helper>
 2008e9c:	e2 26 20 30 	st  %l1, [ %i0 + 0x30 ]                        
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
 2008ea0:	90 10 00 18 	mov  %i0, %o0                                  
 2008ea4:	92 10 00 19 	mov  %i1, %o1                                  
 2008ea8:	7f ff ff 49 	call  2008bcc <_Thread_queue_Enqueue_priority> 
 2008eac:	94 07 bf fc 	add  %fp, -4, %o2                              
    }                                                                 
    _ISR_Enable( level );                                             
 2008eb0:	7f ff e4 11 	call  2001ef4 <sparc_enable_interrupts>        
 2008eb4:	90 10 00 10 	mov  %l0, %o0                                  
 2008eb8:	81 c7 e0 08 	ret                                            
 2008ebc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02008ec0 <_Thread_queue_Timeout>:                                     
                                                                      
void _Thread_queue_Timeout(                                           
  Objects_Id  id,                                                     
  void       *ignored __attribute__((unused))                         
)                                                                     
{                                                                     
 2008ec0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 2008ec4:	90 10 00 18 	mov  %i0, %o0                                  
 2008ec8:	7f ff fd f6 	call  20086a0 <_Thread_Get>                    
 2008ecc:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 2008ed0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2008ed4:	80 a0 60 00 	cmp  %g1, 0                                    
 2008ed8:	12 80 00 08 	bne  2008ef8 <_Thread_queue_Timeout+0x38>      <== NEVER TAKEN
 2008edc:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
 2008ee0:	40 00 0c 92 	call  200c128 <_Thread_queue_Process_timeout>  
 2008ee4:	01 00 00 00 	nop                                            
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
 2008ee8:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2008eec:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 2014d30 <_Thread_Dispatch_disable_level>
 2008ef0:	84 00 bf ff 	add  %g2, -1, %g2                              
 2008ef4:	c4 20 61 30 	st  %g2, [ %g1 + 0x130 ]                       
 2008ef8:	81 c7 e0 08 	ret                                            
 2008efc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
020167a0 <_Timer_server_Body>:                                        
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
 20167a0:	9d e3 bf 88 	save  %sp, -120, %sp                           
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
 20167a4:	39 00 80 f1 	sethi  %hi(0x203c400), %i4                     
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 20167a8:	b6 07 bf f4 	add  %fp, -12, %i3                             
 20167ac:	ae 07 bf f8 	add  %fp, -8, %l7                              
 20167b0:	a4 07 bf e8 	add  %fp, -24, %l2                             
 20167b4:	a6 07 bf ec 	add  %fp, -20, %l3                             
 20167b8:	ee 27 bf f4 	st  %l7, [ %fp + -12 ]                         
  head->previous = NULL;                                              
 20167bc:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  tail->previous = head;                                              
 20167c0:	f6 27 bf fc 	st  %i3, [ %fp + -4 ]                          
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 20167c4:	e6 27 bf e8 	st  %l3, [ %fp + -24 ]                         
  head->previous = NULL;                                              
 20167c8:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
 20167cc:	e4 27 bf f0 	st  %l2, [ %fp + -16 ]                         
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
 20167d0:	a8 06 20 30 	add  %i0, 0x30, %l4                            
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
 20167d4:	3b 00 80 f1 	sethi  %hi(0x203c400), %i5                     
     /*                                                               
      *  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 ); 
 20167d8:	a2 06 20 68 	add  %i0, 0x68, %l1                            
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
 20167dc:	ac 06 20 08 	add  %i0, 8, %l6                               
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
 20167e0:	aa 06 20 40 	add  %i0, 0x40, %l5                            
  Chain_Control *tmp;                                                 
  /*                                                                  
   *  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;                                    
 20167e4:	f6 26 20 78 	st  %i3, [ %i0 + 0x78 ]                        
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
 20167e8:	c2 07 22 14 	ld  [ %i4 + 0x214 ], %g1                       
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
 20167ec:	d2 06 20 3c 	ld  [ %i0 + 0x3c ], %o1                        
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
 20167f0:	94 10 00 12 	mov  %l2, %o2                                  
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
 20167f4:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
 20167f8:	90 10 00 14 	mov  %l4, %o0                                  
 20167fc:	40 00 11 bf 	call  201aef8 <_Watchdog_Adjust_to_chain>      
 2016800:	92 20 40 09 	sub  %g1, %o1, %o1                             
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;         
 2016804:	d4 06 20 74 	ld  [ %i0 + 0x74 ], %o2                        
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
 2016808:	e0 07 61 8c 	ld  [ %i5 + 0x18c ], %l0                       
  /*                                                                  
   *  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 ) {                                   
 201680c:	80 a4 00 0a 	cmp  %l0, %o2                                  
 2016810:	08 80 00 06 	bleu  2016828 <_Timer_server_Body+0x88>        
 2016814:	92 24 00 0a 	sub  %l0, %o2, %o1                             
    /*                                                                
     *  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 );
 2016818:	90 10 00 11 	mov  %l1, %o0                                  
 201681c:	40 00 11 b7 	call  201aef8 <_Watchdog_Adjust_to_chain>      
 2016820:	94 10 00 12 	mov  %l2, %o2                                  
 2016824:	30 80 00 06 	b,a   201683c <_Timer_server_Body+0x9c>        
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
 2016828:	1a 80 00 05 	bcc  201683c <_Timer_server_Body+0x9c>         
 201682c:	90 10 00 11 	mov  %l1, %o0                                  
     /*                                                               
      *  The current TOD is before the last TOD which indicates that  
      *  TOD has been set backwards.                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
 2016830:	92 10 20 01 	mov  1, %o1                                    
 2016834:	40 00 11 89 	call  201ae58 <_Watchdog_Adjust>               
 2016838:	94 22 80 10 	sub  %o2, %l0, %o2                             
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
 201683c:	e0 26 20 74 	st  %l0, [ %i0 + 0x74 ]                        
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
 2016840:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
 2016844:	40 00 02 c0 	call  2017344 <_Chain_Get>                     
 2016848:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
 201684c:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2016850:	02 80 00 0c 	be  2016880 <_Timer_server_Body+0xe0>          
 2016854:	01 00 00 00 	nop                                            
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
 2016858:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        
 201685c:	80 a0 60 01 	cmp  %g1, 1                                    
 2016860:	02 80 00 05 	be  2016874 <_Timer_server_Body+0xd4>          
 2016864:	90 10 00 14 	mov  %l4, %o0                                  
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
 2016868:	80 a0 60 03 	cmp  %g1, 3                                    
 201686c:	12 bf ff f5 	bne  2016840 <_Timer_server_Body+0xa0>         <== NEVER TAKEN
 2016870:	90 10 00 11 	mov  %l1, %o0                                  
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
 2016874:	40 00 11 d5 	call  201afc8 <_Watchdog_Insert>               
 2016878:	92 02 60 10 	add  %o1, 0x10, %o1                            
 201687c:	30 bf ff f1 	b,a   2016840 <_Timer_server_Body+0xa0>        
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
 2016880:	7f ff e3 4d 	call  200f5b4 <sparc_disable_interrupts>       
 2016884:	01 00 00 00 	nop                                            
      tmp = ts->insert_chain;                                         
 2016888:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
      if ( _Chain_Is_empty( insert_chain ) ) {                        
 201688c:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
 2016890:	80 a0 40 17 	cmp  %g1, %l7                                  
 2016894:	12 80 00 04 	bne  20168a4 <_Timer_server_Body+0x104>        <== NEVER TAKEN
 2016898:	a0 10 20 01 	mov  1, %l0                                    
        ts->insert_chain = NULL;                                      
 201689c:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
        do_loop          = false;                                     
 20168a0:	a0 10 20 00 	clr  %l0                                       
      }                                                               
    _ISR_Enable( level );                                             
 20168a4:	7f ff e3 48 	call  200f5c4 <sparc_enable_interrupts>        
 20168a8:	01 00 00 00 	nop                                            
   *  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;                                    
                                                                      
  while ( do_loop ) {                                                 
 20168ac:	80 8c 20 ff 	btst  0xff, %l0                                
 20168b0:	12 bf ff ce 	bne  20167e8 <_Timer_server_Body+0x48>         <== NEVER TAKEN
 20168b4:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
  _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 ) ) {                          
 20168b8:	80 a0 40 13 	cmp  %g1, %l3                                  
 20168bc:	02 80 00 18 	be  201691c <_Timer_server_Body+0x17c>         
 20168c0:	01 00 00 00 	nop                                            
                                                                      
        /*                                                            
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
 20168c4:	7f ff e3 3c 	call  200f5b4 <sparc_disable_interrupts>       
 20168c8:	01 00 00 00 	nop                                            
 20168cc:	84 10 00 08 	mov  %o0, %g2                                  
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
 20168d0:	e0 07 bf e8 	ld  [ %fp + -24 ], %l0                         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
 20168d4:	80 a4 00 13 	cmp  %l0, %l3                                  
 20168d8:	02 80 00 0e 	be  2016910 <_Timer_server_Body+0x170>         
 20168dc:	80 a4 20 00 	cmp  %l0, 0                                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
 20168e0:	c2 04 00 00 	ld  [ %l0 ], %g1                               
                                                                      
  head->next = new_first;                                             
 20168e4:	c2 27 bf e8 	st  %g1, [ %fp + -24 ]                         
         *  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 ) {                                     
 20168e8:	02 80 00 0a 	be  2016910 <_Timer_server_Body+0x170>         <== NEVER TAKEN
 20168ec:	e4 20 60 04 	st  %l2, [ %g1 + 4 ]                           
          watchdog->state = WATCHDOG_INACTIVE;                        
 20168f0:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
          _ISR_Enable( level );                                       
 20168f4:	7f ff e3 34 	call  200f5c4 <sparc_enable_interrupts>        
 20168f8:	01 00 00 00 	nop                                            
        /*                                                            
         *  The timer server may block here and wait for resources or time.
         *  The system watchdogs are inactive and will remain inactive since
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
 20168fc:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 2016900:	d0 04 20 20 	ld  [ %l0 + 0x20 ], %o0                        
 2016904:	9f c0 40 00 	call  %g1                                      
 2016908:	d2 04 20 24 	ld  [ %l0 + 0x24 ], %o1                        
      }                                                               
 201690c:	30 bf ff ee 	b,a   20168c4 <_Timer_server_Body+0x124>       
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
          _ISR_Enable( level );                                       
        } else {                                                      
          _ISR_Enable( level );                                       
 2016910:	7f ff e3 2d 	call  200f5c4 <sparc_enable_interrupts>        
 2016914:	90 10 00 02 	mov  %g2, %o0                                  
 2016918:	30 bf ff b3 	b,a   20167e4 <_Timer_server_Body+0x44>        
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
 201691c:	c0 2e 20 7c 	clrb  [ %i0 + 0x7c ]                           
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
 2016920:	7f ff ff 70 	call  20166e0 <_Thread_Disable_dispatch>       
 2016924:	01 00 00 00 	nop                                            
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
 2016928:	d0 06 00 00 	ld  [ %i0 ], %o0                               
 201692c:	40 00 0f 9f 	call  201a7a8 <_Thread_Set_state>              
 2016930:	92 10 20 08 	mov  8, %o1                                    
        _Timer_server_Reset_interval_system_watchdog( ts );           
 2016934:	7f ff ff 71 	call  20166f8 <_Timer_server_Reset_interval_system_watchdog>
 2016938:	90 10 00 18 	mov  %i0, %o0                                  
        _Timer_server_Reset_tod_system_watchdog( ts );                
 201693c:	7f ff ff 84 	call  201674c <_Timer_server_Reset_tod_system_watchdog>
 2016940:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_Enable_dispatch();                                      
 2016944:	40 00 0d 37 	call  2019e20 <_Thread_Enable_dispatch>        
 2016948:	01 00 00 00 	nop                                            
                                                                      
      ts->active = true;                                              
 201694c:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
 2016950:	90 10 00 16 	mov  %l6, %o0                                  
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
        _Timer_server_Reset_interval_system_watchdog( ts );           
        _Timer_server_Reset_tod_system_watchdog( ts );                
      _Thread_Enable_dispatch();                                      
                                                                      
      ts->active = true;                                              
 2016954:	c2 2e 20 7c 	stb  %g1, [ %i0 + 0x7c ]                       
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
 2016958:	40 00 11 f8 	call  201b138 <_Watchdog_Remove>               
 201695c:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
 2016960:	40 00 11 f6 	call  201b138 <_Watchdog_Remove>               
 2016964:	90 10 00 15 	mov  %l5, %o0                                  
 2016968:	30 bf ff 9f 	b,a   20167e4 <_Timer_server_Body+0x44>        
                                                                      
===============================================================================
0201696c <_Timer_server_Schedule_operation_method>:                   
                                                                      
static void _Timer_server_Schedule_operation_method(                  
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
 201696c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( ts->insert_chain == NULL ) {                                   
 2016970:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
 2016974:	80 a0 60 00 	cmp  %g1, 0                                    
 2016978:	12 80 00 49 	bne  2016a9c <_Timer_server_Schedule_operation_method+0x130>
 201697c:	a0 10 00 19 	mov  %i1, %l0                                  
   *  is the reference point for the delta chain.  Thus if we do not update the
   *  reference point we have to add DT to the initial delta of the watchdog
   *  being inserted.  This could result in an integer overflow.      
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
 2016980:	7f ff ff 58 	call  20166e0 <_Thread_Disable_dispatch>       
 2016984:	01 00 00 00 	nop                                            
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
 2016988:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
 201698c:	80 a0 60 01 	cmp  %g1, 1                                    
 2016990:	12 80 00 1f 	bne  2016a0c <_Timer_server_Schedule_operation_method+0xa0>
 2016994:	80 a0 60 03 	cmp  %g1, 3                                    
    /*                                                                
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
 2016998:	7f ff e3 07 	call  200f5b4 <sparc_disable_interrupts>       
 201699c:	01 00 00 00 	nop                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
 20169a0:	03 00 80 f1 	sethi  %hi(0x203c400), %g1                     
 20169a4:	c4 00 62 14 	ld  [ %g1 + 0x214 ], %g2	! 203c614 <_Watchdog_Ticks_since_boot>
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
 20169a8:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
 20169ac:	c8 06 20 3c 	ld  [ %i0 + 0x3c ], %g4                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 20169b0:	86 06 20 34 	add  %i0, 0x34, %g3                            
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
 20169b4:	80 a0 40 03 	cmp  %g1, %g3                                  
 20169b8:	02 80 00 08 	be  20169d8 <_Timer_server_Schedule_operation_method+0x6c>
 20169bc:	88 20 80 04 	sub  %g2, %g4, %g4                             
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
 20169c0:	da 00 60 10 	ld  [ %g1 + 0x10 ], %o5                        
      if (delta_interval > delta) {                                   
 20169c4:	80 a3 40 04 	cmp  %o5, %g4                                  
 20169c8:	08 80 00 03 	bleu  20169d4 <_Timer_server_Schedule_operation_method+0x68>
 20169cc:	86 10 20 00 	clr  %g3                                       
        delta_interval -= delta;                                      
 20169d0:	86 23 40 04 	sub  %o5, %g4, %g3                             
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
 20169d4:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
 20169d8:	c4 26 20 3c 	st  %g2, [ %i0 + 0x3c ]                        
    _ISR_Enable( level );                                             
 20169dc:	7f ff e2 fa 	call  200f5c4 <sparc_enable_interrupts>        
 20169e0:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
 20169e4:	90 06 20 30 	add  %i0, 0x30, %o0                            
 20169e8:	40 00 11 78 	call  201afc8 <_Watchdog_Insert>               
 20169ec:	92 04 20 10 	add  %l0, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
 20169f0:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
 20169f4:	80 a0 60 00 	cmp  %g1, 0                                    
 20169f8:	12 80 00 27 	bne  2016a94 <_Timer_server_Schedule_operation_method+0x128>
 20169fc:	01 00 00 00 	nop                                            
      _Timer_server_Reset_interval_system_watchdog( ts );             
 2016a00:	7f ff ff 3e 	call  20166f8 <_Timer_server_Reset_interval_system_watchdog>
 2016a04:	90 10 00 18 	mov  %i0, %o0                                  
 2016a08:	30 80 00 23 	b,a   2016a94 <_Timer_server_Schedule_operation_method+0x128>
    }                                                                 
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
 2016a0c:	12 80 00 22 	bne  2016a94 <_Timer_server_Schedule_operation_method+0x128>
 2016a10:	01 00 00 00 	nop                                            
    /*                                                                
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
 2016a14:	7f ff e2 e8 	call  200f5b4 <sparc_disable_interrupts>       
 2016a18:	01 00 00 00 	nop                                            
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
 2016a1c:	c4 06 20 68 	ld  [ %i0 + 0x68 ], %g2                        
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
 2016a20:	da 06 20 74 	ld  [ %i0 + 0x74 ], %o5                        
    /*                                                                
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
 2016a24:	03 00 80 f1 	sethi  %hi(0x203c400), %g1                     
 2016a28:	86 06 20 6c 	add  %i0, 0x6c, %g3                            
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
 2016a2c:	80 a0 80 03 	cmp  %g2, %g3                                  
 2016a30:	02 80 00 0d 	be  2016a64 <_Timer_server_Schedule_operation_method+0xf8>
 2016a34:	c2 00 61 8c 	ld  [ %g1 + 0x18c ], %g1                       
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
 2016a38:	c8 00 a0 10 	ld  [ %g2 + 0x10 ], %g4                        
      if ( snapshot > last_snapshot ) {                               
 2016a3c:	80 a0 40 0d 	cmp  %g1, %o5                                  
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
 2016a40:	86 01 00 0d 	add  %g4, %o5, %g3                             
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
      if ( snapshot > last_snapshot ) {                               
 2016a44:	08 80 00 07 	bleu  2016a60 <_Timer_server_Schedule_operation_method+0xf4>
 2016a48:	86 20 c0 01 	sub  %g3, %g1, %g3                             
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
 2016a4c:	9a 20 40 0d 	sub  %g1, %o5, %o5                             
        if (delta_interval > delta) {                                 
 2016a50:	80 a1 00 0d 	cmp  %g4, %o5                                  
 2016a54:	08 80 00 03 	bleu  2016a60 <_Timer_server_Schedule_operation_method+0xf4><== NEVER TAKEN
 2016a58:	86 10 20 00 	clr  %g3                                       
          delta_interval -= delta;                                    
 2016a5c:	86 21 00 0d 	sub  %g4, %o5, %g3                             
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
        delta_interval += delta;                                      
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
 2016a60:	c6 20 a0 10 	st  %g3, [ %g2 + 0x10 ]                        
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
 2016a64:	c2 26 20 74 	st  %g1, [ %i0 + 0x74 ]                        
    _ISR_Enable( level );                                             
 2016a68:	7f ff e2 d7 	call  200f5c4 <sparc_enable_interrupts>        
 2016a6c:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
 2016a70:	90 06 20 68 	add  %i0, 0x68, %o0                            
 2016a74:	40 00 11 55 	call  201afc8 <_Watchdog_Insert>               
 2016a78:	92 04 20 10 	add  %l0, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
 2016a7c:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
 2016a80:	80 a0 60 00 	cmp  %g1, 0                                    
 2016a84:	12 80 00 04 	bne  2016a94 <_Timer_server_Schedule_operation_method+0x128>
 2016a88:	01 00 00 00 	nop                                            
      _Timer_server_Reset_tod_system_watchdog( ts );                  
 2016a8c:	7f ff ff 30 	call  201674c <_Timer_server_Reset_tod_system_watchdog>
 2016a90:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
 2016a94:	40 00 0c e3 	call  2019e20 <_Thread_Enable_dispatch>        
 2016a98:	81 e8 00 00 	restore                                        
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.         
     */                                                               
    _Chain_Append( ts->insert_chain, &timer->Object.Node );           
 2016a9c:	f0 06 20 78 	ld  [ %i0 + 0x78 ], %i0                        
 2016aa0:	40 00 02 13 	call  20172ec <_Chain_Append>                  
 2016aa4:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200b088 <_Timespec_Greater_than>:                                    
bool _Timespec_Greater_than(                                          
  const struct timespec *lhs,                                         
  const struct timespec *rhs                                          
)                                                                     
{                                                                     
  if ( lhs->tv_sec > rhs->tv_sec )                                    
 200b088:	c6 02 00 00 	ld  [ %o0 ], %g3                               
 200b08c:	c4 02 40 00 	ld  [ %o1 ], %g2                               
                                                                      
bool _Timespec_Greater_than(                                          
  const struct timespec *lhs,                                         
  const struct timespec *rhs                                          
)                                                                     
{                                                                     
 200b090:	82 10 00 08 	mov  %o0, %g1                                  
  if ( lhs->tv_sec > rhs->tv_sec )                                    
 200b094:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200b098:	14 80 00 0b 	bg  200b0c4 <_Timespec_Greater_than+0x3c>      
 200b09c:	90 10 20 01 	mov  1, %o0                                    
    return true;                                                      
                                                                      
  if ( lhs->tv_sec < rhs->tv_sec )                                    
 200b0a0:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200b0a4:	06 80 00 08 	bl  200b0c4 <_Timespec_Greater_than+0x3c>      <== NEVER TAKEN
 200b0a8:	90 10 20 00 	clr  %o0                                       
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
                                                                      
bool _Timespec_Greater_than(                                          
 200b0ac:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
 200b0b0:	c2 02 60 04 	ld  [ %o1 + 4 ], %g1                           
 200b0b4:	80 a0 80 01 	cmp  %g2, %g1                                  
 200b0b8:	14 80 00 03 	bg  200b0c4 <_Timespec_Greater_than+0x3c>      
 200b0bc:	90 10 20 01 	mov  1, %o0                                    
 200b0c0:	90 10 20 00 	clr  %o0                                       
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */                            
  if ( lhs->tv_nsec > rhs->tv_nsec )                                  
    return true;                                                      
                                                                      
  return false;                                                       
}                                                                     
 200b0c4:	81 c3 e0 08 	retl                                           
                                                                      
===============================================================================
020091fc <_User_extensions_Handler_initialization>:                   
#include <rtems/score/userext.h>                                      
#include <rtems/score/wkspace.h>                                      
#include <string.h>                                                   
                                                                      
void _User_extensions_Handler_initialization(void)                    
{                                                                     
 20091fc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  User_extensions_Control *extension;                                 
  uint32_t                 i;                                         
  uint32_t                 number_of_extensions;                      
  User_extensions_Table   *initial_extensions;                        
                                                                      
  number_of_extensions = Configuration.number_of_initial_extensions;  
 2009200:	03 00 80 50 	sethi  %hi(0x2014000), %g1                     
 2009204:	82 10 61 68 	or  %g1, 0x168, %g1	! 2014168 <Configuration>  
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 2009208:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
  initial_extensions   = Configuration.User_extension_table;          
 200920c:	e6 00 60 3c 	ld  [ %g1 + 0x3c ], %l3                        
  User_extensions_Control *extension;                                 
  uint32_t                 i;                                         
  uint32_t                 number_of_extensions;                      
  User_extensions_Table   *initial_extensions;                        
                                                                      
  number_of_extensions = Configuration.number_of_initial_extensions;  
 2009210:	e4 00 60 38 	ld  [ %g1 + 0x38 ], %l2                        
 2009214:	82 10 a3 18 	or  %g2, 0x318, %g1                            
 2009218:	86 00 60 04 	add  %g1, 4, %g3                               
  head->previous = NULL;                                              
 200921c:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
  tail->previous = head;                                              
 2009220:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 2009224:	c6 20 a3 18 	st  %g3, [ %g2 + 0x318 ]                       
 2009228:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
 200922c:	82 10 a1 34 	or  %g2, 0x134, %g1	! 2014d34 <_User_extensions_Switches_list>
 2009230:	86 00 60 04 	add  %g1, 4, %g3                               
  head->previous = NULL;                                              
 2009234:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 2009238:	c6 20 a1 34 	st  %g3, [ %g2 + 0x134 ]                       
  initial_extensions   = Configuration.User_extension_table;          
                                                                      
  _Chain_Initialize_empty( &_User_extensions_List );                  
  _Chain_Initialize_empty( &_User_extensions_Switches_list );         
                                                                      
  if ( initial_extensions ) {                                         
 200923c:	80 a4 e0 00 	cmp  %l3, 0                                    
 2009240:	02 80 00 1b 	be  20092ac <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
 2009244:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
    extension = (User_extensions_Control *)                           
      _Workspace_Allocate_or_fatal_error(                             
        number_of_extensions * sizeof( User_extensions_Control )      
 2009248:	83 2c a0 02 	sll  %l2, 2, %g1                               
 200924c:	a1 2c a0 04 	sll  %l2, 4, %l0                               
 2009250:	a0 24 00 01 	sub  %l0, %g1, %l0                             
 2009254:	a0 04 00 12 	add  %l0, %l2, %l0                             
 2009258:	a1 2c 20 02 	sll  %l0, 2, %l0                               
  _Chain_Initialize_empty( &_User_extensions_List );                  
  _Chain_Initialize_empty( &_User_extensions_Switches_list );         
                                                                      
  if ( initial_extensions ) {                                         
    extension = (User_extensions_Control *)                           
      _Workspace_Allocate_or_fatal_error(                             
 200925c:	40 00 01 6c 	call  200980c <_Workspace_Allocate_or_fatal_error>
 2009260:	90 10 00 10 	mov  %l0, %o0                                  
        number_of_extensions * sizeof( User_extensions_Control )      
      );                                                              
                                                                      
    memset (                                                          
 2009264:	94 10 00 10 	mov  %l0, %o2                                  
  _Chain_Initialize_empty( &_User_extensions_List );                  
  _Chain_Initialize_empty( &_User_extensions_Switches_list );         
                                                                      
  if ( initial_extensions ) {                                         
    extension = (User_extensions_Control *)                           
      _Workspace_Allocate_or_fatal_error(                             
 2009268:	a2 10 00 08 	mov  %o0, %l1                                  
        number_of_extensions * sizeof( User_extensions_Control )      
      );                                                              
                                                                      
    memset (                                                          
 200926c:	92 10 20 00 	clr  %o1                                       
 2009270:	40 00 14 48 	call  200e390 <memset>                         
 2009274:	a0 10 20 00 	clr  %l0                                       
      extension,                                                      
      0,                                                              
      number_of_extensions * sizeof( User_extensions_Control )        
    );                                                                
                                                                      
    for ( i = 0 ; i < number_of_extensions ; i++ ) {                  
 2009278:	10 80 00 0b 	b  20092a4 <_User_extensions_Handler_initialization+0xa8>
 200927c:	80 a4 00 12 	cmp  %l0, %l2                                  
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(        
  User_extensions_Control     *extension,                             
  const User_extensions_Table *extension_table                        
)                                                                     
{                                                                     
  extension->Callouts = *extension_table;                             
 2009280:	90 04 60 14 	add  %l1, 0x14, %o0                            
 2009284:	92 04 c0 09 	add  %l3, %o1, %o1                             
 2009288:	40 00 14 09 	call  200e2ac <memcpy>                         
 200928c:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
  _User_extensions_Add_set( extension );                              
 2009290:	90 10 00 11 	mov  %l1, %o0                                  
 2009294:	40 00 0b ca 	call  200c1bc <_User_extensions_Add_set>       
 2009298:	a0 04 20 01 	inc  %l0                                       
      _User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
      extension++;                                                    
 200929c:	a2 04 60 34 	add  %l1, 0x34, %l1                            
      extension,                                                      
      0,                                                              
      number_of_extensions * sizeof( User_extensions_Control )        
    );                                                                
                                                                      
    for ( i = 0 ; i < number_of_extensions ; i++ ) {                  
 20092a0:	80 a4 00 12 	cmp  %l0, %l2                                  
 20092a4:	0a bf ff f7 	bcs  2009280 <_User_extensions_Handler_initialization+0x84>
 20092a8:	93 2c 20 05 	sll  %l0, 5, %o1                               
 20092ac:	81 c7 e0 08 	ret                                            
 20092b0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200b4e0 <_Watchdog_Adjust>:                                          
void _Watchdog_Adjust(                                                
  Chain_Control               *header,                                
  Watchdog_Adjust_directions   direction,                             
  Watchdog_Interval            units                                  
)                                                                     
{                                                                     
 200b4e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
 200b4e4:	7f ff de 8b 	call  2002f10 <sparc_disable_interrupts>       
 200b4e8:	a0 10 00 18 	mov  %i0, %l0                                  
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
 200b4ec:	c2 06 00 00 	ld  [ %i0 ], %g1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 200b4f0:	a2 06 20 04 	add  %i0, 4, %l1                               
   *       hence the compiler must not assume *header to remain       
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
 200b4f4:	80 a0 40 11 	cmp  %g1, %l1                                  
 200b4f8:	02 80 00 1f 	be  200b574 <_Watchdog_Adjust+0x94>            
 200b4fc:	80 a6 60 00 	cmp  %i1, 0                                    
    switch ( direction ) {                                            
 200b500:	02 80 00 1a 	be  200b568 <_Watchdog_Adjust+0x88>            
 200b504:	a4 10 20 01 	mov  1, %l2                                    
 200b508:	80 a6 60 01 	cmp  %i1, 1                                    
 200b50c:	12 80 00 1a 	bne  200b574 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
 200b510:	01 00 00 00 	nop                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
 200b514:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 200b518:	10 80 00 07 	b  200b534 <_Watchdog_Adjust+0x54>             
 200b51c:	b4 00 80 1a 	add  %g2, %i2, %i2                             
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
 200b520:	f2 00 60 10 	ld  [ %g1 + 0x10 ], %i1                        
 200b524:	80 a6 80 19 	cmp  %i2, %i1                                  
 200b528:	3a 80 00 05 	bcc,a   200b53c <_Watchdog_Adjust+0x5c>        
 200b52c:	e4 20 60 10 	st  %l2, [ %g1 + 0x10 ]                        
            _Watchdog_First( header )->delta_interval -= units;       
 200b530:	b4 26 40 1a 	sub  %i1, %i2, %i2                             
            break;                                                    
 200b534:	10 80 00 10 	b  200b574 <_Watchdog_Adjust+0x94>             
 200b538:	f4 20 60 10 	st  %i2, [ %g1 + 0x10 ]                        
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
                                                                      
            _ISR_Enable( level );                                     
 200b53c:	7f ff de 79 	call  2002f20 <sparc_enable_interrupts>        
 200b540:	01 00 00 00 	nop                                            
                                                                      
            _Watchdog_Tickle( header );                               
 200b544:	40 00 00 94 	call  200b794 <_Watchdog_Tickle>               
 200b548:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
            _ISR_Disable( level );                                    
 200b54c:	7f ff de 71 	call  2002f10 <sparc_disable_interrupts>       
 200b550:	01 00 00 00 	nop                                            
                                                                      
            if ( _Chain_Is_empty( header ) )                          
 200b554:	c2 04 00 00 	ld  [ %l0 ], %g1                               
 200b558:	80 a0 40 11 	cmp  %g1, %l1                                  
 200b55c:	02 80 00 06 	be  200b574 <_Watchdog_Adjust+0x94>            
 200b560:	01 00 00 00 	nop                                            
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
 200b564:	b4 26 80 19 	sub  %i2, %i1, %i2                             
    switch ( direction ) {                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
 200b568:	80 a6 a0 00 	cmp  %i2, 0                                    
 200b56c:	32 bf ff ed 	bne,a   200b520 <_Watchdog_Adjust+0x40>        <== ALWAYS TAKEN
 200b570:	c2 04 00 00 	ld  [ %l0 ], %g1                               
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
 200b574:	7f ff de 6b 	call  2002f20 <sparc_enable_interrupts>        
 200b578:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
===============================================================================
02009620 <_Watchdog_Remove>:                                          
 */                                                                   
                                                                      
Watchdog_States _Watchdog_Remove(                                     
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
 2009620:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
 2009624:	7f ff e2 30 	call  2001ee4 <sparc_disable_interrupts>       
 2009628:	a0 10 00 18 	mov  %i0, %l0                                  
  previous_state = the_watchdog->state;                               
 200962c:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  switch ( previous_state ) {                                         
 2009630:	80 a6 20 01 	cmp  %i0, 1                                    
 2009634:	22 80 00 1d 	be,a   20096a8 <_Watchdog_Remove+0x88>         
 2009638:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
 200963c:	0a 80 00 1c 	bcs  20096ac <_Watchdog_Remove+0x8c>           
 2009640:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 2009644:	80 a6 20 03 	cmp  %i0, 3                                    
 2009648:	18 80 00 19 	bgu  20096ac <_Watchdog_Remove+0x8c>           <== NEVER TAKEN
 200964c:	01 00 00 00 	nop                                            
 2009650:	c2 04 00 00 	ld  [ %l0 ], %g1                               
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
 2009654:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
 2009658:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 200965c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2009660:	02 80 00 07 	be  200967c <_Watchdog_Remove+0x5c>            
 2009664:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
        next_watchdog->delta_interval += the_watchdog->delta_interval;
 2009668:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
 200966c:	c4 04 20 10 	ld  [ %l0 + 0x10 ], %g2                        
 2009670:	84 00 c0 02 	add  %g3, %g2, %g2                             
 2009674:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
      if ( _Watchdog_Sync_count )                                     
 2009678:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
 200967c:	c4 00 a2 40 	ld  [ %g2 + 0x240 ], %g2	! 2014e40 <_Watchdog_Sync_count>
 2009680:	80 a0 a0 00 	cmp  %g2, 0                                    
 2009684:	22 80 00 07 	be,a   20096a0 <_Watchdog_Remove+0x80>         
 2009688:	c4 04 20 04 	ld  [ %l0 + 4 ], %g2                           
        _Watchdog_Sync_level = _ISR_Nest_level;                       
 200968c:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
 2009690:	c6 00 a3 64 	ld  [ %g2 + 0x364 ], %g3	! 2014f64 <_Per_CPU_Information+0x8>
 2009694:	05 00 80 53 	sethi  %hi(0x2014c00), %g2                     
 2009698:	c6 20 a1 d8 	st  %g3, [ %g2 + 0x1d8 ]	! 2014dd8 <_Watchdog_Sync_level>
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200969c:	c4 04 20 04 	ld  [ %l0 + 4 ], %g2                           
  next->previous = previous;                                          
 20096a0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  previous->next = next;                                              
 20096a4:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
 20096a8:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 20096ac:	c2 00 62 44 	ld  [ %g1 + 0x244 ], %g1	! 2014e44 <_Watchdog_Ticks_since_boot>
 20096b0:	c2 24 20 18 	st  %g1, [ %l0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
 20096b4:	7f ff e2 10 	call  2001ef4 <sparc_enable_interrupts>        
 20096b8:	01 00 00 00 	nop                                            
  return( previous_state );                                           
}                                                                     
 20096bc:	81 c7 e0 08 	ret                                            
 20096c0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200acf8 <_Watchdog_Report_chain>:                                    
                                                                      
void _Watchdog_Report_chain(                                          
  const char        *name,                                            
  Chain_Control     *header                                           
)                                                                     
{                                                                     
 200acf8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
 200acfc:	7f ff df 5c 	call  2002a6c <sparc_disable_interrupts>       
 200ad00:	a0 10 00 18 	mov  %i0, %l0                                  
 200ad04:	b0 10 00 08 	mov  %o0, %i0                                  
    printk( "Watchdog Chain: %s %p\n", name, header );                
 200ad08:	11 00 80 6e 	sethi  %hi(0x201b800), %o0                     
 200ad0c:	94 10 00 19 	mov  %i1, %o2                                  
 200ad10:	90 12 20 f8 	or  %o0, 0xf8, %o0                             
 200ad14:	7f ff e6 12 	call  200455c <printk>                         
 200ad18:	92 10 00 10 	mov  %l0, %o1                                  
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
}                                                                     
 200ad1c:	e2 06 40 00 	ld  [ %i1 ], %l1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 200ad20:	b2 06 60 04 	add  %i1, 4, %i1                               
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
 200ad24:	80 a4 40 19 	cmp  %l1, %i1                                  
 200ad28:	02 80 00 0e 	be  200ad60 <_Watchdog_Report_chain+0x68>      
 200ad2c:	11 00 80 6e 	sethi  %hi(0x201b800), %o0                     
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
 200ad30:	92 10 00 11 	mov  %l1, %o1                                  
 200ad34:	40 00 00 10 	call  200ad74 <_Watchdog_Report>               
 200ad38:	90 10 20 00 	clr  %o0                                       
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
 200ad3c:	e2 04 40 00 	ld  [ %l1 ], %l1                               
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
 200ad40:	80 a4 40 19 	cmp  %l1, %i1                                  
 200ad44:	12 bf ff fc 	bne  200ad34 <_Watchdog_Report_chain+0x3c>     <== NEVER TAKEN
 200ad48:	92 10 00 11 	mov  %l1, %o1                                  
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
 200ad4c:	11 00 80 6e 	sethi  %hi(0x201b800), %o0                     
 200ad50:	92 10 00 10 	mov  %l0, %o1                                  
 200ad54:	7f ff e6 02 	call  200455c <printk>                         
 200ad58:	90 12 21 10 	or  %o0, 0x110, %o0                            
 200ad5c:	30 80 00 03 	b,a   200ad68 <_Watchdog_Report_chain+0x70>    
    } else {                                                          
      printk( "Chain is empty\n" );                                   
 200ad60:	7f ff e5 ff 	call  200455c <printk>                         
 200ad64:	90 12 21 20 	or  %o0, 0x120, %o0                            
    }                                                                 
  _ISR_Enable( level );                                               
 200ad68:	7f ff df 45 	call  2002a7c <sparc_enable_interrupts>        
 200ad6c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02006e10 <rtems_chain_get_with_wait>:                                 
  rtems_chain_control *chain,                                         
  rtems_event_set events,                                             
  rtems_interval timeout,                                             
  rtems_chain_node **node_ptr                                         
)                                                                     
{                                                                     
 2006e10:	9d e3 bf 98 	save  %sp, -104, %sp                           
 2006e14:	a0 10 00 18 	mov  %i0, %l0                                  
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
 2006e18:	10 80 00 09 	b  2006e3c <rtems_chain_get_with_wait+0x2c>    
 2006e1c:	a4 07 bf fc 	add  %fp, -4, %l2                              
 2006e20:	92 10 20 00 	clr  %o1                                       
 2006e24:	94 10 00 1a 	mov  %i2, %o2                                  
 2006e28:	7f ff fc fc 	call  2006218 <rtems_event_receive>            
 2006e2c:	96 10 00 12 	mov  %l2, %o3                                  
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
 2006e30:	80 a2 20 00 	cmp  %o0, 0                                    
 2006e34:	32 80 00 09 	bne,a   2006e58 <rtems_chain_get_with_wait+0x48><== ALWAYS TAKEN
 2006e38:	e2 26 c0 00 	st  %l1, [ %i3 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
 2006e3c:	40 00 01 64 	call  20073cc <_Chain_Get>                     
 2006e40:	90 10 00 10 	mov  %l0, %o0                                  
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
 2006e44:	a2 92 20 00 	orcc  %o0, 0, %l1                              
 2006e48:	02 bf ff f6 	be  2006e20 <rtems_chain_get_with_wait+0x10>   
 2006e4c:	90 10 00 19 	mov  %i1, %o0                                  
 2006e50:	90 10 20 00 	clr  %o0                                       
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
 2006e54:	e2 26 c0 00 	st  %l1, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
 2006e58:	81 c7 e0 08 	ret                                            
 2006e5c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
===============================================================================
02008fc0 <rtems_iterate_over_all_threads>:                            
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/thread.h>                                       
                                                                      
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 
{                                                                     
 2008fc0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
 2008fc4:	80 a6 20 00 	cmp  %i0, 0                                    
 2008fc8:	02 80 00 1d 	be  200903c <rtems_iterate_over_all_threads+0x7c><== NEVER TAKEN
 2008fcc:	21 00 80 78 	sethi  %hi(0x201e000), %l0                     
 2008fd0:	a0 14 23 1c 	or  %l0, 0x31c, %l0	! 201e31c <_Objects_Information_table+0x4>
#endif                                                                
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/thread.h>                                       
                                                                      
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 
 2008fd4:	a6 04 20 0c 	add  %l0, 0xc, %l3                             
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
 2008fd8:	c2 04 00 00 	ld  [ %l0 ], %g1                               
 2008fdc:	80 a0 60 00 	cmp  %g1, 0                                    
 2008fe0:	22 80 00 14 	be,a   2009030 <rtems_iterate_over_all_threads+0x70>
 2008fe4:	a0 04 20 04 	add  %l0, 4, %l0                               
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
 2008fe8:	e4 00 60 04 	ld  [ %g1 + 4 ], %l2                           
    if ( !information )                                               
 2008fec:	80 a4 a0 00 	cmp  %l2, 0                                    
 2008ff0:	12 80 00 0b 	bne  200901c <rtems_iterate_over_all_threads+0x5c>
 2008ff4:	a2 10 20 01 	mov  1, %l1                                    
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
 2008ff8:	10 80 00 0e 	b  2009030 <rtems_iterate_over_all_threads+0x70>
 2008ffc:	a0 04 20 04 	add  %l0, 4, %l0                               
      the_thread = (Thread_Control *)information->local_table[ i ];   
 2009000:	83 2c 60 02 	sll  %l1, 2, %g1                               
 2009004:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0                         
                                                                      
      if ( !the_thread )                                              
 2009008:	80 a2 20 00 	cmp  %o0, 0                                    
 200900c:	02 80 00 04 	be  200901c <rtems_iterate_over_all_threads+0x5c>
 2009010:	a2 04 60 01 	inc  %l1                                       
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
 2009014:	9f c6 00 00 	call  %i0                                      
 2009018:	01 00 00 00 	nop                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
 200901c:	c2 14 a0 10 	lduh  [ %l2 + 0x10 ], %g1                      
 2009020:	80 a4 40 01 	cmp  %l1, %g1                                  
 2009024:	28 bf ff f7 	bleu,a   2009000 <rtems_iterate_over_all_threads+0x40>
 2009028:	c4 04 a0 1c 	ld  [ %l2 + 0x1c ], %g2                        
 200902c:	a0 04 20 04 	add  %l0, 4, %l0                               
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
 2009030:	80 a4 00 13 	cmp  %l0, %l3                                  
 2009034:	32 bf ff ea 	bne,a   2008fdc <rtems_iterate_over_all_threads+0x1c>
 2009038:	c2 04 00 00 	ld  [ %l0 ], %g1                               
 200903c:	81 c7 e0 08 	ret                                            
 2009040:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02014158 <rtems_partition_create>:                                    
  uint32_t         length,                                            
  uint32_t         buffer_size,                                       
  rtems_attribute  attribute_set,                                     
  rtems_id        *id                                                 
)                                                                     
{                                                                     
 2014158:	9d e3 bf a0 	save  %sp, -96, %sp                            
 201415c:	a0 10 00 18 	mov  %i0, %l0                                  
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
 2014160:	80 a4 20 00 	cmp  %l0, 0                                    
 2014164:	02 80 00 1f 	be  20141e0 <rtems_partition_create+0x88>      
 2014168:	b0 10 20 03 	mov  3, %i0                                    
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
 201416c:	80 a6 60 00 	cmp  %i1, 0                                    
 2014170:	02 80 00 1c 	be  20141e0 <rtems_partition_create+0x88>      
 2014174:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
 2014178:	80 a7 60 00 	cmp  %i5, 0                                    
 201417c:	02 80 00 19 	be  20141e0 <rtems_partition_create+0x88>      <== NEVER TAKEN
 2014180:	80 a6 e0 00 	cmp  %i3, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
 2014184:	02 80 00 32 	be  201424c <rtems_partition_create+0xf4>      
 2014188:	80 a6 a0 00 	cmp  %i2, 0                                    
 201418c:	02 80 00 30 	be  201424c <rtems_partition_create+0xf4>      
 2014190:	80 a6 80 1b 	cmp  %i2, %i3                                  
 2014194:	0a 80 00 13 	bcs  20141e0 <rtems_partition_create+0x88>     
 2014198:	b0 10 20 08 	mov  8, %i0                                    
 201419c:	80 8e e0 07 	btst  7, %i3                                   
 20141a0:	12 80 00 10 	bne  20141e0 <rtems_partition_create+0x88>     
 20141a4:	80 8e 60 07 	btst  7, %i1                                   
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
 20141a8:	12 80 00 0e 	bne  20141e0 <rtems_partition_create+0x88>     
 20141ac:	b0 10 20 09 	mov  9, %i0                                    
 20141b0:	03 00 80 f1 	sethi  %hi(0x203c400), %g1                     
 20141b4:	c4 00 61 00 	ld  [ %g1 + 0x100 ], %g2	! 203c500 <_Thread_Dispatch_disable_level>
 20141b8:	84 00 a0 01 	inc  %g2                                       
 20141bc:	c4 20 61 00 	st  %g2, [ %g1 + 0x100 ]                       
 *  This function allocates a partition control block from            
 *  the inactive chain of free partition control blocks.              
 */                                                                   
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )  
{                                                                     
  return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
 20141c0:	25 00 80 f0 	sethi  %hi(0x203c000), %l2                     
 20141c4:	40 00 12 45 	call  2018ad8 <_Objects_Allocate>              
 20141c8:	90 14 a3 14 	or  %l2, 0x314, %o0	! 203c314 <_Partition_Information>
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
 20141cc:	a2 92 20 00 	orcc  %o0, 0, %l1                              
 20141d0:	12 80 00 06 	bne  20141e8 <rtems_partition_create+0x90>     
 20141d4:	92 10 00 1b 	mov  %i3, %o1                                  
    _Thread_Enable_dispatch();                                        
 20141d8:	40 00 17 12 	call  2019e20 <_Thread_Enable_dispatch>        
 20141dc:	b0 10 20 05 	mov  5, %i0                                    
    return RTEMS_TOO_MANY;                                            
 20141e0:	81 c7 e0 08 	ret                                            
 20141e4:	81 e8 00 00 	restore                                        
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
 20141e8:	f2 24 60 10 	st  %i1, [ %l1 + 0x10 ]                        
  the_partition->length                = length;                      
 20141ec:	f4 24 60 14 	st  %i2, [ %l1 + 0x14 ]                        
  the_partition->buffer_size           = buffer_size;                 
 20141f0:	f6 24 60 18 	st  %i3, [ %l1 + 0x18 ]                        
  the_partition->attribute_set         = attribute_set;               
 20141f4:	f8 24 60 1c 	st  %i4, [ %l1 + 0x1c ]                        
  the_partition->number_of_used_blocks = 0;                           
 20141f8:	c0 24 60 20 	clr  [ %l1 + 0x20 ]                            
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
                        length / buffer_size, buffer_size );          
 20141fc:	40 00 61 a5 	call  202c890 <.udiv>                          
 2014200:	90 10 00 1a 	mov  %i2, %o0                                  
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
 2014204:	92 10 00 19 	mov  %i1, %o1                                  
                        length / buffer_size, buffer_size );          
 2014208:	94 10 00 08 	mov  %o0, %o2                                  
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
 201420c:	96 10 00 1b 	mov  %i3, %o3                                  
 2014210:	a6 04 60 24 	add  %l1, 0x24, %l3                            
 2014214:	40 00 0c 5b 	call  2017380 <_Chain_Initialize>              
 2014218:	90 10 00 13 	mov  %l3, %o0                                  
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 201421c:	c4 14 60 0a 	lduh  [ %l1 + 0xa ], %g2                       
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2014220:	a4 14 a3 14 	or  %l2, 0x314, %l2                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 2014224:	c6 04 a0 1c 	ld  [ %l2 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 2014228:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 201422c:	85 28 a0 02 	sll  %g2, 2, %g2                               
 2014230:	e2 20 c0 02 	st  %l1, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
 2014234:	e0 24 60 0c 	st  %l0, [ %l1 + 0xc ]                         
    &_Partition_Information,                                          
    &the_partition->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_partition->Object.id;                                     
 2014238:	c2 27 40 00 	st  %g1, [ %i5 ]                               
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
 201423c:	40 00 16 f9 	call  2019e20 <_Thread_Enable_dispatch>        
 2014240:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
 2014244:	81 c7 e0 08 	ret                                            
 2014248:	81 e8 00 00 	restore                                        
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
 201424c:	b0 10 20 08 	mov  8, %i0                                    
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2014250:	81 c7 e0 08 	ret                                            
 2014254:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200723c <rtems_rate_monotonic_period>:                               
                                                                      
rtems_status_code rtems_rate_monotonic_period(                        
  rtems_id       id,                                                  
  rtems_interval length                                               
)                                                                     
{                                                                     
 200723c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Rate_monotonic_Control *)                                   
    _Objects_Get( &_Rate_monotonic_Information, id, location );       
 2007240:	11 00 80 75 	sethi  %hi(0x201d400), %o0                     
 2007244:	92 10 00 18 	mov  %i0, %o1                                  
 2007248:	90 12 21 f4 	or  %o0, 0x1f4, %o0                            
 200724c:	40 00 08 e4 	call  20095dc <_Objects_Get>                   
 2007250:	94 07 bf fc 	add  %fp, -4, %o2                              
  rtems_rate_monotonic_period_states   local_state;                   
  ISR_Level                            level;                         
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
                                                                      
  switch ( location ) {                                               
 2007254:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2007258:	80 a0 60 00 	cmp  %g1, 0                                    
 200725c:	12 80 00 66 	bne  20073f4 <rtems_rate_monotonic_period+0x1b8>
 2007260:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
 2007264:	25 00 80 76 	sethi  %hi(0x201d800), %l2                     
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
 2007268:	c4 02 20 40 	ld  [ %o0 + 0x40 ], %g2                        
 200726c:	a4 14 a1 8c 	or  %l2, 0x18c, %l2                            
 2007270:	c2 04 a0 0c 	ld  [ %l2 + 0xc ], %g1                         
 2007274:	80 a0 80 01 	cmp  %g2, %g1                                  
 2007278:	02 80 00 06 	be  2007290 <rtems_rate_monotonic_period+0x54> 
 200727c:	80 a6 60 00 	cmp  %i1, 0                                    
        _Thread_Enable_dispatch();                                    
 2007280:	40 00 0c 5b 	call  200a3ec <_Thread_Enable_dispatch>        
 2007284:	b0 10 20 17 	mov  0x17, %i0                                 
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
 2007288:	81 c7 e0 08 	ret                                            
 200728c:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
 2007290:	12 80 00 0e 	bne  20072c8 <rtems_rate_monotonic_period+0x8c>
 2007294:	01 00 00 00 	nop                                            
        switch ( the_period->state ) {                                
 2007298:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 200729c:	80 a0 60 04 	cmp  %g1, 4                                    
 20072a0:	18 80 00 06 	bgu  20072b8 <rtems_rate_monotonic_period+0x7c><== NEVER TAKEN
 20072a4:	b0 10 20 00 	clr  %i0                                       
 20072a8:	83 28 60 02 	sll  %g1, 2, %g1                               
 20072ac:	05 00 80 6d 	sethi  %hi(0x201b400), %g2                     
 20072b0:	84 10 a2 3c 	or  %g2, 0x23c, %g2	! 201b63c <CSWTCH.2>       
 20072b4:	f0 00 80 01 	ld  [ %g2 + %g1 ], %i0                         
          case RATE_MONOTONIC_ACTIVE:                                 
          default:              /* unreached -- only to remove warnings */
            return_value = RTEMS_SUCCESSFUL;                          
            break;                                                    
        }                                                             
        _Thread_Enable_dispatch();                                    
 20072b8:	40 00 0c 4d 	call  200a3ec <_Thread_Enable_dispatch>        
 20072bc:	01 00 00 00 	nop                                            
        return( return_value );                                       
 20072c0:	81 c7 e0 08 	ret                                            
 20072c4:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
 20072c8:	7f ff ee cc 	call  2002df8 <sparc_disable_interrupts>       
 20072cc:	01 00 00 00 	nop                                            
 20072d0:	a6 10 00 08 	mov  %o0, %l3                                  
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
 20072d4:	e2 04 20 38 	ld  [ %l0 + 0x38 ], %l1                        
 20072d8:	80 a4 60 00 	cmp  %l1, 0                                    
 20072dc:	12 80 00 15 	bne  2007330 <rtems_rate_monotonic_period+0xf4>
 20072e0:	80 a4 60 02 	cmp  %l1, 2                                    
        _ISR_Enable( level );                                         
 20072e4:	7f ff ee c9 	call  2002e08 <sparc_enable_interrupts>        
 20072e8:	01 00 00 00 	nop                                            
                                                                      
        /*                                                            
         *  Baseline statistics information for the beginning of a period.
         */                                                           
        _Rate_monotonic_Initiate_statistics( the_period );            
 20072ec:	7f ff ff 7a 	call  20070d4 <_Rate_monotonic_Initiate_statistics>
 20072f0:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
 20072f4:	82 10 20 02 	mov  2, %g1                                    
 20072f8:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
 20072fc:	03 00 80 1d 	sethi  %hi(0x2007400), %g1                     
 2007300:	82 10 62 c4 	or  %g1, 0x2c4, %g1	! 20076c4 <_Rate_monotonic_Timeout>
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 2007304:	c0 24 20 18 	clr  [ %l0 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
 2007308:	c2 24 20 2c 	st  %g1, [ %l0 + 0x2c ]                        
  the_watchdog->id        = id;                                       
 200730c:	f0 24 20 30 	st  %i0, [ %l0 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
 2007310:	c0 24 20 34 	clr  [ %l0 + 0x34 ]                            
          _Rate_monotonic_Timeout,                                    
          id,                                                         
          NULL                                                        
        );                                                            
                                                                      
        the_period->next_length = length;                             
 2007314:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 2007318:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 200731c:	11 00 80 76 	sethi  %hi(0x201d800), %o0                     
 2007320:	92 04 20 10 	add  %l0, 0x10, %o1                            
 2007324:	40 00 10 3a 	call  200b40c <_Watchdog_Insert>               
 2007328:	90 12 20 24 	or  %o0, 0x24, %o0                             
 200732c:	30 80 00 1b 	b,a   2007398 <rtems_rate_monotonic_period+0x15c>
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
 2007330:	12 80 00 1e 	bne  20073a8 <rtems_rate_monotonic_period+0x16c>
 2007334:	80 a4 60 04 	cmp  %l1, 4                                    
        /*                                                            
         *  Update statistics from the concluding period.             
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
 2007338:	7f ff ff 83 	call  2007144 <_Rate_monotonic_Update_statistics>
 200733c:	90 10 00 10 	mov  %l0, %o0                                  
        /*                                                            
         *  This tells the _Rate_monotonic_Timeout that this task is  
         *  in the process of blocking on the period and that we      
         *  may be changing the length of the next period.            
         */                                                           
        the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;         
 2007340:	82 10 20 01 	mov  1, %g1                                    
        the_period->next_length = length;                             
 2007344:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
        /*                                                            
         *  This tells the _Rate_monotonic_Timeout that this task is  
         *  in the process of blocking on the period and that we      
         *  may be changing the length of the next period.            
         */                                                           
        the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;         
 2007348:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
        the_period->next_length = length;                             
                                                                      
        _ISR_Enable( level );                                         
 200734c:	7f ff ee af 	call  2002e08 <sparc_enable_interrupts>        
 2007350:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
 2007354:	d0 04 a0 0c 	ld  [ %l2 + 0xc ], %o0                         
 2007358:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
 200735c:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
 2007360:	40 00 0e 50 	call  200aca0 <_Thread_Set_state>              
 2007364:	c2 22 20 20 	st  %g1, [ %o0 + 0x20 ]                        
                                                                      
        /*                                                            
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
 2007368:	7f ff ee a4 	call  2002df8 <sparc_disable_interrupts>       
 200736c:	01 00 00 00 	nop                                            
          local_state = the_period->state;                            
 2007370:	e6 04 20 38 	ld  [ %l0 + 0x38 ], %l3                        
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
 2007374:	e2 24 20 38 	st  %l1, [ %l0 + 0x38 ]                        
        _ISR_Enable( level );                                         
 2007378:	7f ff ee a4 	call  2002e08 <sparc_enable_interrupts>        
 200737c:	01 00 00 00 	nop                                            
                                                                      
        /*                                                            
         *  If it did, then we want to unblock ourself and continue as
         *  if nothing happen.  The period was reset in the timeout routine.
         */                                                           
        if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )   
 2007380:	80 a4 e0 03 	cmp  %l3, 3                                    
 2007384:	12 80 00 05 	bne  2007398 <rtems_rate_monotonic_period+0x15c>
 2007388:	01 00 00 00 	nop                                            
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
 200738c:	d0 04 a0 0c 	ld  [ %l2 + 0xc ], %o0                         
 2007390:	40 00 0b 39 	call  200a074 <_Thread_Clear_state>            
 2007394:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
                                                                      
        _Thread_Enable_dispatch();                                    
 2007398:	40 00 0c 15 	call  200a3ec <_Thread_Enable_dispatch>        
 200739c:	b0 10 20 00 	clr  %i0                                       
        return RTEMS_SUCCESSFUL;                                      
 20073a0:	81 c7 e0 08 	ret                                            
 20073a4:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {            
 20073a8:	12 bf ff b8 	bne  2007288 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
 20073ac:	b0 10 20 04 	mov  4, %i0                                    
        /*                                                            
         *  Update statistics from the concluding period              
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
 20073b0:	7f ff ff 65 	call  2007144 <_Rate_monotonic_Update_statistics>
 20073b4:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
        _ISR_Enable( level );                                         
 20073b8:	7f ff ee 94 	call  2002e08 <sparc_enable_interrupts>        
 20073bc:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
 20073c0:	82 10 20 02 	mov  2, %g1                                    
 20073c4:	92 04 20 10 	add  %l0, 0x10, %o1                            
 20073c8:	11 00 80 76 	sethi  %hi(0x201d800), %o0                     
 20073cc:	90 12 20 24 	or  %o0, 0x24, %o0	! 201d824 <_Watchdog_Ticks_chain>
 20073d0:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
        the_period->next_length = length;                             
 20073d4:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 20073d8:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 20073dc:	40 00 10 0c 	call  200b40c <_Watchdog_Insert>               
 20073e0:	b0 10 20 06 	mov  6, %i0                                    
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
 20073e4:	40 00 0c 02 	call  200a3ec <_Thread_Enable_dispatch>        
 20073e8:	01 00 00 00 	nop                                            
        return RTEMS_TIMEOUT;                                         
 20073ec:	81 c7 e0 08 	ret                                            
 20073f0:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
 20073f4:	b0 10 20 04 	mov  4, %i0                                    
}                                                                     
 20073f8:	81 c7 e0 08 	ret                                            
 20073fc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02007400 <rtems_rate_monotonic_report_statistics_with_plugin>:        
 */                                                                   
void rtems_rate_monotonic_report_statistics_with_plugin(              
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
 2007400:	9d e3 bf 30 	save  %sp, -208, %sp                           
  rtems_id                               id;                          
  rtems_rate_monotonic_period_statistics the_stats;                   
  rtems_rate_monotonic_period_status     the_status;                  
  char                                   name[5];                     
                                                                      
  if ( !print )                                                       
 2007404:	80 a6 60 00 	cmp  %i1, 0                                    
 2007408:	02 80 00 79 	be  20075ec <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== NEVER TAKEN
 200740c:	90 10 00 18 	mov  %i0, %o0                                  
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
 2007410:	13 00 80 6d 	sethi  %hi(0x201b400), %o1                     
 2007414:	9f c6 40 00 	call  %i1                                      
 2007418:	92 12 62 50 	or  %o1, 0x250, %o1	! 201b650 <CSWTCH.2+0x14>  
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
 200741c:	90 10 00 18 	mov  %i0, %o0                                  
 2007420:	13 00 80 6d 	sethi  %hi(0x201b400), %o1                     
 2007424:	9f c6 40 00 	call  %i1                                      
 2007428:	92 12 62 70 	or  %o1, 0x270, %o1	! 201b670 <CSWTCH.2+0x34>  
    (*print)( context, "--- Wall times are in seconds ---\n" );       
 200742c:	90 10 00 18 	mov  %i0, %o0                                  
 2007430:	13 00 80 6d 	sethi  %hi(0x201b400), %o1                     
 2007434:	9f c6 40 00 	call  %i1                                      
 2007438:	92 12 62 98 	or  %o1, 0x298, %o1	! 201b698 <CSWTCH.2+0x5c>  
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
 200743c:	90 10 00 18 	mov  %i0, %o0                                  
 2007440:	13 00 80 6d 	sethi  %hi(0x201b400), %o1                     
 2007444:	9f c6 40 00 	call  %i1                                      
 2007448:	92 12 62 c0 	or  %o1, 0x2c0, %o1	! 201b6c0 <CSWTCH.2+0x84>  
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
 200744c:	90 10 00 18 	mov  %i0, %o0                                  
 2007450:	13 00 80 6d 	sethi  %hi(0x201b400), %o1                     
 2007454:	9f c6 40 00 	call  %i1                                      
 2007458:	92 12 63 10 	or  %o1, 0x310, %o1	! 201b710 <CSWTCH.2+0xd4>  
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
 200745c:	3b 00 80 75 	sethi  %hi(0x201d400), %i5                     
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
 2007460:	2b 00 80 6d 	sethi  %hi(0x201b400), %l5                     
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
 2007464:	82 17 61 f4 	or  %i5, 0x1f4, %g1                            
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
      (*print)( context,                                              
 2007468:	27 00 80 6d 	sethi  %hi(0x201b400), %l3                     
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
                                                                      
      _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
      (*print)( context,                                              
 200746c:	35 00 80 6d 	sethi  %hi(0x201b400), %i2                     
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
 2007470:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
 2007474:	ae 07 bf a0 	add  %fp, -96, %l7                             
    #if defined(RTEMS_DEBUG)                                          
      status = rtems_rate_monotonic_get_status( id, &the_status );    
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
 2007478:	ac 07 bf d8 	add  %fp, -40, %l6                             
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
 200747c:	a4 07 bf f8 	add  %fp, -8, %l2                              
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
 2007480:	aa 15 63 60 	or  %l5, 0x360, %l5                            
    {                                                                 
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
 2007484:	a8 07 bf b8 	add  %fp, -72, %l4                             
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
 2007488:	a2 07 bf f0 	add  %fp, -16, %l1                             
      (*print)( context,                                              
 200748c:	a6 14 e3 78 	or  %l3, 0x378, %l3                            
    {                                                                 
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      struct timespec  wall_average;                                  
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
 2007490:	b8 07 bf d0 	add  %fp, -48, %i4                             
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
 2007494:	10 80 00 52 	b  20075dc <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc>
 2007498:	b4 16 a3 98 	or  %i2, 0x398, %i2                            
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
 200749c:	40 00 18 22 	call  200d524 <rtems_rate_monotonic_get_statistics>
 20074a0:	92 10 00 17 	mov  %l7, %o1                                  
    if ( status != RTEMS_SUCCESSFUL )                                 
 20074a4:	80 a2 20 00 	cmp  %o0, 0                                    
 20074a8:	32 80 00 4c 	bne,a   20075d8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d8>
 20074ac:	a0 04 20 01 	inc  %l0                                       
    #if defined(RTEMS_DEBUG)                                          
      status = rtems_rate_monotonic_get_status( id, &the_status );    
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
 20074b0:	92 10 00 16 	mov  %l6, %o1                                  
 20074b4:	40 00 18 49 	call  200d5d8 <rtems_rate_monotonic_get_status>
 20074b8:	90 10 00 10 	mov  %l0, %o0                                  
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
 20074bc:	d0 07 bf d8 	ld  [ %fp + -40 ], %o0                         
 20074c0:	92 10 20 05 	mov  5, %o1                                    
 20074c4:	40 00 00 ae 	call  200777c <rtems_object_get_name>          
 20074c8:	94 10 00 12 	mov  %l2, %o2                                  
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
 20074cc:	d8 1f bf a0 	ldd  [ %fp + -96 ], %o4                        
 20074d0:	92 10 00 15 	mov  %l5, %o1                                  
 20074d4:	90 10 00 18 	mov  %i0, %o0                                  
 20074d8:	94 10 00 10 	mov  %l0, %o2                                  
 20074dc:	9f c6 40 00 	call  %i1                                      
 20074e0:	96 10 00 12 	mov  %l2, %o3                                  
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
 20074e4:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         
 20074e8:	80 a2 60 00 	cmp  %o1, 0                                    
 20074ec:	12 80 00 08 	bne  200750c <rtems_rate_monotonic_report_statistics_with_plugin+0x10c>
 20074f0:	94 10 00 11 	mov  %l1, %o2                                  
      (*print)( context, "\n" );                                      
 20074f4:	90 10 00 18 	mov  %i0, %o0                                  
 20074f8:	13 00 80 6a 	sethi  %hi(0x201a800), %o1                     
 20074fc:	9f c6 40 00 	call  %i1                                      
 2007500:	92 12 61 58 	or  %o1, 0x158, %o1	! 201a958 <_rodata_start+0x158>
      continue;                                                       
 2007504:	10 80 00 35 	b  20075d8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d8>
 2007508:	a0 04 20 01 	inc  %l0                                       
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
 200750c:	40 00 0e 9d 	call  200af80 <_Timespec_Divide_by_integer>    
 2007510:	90 10 00 14 	mov  %l4, %o0                                  
      (*print)( context,                                              
 2007514:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
 2007518:	40 00 45 7a 	call  2018b00 <.div>                           
 200751c:	92 10 23 e8 	mov  0x3e8, %o1                                
 2007520:	96 10 00 08 	mov  %o0, %o3                                  
 2007524:	d0 07 bf b4 	ld  [ %fp + -76 ], %o0                         
 2007528:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        
 200752c:	40 00 45 75 	call  2018b00 <.div>                           
 2007530:	92 10 23 e8 	mov  0x3e8, %o1                                
 2007534:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
 2007538:	b6 10 00 08 	mov  %o0, %i3                                  
 200753c:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
 2007540:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 2007544:	40 00 45 6f 	call  2018b00 <.div>                           
 2007548:	92 10 23 e8 	mov  0x3e8, %o1                                
 200754c:	d8 07 bf b0 	ld  [ %fp + -80 ], %o4                         
 2007550:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        
 2007554:	d4 07 bf a8 	ld  [ %fp + -88 ], %o2                         
 2007558:	9a 10 00 1b 	mov  %i3, %o5                                  
 200755c:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
 2007560:	92 10 00 13 	mov  %l3, %o1                                  
 2007564:	9f c6 40 00 	call  %i1                                      
 2007568:	90 10 00 18 	mov  %i0, %o0                                  
      struct timespec  wall_average;                                  
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
                                                                      
      _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
 200756c:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         
 2007570:	94 10 00 11 	mov  %l1, %o2                                  
 2007574:	40 00 0e 83 	call  200af80 <_Timespec_Divide_by_integer>    
 2007578:	90 10 00 1c 	mov  %i4, %o0                                  
      (*print)( context,                                              
 200757c:	d0 07 bf c4 	ld  [ %fp + -60 ], %o0                         
 2007580:	40 00 45 60 	call  2018b00 <.div>                           
 2007584:	92 10 23 e8 	mov  0x3e8, %o1                                
 2007588:	96 10 00 08 	mov  %o0, %o3                                  
 200758c:	d0 07 bf cc 	ld  [ %fp + -52 ], %o0                         
 2007590:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        
 2007594:	40 00 45 5b 	call  2018b00 <.div>                           
 2007598:	92 10 23 e8 	mov  0x3e8, %o1                                
 200759c:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
 20075a0:	b6 10 00 08 	mov  %o0, %i3                                  
 20075a4:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
 20075a8:	92 10 23 e8 	mov  0x3e8, %o1                                
 20075ac:	40 00 45 55 	call  2018b00 <.div>                           
 20075b0:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 20075b4:	d4 07 bf c0 	ld  [ %fp + -64 ], %o2                         
 20075b8:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        
 20075bc:	d8 07 bf c8 	ld  [ %fp + -56 ], %o4                         
 20075c0:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
 20075c4:	92 10 00 1a 	mov  %i2, %o1                                  
 20075c8:	90 10 00 18 	mov  %i0, %o0                                  
 20075cc:	9f c6 40 00 	call  %i1                                      
 20075d0:	9a 10 00 1b 	mov  %i3, %o5                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
 20075d4:	a0 04 20 01 	inc  %l0                                       
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
        id <= _Rate_monotonic_Information.maximum_id ;                
 20075d8:	82 17 61 f4 	or  %i5, 0x1f4, %g1                            
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
 20075dc:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 20075e0:	80 a4 00 01 	cmp  %l0, %g1                                  
 20075e4:	08 bf ff ae 	bleu  200749c <rtems_rate_monotonic_report_statistics_with_plugin+0x9c>
 20075e8:	90 10 00 10 	mov  %l0, %o0                                  
 20075ec:	81 c7 e0 08 	ret                                            
 20075f0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
020156fc <rtems_signal_send>:                                         
                                                                      
rtems_status_code rtems_signal_send(                                  
  rtems_id          id,                                               
  rtems_signal_set  signal_set                                        
)                                                                     
{                                                                     
 20156fc:	9d e3 bf 98 	save  %sp, -104, %sp                           
 2015700:	90 10 00 18 	mov  %i0, %o0                                  
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
 2015704:	80 a6 60 00 	cmp  %i1, 0                                    
 2015708:	02 80 00 2e 	be  20157c0 <rtems_signal_send+0xc4>           
 201570c:	b0 10 20 0a 	mov  0xa, %i0                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 2015710:	40 00 11 d1 	call  2019e54 <_Thread_Get>                    
 2015714:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 2015718:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 201571c:	a2 10 00 08 	mov  %o0, %l1                                  
  switch ( location ) {                                               
 2015720:	80 a0 60 00 	cmp  %g1, 0                                    
 2015724:	12 80 00 27 	bne  20157c0 <rtems_signal_send+0xc4>          
 2015728:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
 201572c:	e0 02 21 58 	ld  [ %o0 + 0x158 ], %l0                       
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
 2015730:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
 2015734:	80 a0 60 00 	cmp  %g1, 0                                    
 2015738:	02 80 00 24 	be  20157c8 <rtems_signal_send+0xcc>           
 201573c:	01 00 00 00 	nop                                            
        if ( asr->is_enabled ) {                                      
 2015740:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
 2015744:	80 a0 60 00 	cmp  %g1, 0                                    
 2015748:	02 80 00 15 	be  201579c <rtems_signal_send+0xa0>           
 201574c:	01 00 00 00 	nop                                            
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
 2015750:	7f ff e7 99 	call  200f5b4 <sparc_disable_interrupts>       
 2015754:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
 2015758:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
 201575c:	b2 10 40 19 	or  %g1, %i1, %i1                              
 2015760:	f2 24 20 14 	st  %i1, [ %l0 + 0x14 ]                        
  _ISR_Enable( _level );                                              
 2015764:	7f ff e7 98 	call  200f5c4 <sparc_enable_interrupts>        
 2015768:	01 00 00 00 	nop                                            
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
 201576c:	03 00 80 f1 	sethi  %hi(0x203c400), %g1                     
 2015770:	82 10 63 34 	or  %g1, 0x334, %g1	! 203c734 <_Per_CPU_Information>
 2015774:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 2015778:	80 a0 a0 00 	cmp  %g2, 0                                    
 201577c:	02 80 00 0f 	be  20157b8 <rtems_signal_send+0xbc>           
 2015780:	01 00 00 00 	nop                                            
 2015784:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 2015788:	80 a4 40 02 	cmp  %l1, %g2                                  
 201578c:	12 80 00 0b 	bne  20157b8 <rtems_signal_send+0xbc>          <== NEVER TAKEN
 2015790:	84 10 20 01 	mov  1, %g2                                    
            _Thread_Dispatch_necessary = true;                        
 2015794:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
 2015798:	30 80 00 08 	b,a   20157b8 <rtems_signal_send+0xbc>         
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
 201579c:	7f ff e7 86 	call  200f5b4 <sparc_disable_interrupts>       
 20157a0:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
 20157a4:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
 20157a8:	b2 10 40 19 	or  %g1, %i1, %i1                              
 20157ac:	f2 24 20 18 	st  %i1, [ %l0 + 0x18 ]                        
  _ISR_Enable( _level );                                              
 20157b0:	7f ff e7 85 	call  200f5c4 <sparc_enable_interrupts>        
 20157b4:	01 00 00 00 	nop                                            
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
 20157b8:	40 00 11 9a 	call  2019e20 <_Thread_Enable_dispatch>        
 20157bc:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
        return RTEMS_SUCCESSFUL;                                      
 20157c0:	81 c7 e0 08 	ret                                            
 20157c4:	81 e8 00 00 	restore                                        
      }                                                               
      _Thread_Enable_dispatch();                                      
 20157c8:	40 00 11 96 	call  2019e20 <_Thread_Enable_dispatch>        
 20157cc:	b0 10 20 0b 	mov  0xb, %i0                                  
      return RTEMS_NOT_DEFINED;                                       
 20157d0:	81 c7 e0 08 	ret                                            
 20157d4:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
0200d400 <rtems_task_mode>:                                           
rtems_status_code rtems_task_mode(                                    
  rtems_mode  mode_set,                                               
  rtems_mode  mask,                                                   
  rtems_mode *previous_mode_set                                       
)                                                                     
{                                                                     
 200d400:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ASR_Information    *asr;                                            
  bool                is_asr_enabled = false;                         
  bool                needs_asr_dispatching = false;                  
  rtems_mode          old_mode;                                       
                                                                      
  if ( !previous_mode_set )                                           
 200d404:	80 a6 a0 00 	cmp  %i2, 0                                    
 200d408:	02 80 00 5a 	be  200d570 <rtems_task_mode+0x170>            
 200d40c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
 200d410:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200d414:	e2 00 63 68 	ld  [ %g1 + 0x368 ], %l1	! 2014f68 <_Per_CPU_Information+0xc>
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
 200d418:	c2 0c 60 74 	ldub  [ %l1 + 0x74 ], %g1                      
                                                                      
  if ( !previous_mode_set )                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
 200d41c:	e0 04 61 58 	ld  [ %l1 + 0x158 ], %l0                       
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
 200d420:	80 a0 00 01 	cmp  %g0, %g1                                  
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
 200d424:	c2 04 60 7c 	ld  [ %l1 + 0x7c ], %g1                        
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
 200d428:	a4 60 3f ff 	subx  %g0, -1, %l2                             
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
 200d42c:	80 a0 60 00 	cmp  %g1, 0                                    
 200d430:	02 80 00 03 	be  200d43c <rtems_task_mode+0x3c>             
 200d434:	a5 2c a0 08 	sll  %l2, 8, %l2                               
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
 200d438:	a4 14 a2 00 	or  %l2, 0x200, %l2                            
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
 200d43c:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
 200d440:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
 200d444:	7f ff f2 44 	call  2009d54 <_CPU_ISR_Get_level>             
 200d448:	a6 60 3f ff 	subx  %g0, -1, %l3                             
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
 200d44c:	a7 2c e0 0a 	sll  %l3, 0xa, %l3                             
 200d450:	a6 14 c0 08 	or  %l3, %o0, %l3                              
  old_mode |= _ISR_Get_level();                                       
 200d454:	a4 14 c0 12 	or  %l3, %l2, %l2                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
 200d458:	80 8e 61 00 	btst  0x100, %i1                               
 200d45c:	02 80 00 06 	be  200d474 <rtems_task_mode+0x74>             
 200d460:	e4 26 80 00 	st  %l2, [ %i2 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (                         
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
   return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;           
 200d464:	82 0e 21 00 	and  %i0, 0x100, %g1                           
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
 200d468:	80 a0 00 01 	cmp  %g0, %g1                                  
 200d46c:	82 60 3f ff 	subx  %g0, -1, %g1                             
 200d470:	c2 2c 60 74 	stb  %g1, [ %l1 + 0x74 ]                       
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
 200d474:	80 8e 62 00 	btst  0x200, %i1                               
 200d478:	02 80 00 0b 	be  200d4a4 <rtems_task_mode+0xa4>             
 200d47c:	80 8e 60 0f 	btst  0xf, %i1                                 
    if ( _Modes_Is_timeslice(mode_set) ) {                            
 200d480:	80 8e 22 00 	btst  0x200, %i0                               
 200d484:	22 80 00 07 	be,a   200d4a0 <rtems_task_mode+0xa0>          
 200d488:	c0 24 60 7c 	clr  [ %l1 + 0x7c ]                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
 200d48c:	82 10 20 01 	mov  1, %g1                                    
 200d490:	c2 24 60 7c 	st  %g1, [ %l1 + 0x7c ]                        
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
 200d494:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200d498:	c2 00 60 94 	ld  [ %g1 + 0x94 ], %g1	! 2014c94 <_Thread_Ticks_per_timeslice>
 200d49c:	c2 24 60 78 	st  %g1, [ %l1 + 0x78 ]                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
 200d4a0:	80 8e 60 0f 	btst  0xf, %i1                                 
 200d4a4:	02 80 00 06 	be  200d4bc <rtems_task_mode+0xbc>             
 200d4a8:	80 8e 64 00 	btst  0x400, %i1                               
 */                                                                   
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (           
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  return ( mode_set & RTEMS_INTERRUPT_MASK );                         
 200d4ac:	90 0e 20 0f 	and  %i0, 0xf, %o0                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (                
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );           
 200d4b0:	7f ff d2 91 	call  2001ef4 <sparc_enable_interrupts>        
 200d4b4:	91 2a 20 08 	sll  %o0, 8, %o0                               
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
 200d4b8:	80 8e 64 00 	btst  0x400, %i1                               
 200d4bc:	02 80 00 14 	be  200d50c <rtems_task_mode+0x10c>            
 200d4c0:	88 10 20 00 	clr  %g4                                       
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
 200d4c4:	c4 0c 20 08 	ldub  [ %l0 + 8 ], %g2                         
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Modes_Is_asr_disabled (                    
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
   return (mode_set & RTEMS_ASR_MASK) == RTEMS_NO_ASR;                
 200d4c8:	b0 0e 24 00 	and  %i0, 0x400, %i0                           
 *  Output:                                                           
 *    *previous_mode_set - previous mode set                          
 *     always return RTEMS_SUCCESSFUL;                                
 */                                                                   
                                                                      
rtems_status_code rtems_task_mode(                                    
 200d4cc:	80 a0 00 18 	cmp  %g0, %i0                                  
 200d4d0:	82 60 3f ff 	subx  %g0, -1, %g1                             
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
 200d4d4:	80 a0 40 02 	cmp  %g1, %g2                                  
 200d4d8:	22 80 00 0e 	be,a   200d510 <rtems_task_mode+0x110>         
 200d4dc:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
)                                                                     
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
 200d4e0:	7f ff d2 81 	call  2001ee4 <sparc_disable_interrupts>       
 200d4e4:	c2 2c 20 08 	stb  %g1, [ %l0 + 8 ]                          
    _signals                     = information->signals_pending;      
 200d4e8:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
    information->signals_pending = information->signals_posted;       
 200d4ec:	c4 04 20 14 	ld  [ %l0 + 0x14 ], %g2                        
    information->signals_posted  = _signals;                          
 200d4f0:	c2 24 20 14 	st  %g1, [ %l0 + 0x14 ]                        
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
    _signals                     = information->signals_pending;      
    information->signals_pending = information->signals_posted;       
 200d4f4:	c4 24 20 18 	st  %g2, [ %l0 + 0x18 ]                        
    information->signals_posted  = _signals;                          
  _ISR_Enable( _level );                                              
 200d4f8:	7f ff d2 7f 	call  2001ef4 <sparc_enable_interrupts>        
 200d4fc:	01 00 00 00 	nop                                            
      asr->is_enabled = is_asr_enabled;                               
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
 200d500:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
                                                                      
  /*                                                                  
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
 200d504:	80 a0 00 01 	cmp  %g0, %g1                                  
 200d508:	88 40 20 00 	addx  %g0, 0, %g4                              
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
 200d50c:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200d510:	c4 00 62 8c 	ld  [ %g1 + 0x28c ], %g2	! 2014e8c <_System_state_Current>
 200d514:	80 a0 a0 03 	cmp  %g2, 3                                    
 200d518:	12 80 00 16 	bne  200d570 <rtems_task_mode+0x170>           <== NEVER TAKEN
 200d51c:	82 10 20 00 	clr  %g1                                       
  bool are_signals_pending                                            
)                                                                     
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
 200d520:	07 00 80 53 	sethi  %hi(0x2014c00), %g3                     
                                                                      
  if ( are_signals_pending ||                                         
 200d524:	80 89 20 ff 	btst  0xff, %g4                                
  bool are_signals_pending                                            
)                                                                     
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
 200d528:	86 10 e3 5c 	or  %g3, 0x35c, %g3                            
                                                                      
  if ( are_signals_pending ||                                         
 200d52c:	12 80 00 0a 	bne  200d554 <rtems_task_mode+0x154>           
 200d530:	c4 00 e0 0c 	ld  [ %g3 + 0xc ], %g2                         
 200d534:	c6 00 e0 10 	ld  [ %g3 + 0x10 ], %g3                        
 200d538:	80 a0 80 03 	cmp  %g2, %g3                                  
 200d53c:	02 80 00 0d 	be  200d570 <rtems_task_mode+0x170>            
 200d540:	01 00 00 00 	nop                                            
       (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
 200d544:	c4 08 a0 74 	ldub  [ %g2 + 0x74 ], %g2                      
 200d548:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d54c:	02 80 00 09 	be  200d570 <rtems_task_mode+0x170>            <== NEVER TAKEN
 200d550:	01 00 00 00 	nop                                            
    _Thread_Dispatch_necessary = true;                                
 200d554:	84 10 20 01 	mov  1, %g2	! 1 <PROM_START+0x1>               
 200d558:	03 00 80 53 	sethi  %hi(0x2014c00), %g1                     
 200d55c:	82 10 63 5c 	or  %g1, 0x35c, %g1	! 2014f5c <_Per_CPU_Information>
 200d560:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
 200d564:	7f ff eb ef 	call  2008520 <_Thread_Dispatch>               
 200d568:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200d56c:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
}                                                                     
 200d570:	81 c7 e0 08 	ret                                            
 200d574:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
===============================================================================
0200aa4c <rtems_task_set_priority>:                                   
rtems_status_code rtems_task_set_priority(                            
  rtems_id             id,                                            
  rtems_task_priority  new_priority,                                  
  rtems_task_priority *old_priority                                   
)                                                                     
{                                                                     
 200aa4c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
 200aa50:	80 a6 60 00 	cmp  %i1, 0                                    
 200aa54:	02 80 00 07 	be  200aa70 <rtems_task_set_priority+0x24>     
 200aa58:	90 10 00 18 	mov  %i0, %o0                                  
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
            ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );             
 200aa5c:	03 00 80 62 	sethi  %hi(0x2018800), %g1                     
 200aa60:	c2 08 60 f4 	ldub  [ %g1 + 0xf4 ], %g1	! 20188f4 <rtems_maximum_priority>
 200aa64:	80 a6 40 01 	cmp  %i1, %g1                                  
 200aa68:	18 80 00 1c 	bgu  200aad8 <rtems_task_set_priority+0x8c>    
 200aa6c:	b0 10 20 13 	mov  0x13, %i0                                 
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
 200aa70:	80 a6 a0 00 	cmp  %i2, 0                                    
 200aa74:	02 80 00 19 	be  200aad8 <rtems_task_set_priority+0x8c>     
 200aa78:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 200aa7c:	40 00 09 30 	call  200cf3c <_Thread_Get>                    
 200aa80:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 200aa84:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200aa88:	80 a0 60 00 	cmp  %g1, 0                                    
 200aa8c:	12 80 00 13 	bne  200aad8 <rtems_task_set_priority+0x8c>    
 200aa90:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
 200aa94:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
 200aa98:	80 a6 60 00 	cmp  %i1, 0                                    
 200aa9c:	02 80 00 0d 	be  200aad0 <rtems_task_set_priority+0x84>     
 200aaa0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
 200aaa4:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
 200aaa8:	80 a0 60 00 	cmp  %g1, 0                                    
 200aaac:	02 80 00 06 	be  200aac4 <rtems_task_set_priority+0x78>     
 200aab0:	f2 22 20 18 	st  %i1, [ %o0 + 0x18 ]                        
 200aab4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
 200aab8:	80 a0 40 19 	cmp  %g1, %i1                                  
 200aabc:	08 80 00 05 	bleu  200aad0 <rtems_task_set_priority+0x84>   <== ALWAYS TAKEN
 200aac0:	01 00 00 00 	nop                                            
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
 200aac4:	92 10 00 19 	mov  %i1, %o1                                  
 200aac8:	40 00 07 ed 	call  200ca7c <_Thread_Change_priority>        
 200aacc:	94 10 20 00 	clr  %o2                                       
      }                                                               
      _Thread_Enable_dispatch();                                      
 200aad0:	40 00 09 0e 	call  200cf08 <_Thread_Enable_dispatch>        
 200aad4:	b0 10 20 00 	clr  %i0                                       
      return RTEMS_SUCCESSFUL;                                        
 200aad8:	81 c7 e0 08 	ret                                            
 200aadc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
02016108 <rtems_timer_cancel>:                                        
 */                                                                   
                                                                      
rtems_status_code rtems_timer_cancel(                                 
  rtems_id id                                                         
)                                                                     
{                                                                     
 2016108:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
    _Objects_Get( &_Timer_Information, id, location );                
 201610c:	11 00 80 f1 	sethi  %hi(0x203c400), %o0                     
 2016110:	92 10 00 18 	mov  %i0, %o1                                  
 2016114:	90 12 23 c4 	or  %o0, 0x3c4, %o0                            
 2016118:	40 00 0b be 	call  2019010 <_Objects_Get>                   
 201611c:	94 07 bf fc 	add  %fp, -4, %o2                              
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
 2016120:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2016124:	80 a0 60 00 	cmp  %g1, 0                                    
 2016128:	12 80 00 0c 	bne  2016158 <rtems_timer_cancel+0x50>         
 201612c:	01 00 00 00 	nop                                            
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
 2016130:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 2016134:	80 a0 60 04 	cmp  %g1, 4                                    
 2016138:	02 80 00 04 	be  2016148 <rtems_timer_cancel+0x40>          <== NEVER TAKEN
 201613c:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &the_timer->Ticker );                
 2016140:	40 00 13 fe 	call  201b138 <_Watchdog_Remove>               
 2016144:	90 02 20 10 	add  %o0, 0x10, %o0                            
      _Thread_Enable_dispatch();                                      
 2016148:	40 00 0f 36 	call  2019e20 <_Thread_Enable_dispatch>        
 201614c:	b0 10 20 00 	clr  %i0                                       
      return RTEMS_SUCCESSFUL;                                        
 2016150:	81 c7 e0 08 	ret                                            
 2016154:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 2016158:	81 c7 e0 08 	ret                                            
 201615c:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      
===============================================================================
020165f0 <rtems_timer_server_fire_when>:                              
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
 20165f0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
 20165f4:	03 00 80 f2 	sethi  %hi(0x203c800), %g1                     
 20165f8:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1	! 203c804 <_Timer_server> 
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
 20165fc:	a0 10 00 18 	mov  %i0, %l0                                  
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
 2016600:	80 a4 60 00 	cmp  %l1, 0                                    
 2016604:	02 80 00 33 	be  20166d0 <rtems_timer_server_fire_when+0xe0>
 2016608:	b0 10 20 0e 	mov  0xe, %i0                                  
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
 201660c:	03 00 80 f1 	sethi  %hi(0x203c400), %g1                     
 2016610:	c2 08 61 10 	ldub  [ %g1 + 0x110 ], %g1	! 203c510 <_TOD_Is_set>
 2016614:	80 a0 60 00 	cmp  %g1, 0                                    
 2016618:	02 80 00 2e 	be  20166d0 <rtems_timer_server_fire_when+0xe0><== NEVER TAKEN
 201661c:	b0 10 20 0b 	mov  0xb, %i0                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
 2016620:	80 a6 a0 00 	cmp  %i2, 0                                    
 2016624:	02 80 00 2b 	be  20166d0 <rtems_timer_server_fire_when+0xe0>
 2016628:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
 201662c:	90 10 00 19 	mov  %i1, %o0                                  
 2016630:	7f ff f4 07 	call  201364c <_TOD_Validate>                  
 2016634:	b0 10 20 14 	mov  0x14, %i0                                 
 2016638:	80 8a 20 ff 	btst  0xff, %o0                                
 201663c:	02 80 00 27 	be  20166d8 <rtems_timer_server_fire_when+0xe8>
 2016640:	01 00 00 00 	nop                                            
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
 2016644:	7f ff f3 ce 	call  201357c <_TOD_To_seconds>                
 2016648:	90 10 00 19 	mov  %i1, %o0                                  
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
 201664c:	27 00 80 f1 	sethi  %hi(0x203c400), %l3                     
 2016650:	c2 04 e1 8c 	ld  [ %l3 + 0x18c ], %g1	! 203c58c <_TOD_Now>  
 2016654:	80 a2 00 01 	cmp  %o0, %g1                                  
 2016658:	08 80 00 1e 	bleu  20166d0 <rtems_timer_server_fire_when+0xe0>
 201665c:	a4 10 00 08 	mov  %o0, %l2                                  
 2016660:	11 00 80 f1 	sethi  %hi(0x203c400), %o0                     
 2016664:	92 10 00 10 	mov  %l0, %o1                                  
 2016668:	90 12 23 c4 	or  %o0, 0x3c4, %o0                            
 201666c:	40 00 0a 69 	call  2019010 <_Objects_Get>                   
 2016670:	94 07 bf fc 	add  %fp, -4, %o2                              
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
 2016674:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2016678:	b2 10 00 08 	mov  %o0, %i1                                  
 201667c:	80 a0 60 00 	cmp  %g1, 0                                    
 2016680:	12 80 00 14 	bne  20166d0 <rtems_timer_server_fire_when+0xe0>
 2016684:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
 2016688:	40 00 12 ac 	call  201b138 <_Watchdog_Remove>               
 201668c:	90 02 20 10 	add  %o0, 0x10, %o0                            
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
 2016690:	82 10 20 03 	mov  3, %g1                                    
 2016694:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
 2016698:	c2 04 e1 8c 	ld  [ %l3 + 0x18c ], %g1                       
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
 201669c:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
 20166a0:	a4 24 80 01 	sub  %l2, %g1, %l2                             
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
 20166a4:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
 20166a8:	92 10 00 19 	mov  %i1, %o1                                  
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 20166ac:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
 20166b0:	f4 26 60 2c 	st  %i2, [ %i1 + 0x2c ]                        
  the_watchdog->id        = id;                                       
 20166b4:	e0 26 60 30 	st  %l0, [ %i1 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
 20166b8:	f6 26 60 34 	st  %i3, [ %i1 + 0x34 ]                        
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
 20166bc:	e4 26 60 1c 	st  %l2, [ %i1 + 0x1c ]                        
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
 20166c0:	9f c0 40 00 	call  %g1                                      
 20166c4:	b0 10 20 00 	clr  %i0                                       
                                                                      
      _Thread_Enable_dispatch();                                      
 20166c8:	40 00 0d d6 	call  2019e20 <_Thread_Enable_dispatch>        
 20166cc:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
 20166d0:	81 c7 e0 08 	ret                                            
 20166d4:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 20166d8:	81 c7 e0 08 	ret                                            
 20166dc:	81 e8 00 00 	restore