===============================================================================
40017f94 <_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                    
)                                                                     
{                                                                     
40017f94:	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 ) {             
40017f98:	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                    
)                                                                     
{                                                                     
40017f9c:	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 ) {             
40017fa0:	80 a6 80 01 	cmp  %i2, %g1                                  
40017fa4:	18 80 00 16 	bgu  40017ffc <_CORE_message_queue_Broadcast+0x68><== NEVER TAKEN
40017fa8:	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 ) {         
40017fac:	c2 04 20 48 	ld  [ %l0 + 0x48 ], %g1                        
40017fb0:	80 a0 60 00 	cmp  %g1, 0                                    
40017fb4:	02 80 00 0b 	be  40017fe0 <_CORE_message_queue_Broadcast+0x4c>
40017fb8:	a2 10 20 00 	clr  %l1                                       
    *count = 0;                                                       
40017fbc:	c0 27 40 00 	clr  [ %i5 ]                                   
    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                      
40017fc0:	81 c7 e0 08 	ret                                            
40017fc4:	91 e8 20 00 	restore  %g0, 0, %o0                           
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
40017fc8:	92 10 00 19 	mov  %i1, %o1                                  
40017fcc:	40 00 21 0c 	call  400203fc <memcpy>                        
40017fd0:	94 10 00 1a 	mov  %i2, %o2                                  
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
40017fd4:	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;                                          
40017fd8:	a2 04 60 01 	inc  %l1                                       
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
40017fdc:	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 =                                                
40017fe0:	40 00 0a 2c 	call  4001a890 <_Thread_queue_Dequeue>         
40017fe4:	90 10 00 10 	mov  %l0, %o0                                  
40017fe8:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40017fec:	32 bf ff f7 	bne,a   40017fc8 <_CORE_message_queue_Broadcast+0x34>
40017ff0:	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;                                        
40017ff4:	e2 27 40 00 	st  %l1, [ %i5 ]                               
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                        
40017ff8:	b0 10 20 00 	clr  %i0                                       
}                                                                     
40017ffc:	81 c7 e0 08 	ret                                            
40018000:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
400107c8 <_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                 
)                                                                     
{                                                                     
400107c8:	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;
400107cc:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
  the_message_queue->number_of_pending_messages = 0;                  
400107d0:	c0 26 20 48 	clr  [ %i0 + 0x48 ]                            
  the_message_queue->maximum_message_size       = maximum_message_size;
400107d4:	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                 
)                                                                     
{                                                                     
400107d8:	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)) {              
400107dc:	80 8e e0 03 	btst  3, %i3                                   
400107e0:	02 80 00 07 	be  400107fc <_CORE_message_queue_Initialize+0x34>
400107e4:	a4 10 00 1b 	mov  %i3, %l2                                  
    allocated_message_size += sizeof(uint32_t);                       
400107e8:	a4 06 e0 04 	add  %i3, 4, %l2                               
    allocated_message_size &= ~(sizeof(uint32_t) - 1);                
400107ec:	a4 0c bf fc 	and  %l2, -4, %l2                              
  }                                                                   
                                                                      
  if (allocated_message_size < maximum_message_size)                  
400107f0:	80 a4 80 1b 	cmp  %l2, %i3                                  
400107f4:	0a 80 00 22 	bcs  4001087c <_CORE_message_queue_Initialize+0xb4><== NEVER TAKEN
400107f8:	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));
400107fc:	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 *    
40010800:	92 10 00 1a 	mov  %i2, %o1                                  
40010804:	90 10 00 11 	mov  %l1, %o0                                  
40010808:	40 00 3d 44 	call  4001fd18 <.umul>                         
4001080c:	b0 10 20 00 	clr  %i0                                       
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
                                                                      
  if (message_buffering_required < allocated_message_size)            
40010810:	80 a2 00 12 	cmp  %o0, %l2                                  
40010814:	0a 80 00 1a 	bcs  4001087c <_CORE_message_queue_Initialize+0xb4><== NEVER TAKEN
40010818:	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 );               
4001081c:	40 00 0b 7b 	call  40013608 <_Workspace_Allocate>           
40010820:	01 00 00 00 	nop                                            
    return false;                                                     
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
40010824:	d0 24 20 5c 	st  %o0, [ %l0 + 0x5c ]                        
     _Workspace_Allocate( message_buffering_required );               
                                                                      
  if (the_message_queue->message_buffers == 0)                        
40010828:	80 a2 20 00 	cmp  %o0, 0                                    
4001082c:	02 80 00 14 	be  4001087c <_CORE_message_queue_Initialize+0xb4>
40010830:	92 10 00 08 	mov  %o0, %o1                                  
                                                                      
  /*                                                                  
   *  Initialize the pool of inactive messages, pending messages,     
   *  and set of waiting threads.                                     
   */                                                                 
  _Chain_Initialize (                                                 
40010834:	90 04 20 60 	add  %l0, 0x60, %o0                            
40010838:	94 10 00 1a 	mov  %i2, %o2                                  
4001083c:	40 00 13 91 	call  40015680 <_Chain_Initialize>             
40010840:	96 10 00 11 	mov  %l1, %o3                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
40010844:	82 04 20 54 	add  %l0, 0x54, %g1                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
40010848:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
    the_message_queue->message_buffers,                               
    (size_t) maximum_pending_messages,                                
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );                                                                  
                                                                      
  _Chain_Initialize_empty( &the_message_queue->Pending_messages );    
4001084c:	82 04 20 50 	add  %l0, 0x50, %g1                            
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
40010850:	c2 24 20 58 	st  %g1, [ %l0 + 0x58 ]                        
                                                                      
  _Thread_queue_Initialize(                                           
40010854:	c2 06 40 00 	ld  [ %i1 ], %g1                               
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
40010858:	c0 24 20 54 	clr  [ %l0 + 0x54 ]                            
4001085c:	82 18 60 01 	xor  %g1, 1, %g1                               
40010860:	80 a0 00 01 	cmp  %g0, %g1                                  
40010864:	90 10 00 10 	mov  %l0, %o0                                  
40010868:	92 60 3f ff 	subx  %g0, -1, %o1                             
4001086c:	94 10 20 80 	mov  0x80, %o2                                 
40010870:	96 10 20 06 	mov  6, %o3                                    
40010874:	40 00 08 53 	call  400129c0 <_Thread_queue_Initialize>      
40010878:	b0 10 20 01 	mov  1, %i0                                    
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
}                                                                     
4001087c:	81 c7 e0 08 	ret                                            
40010880:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40010884 <_CORE_message_queue_Seize>:                                 
  void                            *buffer,                            
  size_t                          *size_p,                            
  bool                             wait,                              
  Watchdog_Interval                timeout                            
)                                                                     
{                                                                     
40010884:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
40010888:	27 10 00 96 	sethi  %hi(0x40025800), %l3                    
4001088c:	a6 14 e3 3c 	or  %l3, 0x33c, %l3	! 40025b3c <_Per_CPU_Information>
40010890:	e4 04 e0 0c 	ld  [ %l3 + 0xc ], %l2                         
  void                            *buffer,                            
  size_t                          *size_p,                            
  bool                             wait,                              
  Watchdog_Interval                timeout                            
)                                                                     
{                                                                     
40010894:	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 );                                              
40010898:	7f ff da ad 	call  4000734c <sparc_disable_interrupts>      
4001089c:	c0 24 a0 34 	clr  [ %l2 + 0x34 ]                            
400108a0:	82 10 00 08 	mov  %o0, %g1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
400108a4:	e2 06 20 50 	ld  [ %i0 + 0x50 ], %l1                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
400108a8:	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))                                   
400108ac:	80 a4 40 02 	cmp  %l1, %g2                                  
400108b0:	02 80 00 15 	be  40010904 <_CORE_message_queue_Seize+0x80>  
400108b4:	86 06 20 50 	add  %i0, 0x50, %g3                            
{                                                                     
  Chain_Node  *return_node;                                           
  Chain_Node  *new_first;                                             
                                                                      
  return_node         = the_chain->first;                             
  new_first           = return_node->next;                            
400108b8:	c4 04 40 00 	ld  [ %l1 ], %g2                               
  the_chain->first    = new_first;                                    
400108bc:	c4 26 20 50 	st  %g2, [ %i0 + 0x50 ]                        
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {                                        
400108c0:	80 a4 60 00 	cmp  %l1, 0                                    
400108c4:	02 80 00 10 	be  40010904 <_CORE_message_queue_Seize+0x80>  <== NEVER TAKEN
400108c8:	c6 20 a0 04 	st  %g3, [ %g2 + 4 ]                           
    the_message_queue->number_of_pending_messages -= 1;               
400108cc:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
400108d0:	82 00 7f ff 	add  %g1, -1, %g1                              
400108d4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
    _ISR_Enable( level );                                             
400108d8:	7f ff da a1 	call  4000735c <sparc_enable_interrupts>       
400108dc:	b0 06 20 60 	add  %i0, 0x60, %i0                            
                                                                      
    *size_p = the_message->Contents.size;                             
400108e0:	d4 04 60 08 	ld  [ %l1 + 8 ], %o2                           
    _Thread_Executing->Wait.count =                                   
400108e4:	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;                             
400108e8:	d4 26 c0 00 	st  %o2, [ %i3 ]                               
    _Thread_Executing->Wait.count =                                   
400108ec:	c0 20 60 24 	clr  [ %g1 + 0x24 ]                            
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
400108f0:	90 10 00 1a 	mov  %i2, %o0                                  
400108f4:	40 00 1d f9 	call  400180d8 <memcpy>                        
400108f8:	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 );
400108fc:	7f ff ff 83 	call  40010708 <_Chain_Append>                 
40010900:	93 e8 00 11 	restore  %g0, %l1, %o1                         
      return;                                                         
    }                                                                 
    #endif                                                            
  }                                                                   
                                                                      
  if ( !wait ) {                                                      
40010904:	80 8f 20 ff 	btst  0xff, %i4                                
40010908:	32 80 00 08 	bne,a   40010928 <_CORE_message_queue_Seize+0xa4>
4001090c:	84 10 20 01 	mov  1, %g2                                    
    _ISR_Enable( level );                                             
40010910:	7f ff da 93 	call  4000735c <sparc_enable_interrupts>       
40010914:	90 10 00 01 	mov  %g1, %o0                                  
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
40010918:	82 10 20 04 	mov  4, %g1                                    
4001091c:	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 );   
}                                                                     
40010920:	81 c7 e0 08 	ret                                            
40010924:	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;
40010928:	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;             
4001092c:	f0 24 a0 44 	st  %i0, [ %l2 + 0x44 ]                        
  executing->Wait.id = id;                                            
40010930:	e0 24 a0 20 	st  %l0, [ %l2 + 0x20 ]                        
  executing->Wait.return_argument_second.mutable_object = buffer;     
40010934:	f4 24 a0 2c 	st  %i2, [ %l2 + 0x2c ]                        
  executing->Wait.return_argument = size_p;                           
40010938:	f6 24 a0 28 	st  %i3, [ %l2 + 0x28 ]                        
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
4001093c:	90 10 00 01 	mov  %g1, %o0                                  
40010940:	7f ff da 87 	call  4000735c <sparc_enable_interrupts>       
40010944:	35 10 00 4a 	sethi  %hi(0x40012800), %i2                    
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
40010948:	b2 10 00 1d 	mov  %i5, %i1                                  
4001094c:	40 00 07 75 	call  40012720 <_Thread_queue_Enqueue_with_handler>
40010950:	95 ee a2 a0 	restore  %i2, 0x2a0, %o2                       
                                                                      
===============================================================================
4000762c <_CORE_mutex_Seize>:                                         
  Objects_Id           _id,                                           
  bool                 _wait,                                         
  Watchdog_Interval    _timeout,                                      
  ISR_Level            _level                                         
)                                                                     
{                                                                     
4000762c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
40007630:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40007634:	c2 00 63 68 	ld  [ %g1 + 0x368 ], %g1	! 40015368 <_Thread_Dispatch_disable_level>
40007638:	80 a0 60 00 	cmp  %g1, 0                                    
4000763c:	02 80 00 0d 	be  40007670 <_CORE_mutex_Seize+0x44>          
40007640:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40007644:	80 8e a0 ff 	btst  0xff, %i2                                
40007648:	02 80 00 0b 	be  40007674 <_CORE_mutex_Seize+0x48>          <== NEVER TAKEN
4000764c:	90 10 00 18 	mov  %i0, %o0                                  
40007650:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40007654:	c2 00 60 ec 	ld  [ %g1 + 0xec ], %g1	! 400154ec <_System_state_Current>
40007658:	80 a0 60 01 	cmp  %g1, 1                                    
4000765c:	08 80 00 05 	bleu  40007670 <_CORE_mutex_Seize+0x44>        
40007660:	90 10 20 00 	clr  %o0                                       
40007664:	92 10 20 00 	clr  %o1                                       
40007668:	40 00 01 df 	call  40007de4 <_Internal_error_Occurred>      
4000766c:	94 10 20 12 	mov  0x12, %o2                                 
40007670:	90 10 00 18 	mov  %i0, %o0                                  
40007674:	40 00 12 ad 	call  4000c128 <_CORE_mutex_Seize_interrupt_trylock>
40007678:	92 07 a0 54 	add  %fp, 0x54, %o1                            
4000767c:	80 a2 20 00 	cmp  %o0, 0                                    
40007680:	02 80 00 0a 	be  400076a8 <_CORE_mutex_Seize+0x7c>          
40007684:	80 8e a0 ff 	btst  0xff, %i2                                
40007688:	35 10 00 55 	sethi  %hi(0x40015400), %i2                    
4000768c:	12 80 00 09 	bne  400076b0 <_CORE_mutex_Seize+0x84>         
40007690:	b4 16 a1 cc 	or  %i2, 0x1cc, %i2	! 400155cc <_Per_CPU_Information>
40007694:	7f ff e9 ac 	call  40001d44 <sparc_enable_interrupts>       
40007698:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
4000769c:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
400076a0:	84 10 20 01 	mov  1, %g2                                    
400076a4:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
400076a8:	81 c7 e0 08 	ret                                            
400076ac:	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;
400076b0:	82 10 20 01 	mov  1, %g1                                    
400076b4:	c2 26 20 30 	st  %g1, [ %i0 + 0x30 ]                        
400076b8:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
400076bc:	f0 20 60 44 	st  %i0, [ %g1 + 0x44 ]                        
400076c0:	f2 20 60 20 	st  %i1, [ %g1 + 0x20 ]                        
400076c4:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
400076c8:	c4 00 63 68 	ld  [ %g1 + 0x368 ], %g2	! 40015368 <_Thread_Dispatch_disable_level>
400076cc:	84 00 a0 01 	inc  %g2                                       
400076d0:	c4 20 63 68 	st  %g2, [ %g1 + 0x368 ]                       
400076d4:	7f ff e9 9c 	call  40001d44 <sparc_enable_interrupts>       
400076d8:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
400076dc:	90 10 00 18 	mov  %i0, %o0                                  
400076e0:	7f ff ff ba 	call  400075c8 <_CORE_mutex_Seize_interrupt_blocking>
400076e4:	92 10 00 1b 	mov  %i3, %o1                                  
400076e8:	81 c7 e0 08 	ret                                            
400076ec:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000c128 <_CORE_mutex_Seize_interrupt_trylock>:                       
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)                 
int _CORE_mutex_Seize_interrupt_trylock(                              
  CORE_mutex_Control  *the_mutex,                                     
  ISR_Level           *level_p                                        
)                                                                     
{                                                                     
4000c128:	9d e3 bf a0 	save  %sp, -96, %sp                            
{                                                                     
  Thread_Control   *executing;                                        
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
4000c12c:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
4000c130:	c2 00 61 d8 	ld  [ %g1 + 0x1d8 ], %g1	! 400155d8 <_Per_CPU_Information+0xc>
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
4000c134:	c4 06 20 50 	ld  [ %i0 + 0x50 ], %g2                        
  Thread_Control   *executing;                                        
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
4000c138:	c0 20 60 34 	clr  [ %g1 + 0x34 ]                            
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
4000c13c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c140:	02 80 00 2f 	be  4000c1fc <_CORE_mutex_Seize_interrupt_trylock+0xd4>
4000c144:	a0 10 00 18 	mov  %i0, %l0                                  
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
    the_mutex->holder     = executing;                                
    the_mutex->holder_id  = executing->Object.id;                     
4000c148:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
4000c14c:	c0 26 20 50 	clr  [ %i0 + 0x50 ]                            
    the_mutex->holder     = executing;                                
    the_mutex->holder_id  = executing->Object.id;                     
4000c150:	c4 26 20 60 	st  %g2, [ %i0 + 0x60 ]                        
    the_mutex->nest_count = 1;                                        
4000c154:	84 10 20 01 	mov  1, %g2                                    
4000c158:	c4 26 20 54 	st  %g2, [ %i0 + 0x54 ]                        
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}                                                                     
4000c15c:	c4 06 20 48 	ld  [ %i0 + 0x48 ], %g2                        
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
4000c160:	80 a0 a0 02 	cmp  %g2, 2                                    
4000c164:	02 80 00 05 	be  4000c178 <_CORE_mutex_Seize_interrupt_trylock+0x50>
4000c168:	c2 26 20 5c 	st  %g1, [ %i0 + 0x5c ]                        
4000c16c:	80 a0 a0 03 	cmp  %g2, 3                                    
4000c170:	12 80 00 07 	bne  4000c18c <_CORE_mutex_Seize_interrupt_trylock+0x64>
4000c174:	01 00 00 00 	nop                                            
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
4000c178:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
    }                                                                 
                                                                      
    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
4000c17c:	80 a0 a0 03 	cmp  %g2, 3                                    
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
4000c180:	88 00 e0 01 	add  %g3, 1, %g4                               
    }                                                                 
                                                                      
    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
4000c184:	02 80 00 03 	be  4000c190 <_CORE_mutex_Seize_interrupt_trylock+0x68>
4000c188:	c8 20 60 1c 	st  %g4, [ %g1 + 0x1c ]                        
      _ISR_Enable( *level_p );                                        
4000c18c:	30 80 00 2b 	b,a   4000c238 <_CORE_mutex_Seize_interrupt_trylock+0x110>
       */                                                             
    {                                                                 
      Priority_Control  ceiling;                                      
      Priority_Control  current;                                      
                                                                      
      ceiling = the_mutex->Attributes.priority_ceiling;               
4000c190:	c4 04 20 4c 	ld  [ %l0 + 0x4c ], %g2                        
      current = executing->current_priority;                          
4000c194:	c8 00 60 14 	ld  [ %g1 + 0x14 ], %g4                        
      if ( current == ceiling ) {                                     
4000c198:	80 a1 00 02 	cmp  %g4, %g2                                  
4000c19c:	12 80 00 03 	bne  4000c1a8 <_CORE_mutex_Seize_interrupt_trylock+0x80>
4000c1a0:	01 00 00 00 	nop                                            
        _ISR_Enable( *level_p );                                      
4000c1a4:	30 80 00 25 	b,a   4000c238 <_CORE_mutex_Seize_interrupt_trylock+0x110>
        return 0;                                                     
      }                                                               
                                                                      
      if ( current > ceiling ) {                                      
4000c1a8:	08 80 00 0f 	bleu  4000c1e4 <_CORE_mutex_Seize_interrupt_trylock+0xbc>
4000c1ac:	84 10 20 06 	mov  6, %g2                                    
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
4000c1b0:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
4000c1b4:	c4 00 63 68 	ld  [ %g1 + 0x368 ], %g2	! 40015368 <_Thread_Dispatch_disable_level>
4000c1b8:	84 00 a0 01 	inc  %g2                                       
4000c1bc:	c4 20 63 68 	st  %g2, [ %g1 + 0x368 ]                       
        _Thread_Disable_dispatch();                                   
        _ISR_Enable( *level_p );                                      
4000c1c0:	7f ff d6 e1 	call  40001d44 <sparc_enable_interrupts>       
4000c1c4:	d0 06 40 00 	ld  [ %i1 ], %o0                               
        _Thread_Change_priority(                                      
4000c1c8:	d0 04 20 5c 	ld  [ %l0 + 0x5c ], %o0                        
4000c1cc:	d2 04 20 4c 	ld  [ %l0 + 0x4c ], %o1                        
4000c1d0:	7f ff f1 56 	call  40008728 <_Thread_Change_priority>       
4000c1d4:	94 10 20 00 	clr  %o2                                       
          the_mutex->holder,                                          
          the_mutex->Attributes.priority_ceiling,                     
         false                                                        
        );                                                            
        _Thread_Enable_dispatch();                                    
4000c1d8:	7f ff f2 b8 	call  40008cb8 <_Thread_Enable_dispatch>       
4000c1dc:	b0 10 20 00 	clr  %i0                                       
4000c1e0:	30 80 00 1d 	b,a   4000c254 <_CORE_mutex_Seize_interrupt_trylock+0x12c>
        return 0;                                                     
      }                                                               
      /* if ( current < ceiling ) */ {                                
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
4000c1e4:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;                  
        the_mutex->nest_count = 0;     /* undo locking above */       
4000c1e8:	c0 24 20 54 	clr  [ %l0 + 0x54 ]                            
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
      }                                                               
      /* if ( current < ceiling ) */ {                                
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;                  
4000c1ec:	84 10 20 01 	mov  1, %g2                                    
4000c1f0:	c4 24 20 50 	st  %g2, [ %l0 + 0x50 ]                        
        the_mutex->nest_count = 0;     /* undo locking above */       
        executing->resource_count--;   /* undo locking above */       
4000c1f4:	c6 20 60 1c 	st  %g3, [ %g1 + 0x1c ]                        
        _ISR_Enable( *level_p );                                      
4000c1f8:	30 80 00 10 	b,a   4000c238 <_CORE_mutex_Seize_interrupt_trylock+0x110>
  /*                                                                  
   *  At this point, we know the mutex was not available.  If this thread
   *  is the thread that has locked the mutex, let's see if we are allowed
   *  to nest access.                                                 
   */                                                                 
  if ( _Thread_Is_executing( the_mutex->holder ) ) {                  
4000c1fc:	c4 06 20 5c 	ld  [ %i0 + 0x5c ], %g2                        
4000c200:	80 a0 80 01 	cmp  %g2, %g1                                  
4000c204:	12 80 00 14 	bne  4000c254 <_CORE_mutex_Seize_interrupt_trylock+0x12c>
4000c208:	b0 10 20 01 	mov  1, %i0                                    
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {          
4000c20c:	c2 04 20 40 	ld  [ %l0 + 0x40 ], %g1                        
4000c210:	80 a0 60 00 	cmp  %g1, 0                                    
4000c214:	22 80 00 07 	be,a   4000c230 <_CORE_mutex_Seize_interrupt_trylock+0x108>
4000c218:	c2 04 20 54 	ld  [ %l0 + 0x54 ], %g1                        
4000c21c:	80 a0 60 01 	cmp  %g1, 1                                    
4000c220:	12 80 00 0d 	bne  4000c254 <_CORE_mutex_Seize_interrupt_trylock+0x12c><== ALWAYS TAKEN
4000c224:	82 10 20 02 	mov  2, %g1                                    
      case CORE_MUTEX_NESTING_ACQUIRES:                               
        the_mutex->nest_count++;                                      
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
      case CORE_MUTEX_NESTING_IS_ERROR:                               
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
4000c228:	10 80 00 08 	b  4000c248 <_CORE_mutex_Seize_interrupt_trylock+0x120><== NOT EXECUTED
4000c22c:	c2 20 a0 34 	st  %g1, [ %g2 + 0x34 ]                        <== NOT EXECUTED
   *  to nest access.                                                 
   */                                                                 
  if ( _Thread_Is_executing( the_mutex->holder ) ) {                  
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {          
      case CORE_MUTEX_NESTING_ACQUIRES:                               
        the_mutex->nest_count++;                                      
4000c230:	82 00 60 01 	inc  %g1                                       
4000c234:	c2 24 20 54 	st  %g1, [ %l0 + 0x54 ]                        
        _ISR_Enable( *level_p );                                      
4000c238:	7f ff d6 c3 	call  40001d44 <sparc_enable_interrupts>       
4000c23c:	d0 06 40 00 	ld  [ %i1 ], %o0                               
        return 0;                                                     
4000c240:	81 c7 e0 08 	ret                                            
4000c244:	91 e8 20 00 	restore  %g0, 0, %o0                           
      case CORE_MUTEX_NESTING_IS_ERROR:                               
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
        _ISR_Enable( *level_p );                                      
4000c248:	d0 06 40 00 	ld  [ %i1 ], %o0                               <== NOT EXECUTED
4000c24c:	7f ff d6 be 	call  40001d44 <sparc_enable_interrupts>       <== NOT EXECUTED
4000c250:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4000c254:	81 c7 e0 08 	ret                                            
4000c258:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000786c <_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     
)                                                                     
{                                                                     
4000786c:	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)) ) {
40007870:	90 10 00 18 	mov  %i0, %o0                                  
40007874:	40 00 05 ec 	call  40009024 <_Thread_queue_Dequeue>         
40007878:	a0 10 00 18 	mov  %i0, %l0                                  
4000787c:	80 a2 20 00 	cmp  %o0, 0                                    
40007880:	12 80 00 0e 	bne  400078b8 <_CORE_semaphore_Surrender+0x4c> 
40007884:	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 );                                            
40007888:	7f ff e9 2b 	call  40001d34 <sparc_disable_interrupts>      
4000788c:	01 00 00 00 	nop                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
40007890:	c2 04 20 48 	ld  [ %l0 + 0x48 ], %g1                        
40007894:	c4 04 20 40 	ld  [ %l0 + 0x40 ], %g2                        
40007898:	80 a0 40 02 	cmp  %g1, %g2                                  
4000789c:	1a 80 00 05 	bcc  400078b0 <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
400078a0:	b0 10 20 04 	mov  4, %i0                                    
        the_semaphore->count += 1;                                    
400078a4:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
400078a8:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;                                    
400078ac:	c2 24 20 48 	st  %g1, [ %l0 + 0x48 ]                        
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
400078b0:	7f ff e9 25 	call  40001d44 <sparc_enable_interrupts>       
400078b4:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
400078b8:	81 c7 e0 08 	ret                                            
400078bc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
400064c0 <_Event_Seize>:                                              
  rtems_event_set  event_in,                                          
  rtems_option     option_set,                                        
  rtems_interval   ticks,                                             
  rtems_event_set *event_out                                          
)                                                                     
{                                                                     
400064c0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_event_set                   pending_events;                   
  ISR_Level                         level;                            
  RTEMS_API_Control                *api;                              
  Thread_blocking_operation_States  sync_state;                       
                                                                      
  executing = _Thread_Executing;                                      
400064c4:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400064c8:	e0 00 61 d8 	ld  [ %g1 + 0x1d8 ], %l0	! 400155d8 <_Per_CPU_Information+0xc>
  executing->Wait.return_code = RTEMS_SUCCESSFUL;                     
400064cc:	c0 24 20 34 	clr  [ %l0 + 0x34 ]                            
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
                                                                      
  _ISR_Disable( level );                                              
400064d0:	7f ff ee 19 	call  40001d34 <sparc_disable_interrupts>      
400064d4:	e4 04 21 5c 	ld  [ %l0 + 0x15c ], %l2                       
  pending_events = api->pending_events;                               
400064d8:	c2 04 80 00 	ld  [ %l2 ], %g1                               
  seized_events  = _Event_sets_Get( pending_events, event_in );       
                                                                      
  if ( !_Event_sets_Is_empty( seized_events ) &&                      
400064dc:	a2 8e 00 01 	andcc  %i0, %g1, %l1                           
400064e0:	02 80 00 0f 	be  4000651c <_Event_Seize+0x5c>               
400064e4:	80 8e 60 01 	btst  1, %i1                                   
400064e8:	80 a4 40 18 	cmp  %l1, %i0                                  
400064ec:	22 80 00 06 	be,a   40006504 <_Event_Seize+0x44>            
400064f0:	82 28 40 11 	andn  %g1, %l1, %g1                            
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
400064f4:	80 8e 60 02 	btst  2, %i1                                   
400064f8:	22 80 00 09 	be,a   4000651c <_Event_Seize+0x5c>            <== NEVER TAKEN
400064fc:	80 8e 60 01 	btst  1, %i1                                   <== NOT EXECUTED
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) );                            
40006500:	82 28 40 11 	andn  %g1, %l1, %g1                            
    api->pending_events =                                             
40006504:	c2 24 80 00 	st  %g1, [ %l2 ]                               
      _Event_sets_Clear( pending_events, seized_events );             
    _ISR_Enable( level );                                             
40006508:	7f ff ee 0f 	call  40001d44 <sparc_enable_interrupts>       
4000650c:	01 00 00 00 	nop                                            
40006510:	e2 26 c0 00 	st  %l1, [ %i3 ]                               
40006514:	81 c7 e0 08 	ret                                            
40006518:	81 e8 00 00 	restore                                        
    *event_out = seized_events;                                       
    return;                                                           
  }                                                                   
                                                                      
  if ( _Options_Is_no_wait( option_set ) ) {                          
4000651c:	22 80 00 09 	be,a   40006540 <_Event_Seize+0x80>            
40006520:	f2 24 20 30 	st  %i1, [ %l0 + 0x30 ]                        
    _ISR_Enable( level );                                             
40006524:	7f ff ee 08 	call  40001d44 <sparc_enable_interrupts>       
40006528:	01 00 00 00 	nop                                            
    executing->Wait.return_code = RTEMS_UNSATISFIED;                  
4000652c:	82 10 20 0d 	mov  0xd, %g1	! d <PROM_START+0xd>             
40006530:	c2 24 20 34 	st  %g1, [ %l0 + 0x34 ]                        
    *event_out = seized_events;                                       
40006534:	e2 26 c0 00 	st  %l1, [ %i3 ]                               
40006538:	81 c7 e0 08 	ret                                            
4000653c:	81 e8 00 00 	restore                                        
   *                                                                  
   *  NOTE: Since interrupts are disabled, this isn't that much of an 
   *        issue but better safe than sorry.                         
   */                                                                 
  executing->Wait.option            = (uint32_t) option_set;          
  executing->Wait.count             = (uint32_t) event_in;            
40006540:	f0 24 20 24 	st  %i0, [ %l0 + 0x24 ]                        
  executing->Wait.return_argument   = event_out;                      
40006544:	f6 24 20 28 	st  %i3, [ %l0 + 0x28 ]                        
                                                                      
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;     
40006548:	84 10 20 01 	mov  1, %g2                                    
4000654c:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40006550:	c4 20 61 e8 	st  %g2, [ %g1 + 0x1e8 ]	! 400155e8 <_Event_Sync_state>
                                                                      
  _ISR_Enable( level );                                               
40006554:	7f ff ed fc 	call  40001d44 <sparc_enable_interrupts>       
40006558:	01 00 00 00 	nop                                            
                                                                      
  if ( ticks ) {                                                      
4000655c:	80 a6 a0 00 	cmp  %i2, 0                                    
40006560:	02 80 00 0f 	be  4000659c <_Event_Seize+0xdc>               
40006564:	90 10 00 10 	mov  %l0, %o0                                  
    _Watchdog_Initialize(                                             
40006568:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
4000656c:	05 10 00 19 	sethi  %hi(0x40006400), %g2                    
40006570:	84 10 a3 74 	or  %g2, 0x374, %g2	! 40006774 <_Event_Timeout>
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40006574:	11 10 00 55 	sethi  %hi(0x40015400), %o0                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40006578:	c0 24 20 50 	clr  [ %l0 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
4000657c:	c4 24 20 64 	st  %g2, [ %l0 + 0x64 ]                        
  the_watchdog->id        = id;                                       
40006580:	c2 24 20 68 	st  %g1, [ %l0 + 0x68 ]                        
  the_watchdog->user_data = user_data;                                
40006584:	c0 24 20 6c 	clr  [ %l0 + 0x6c ]                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40006588:	f4 24 20 54 	st  %i2, [ %l0 + 0x54 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000658c:	90 12 20 2c 	or  %o0, 0x2c, %o0                             
40006590:	40 00 0d fb 	call  40009d7c <_Watchdog_Insert>              
40006594:	92 04 20 48 	add  %l0, 0x48, %o1                            
      NULL                                                            
    );                                                                
    _Watchdog_Insert_ticks( &executing->Timer, ticks );               
  }                                                                   
                                                                      
  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );           
40006598:	90 10 00 10 	mov  %l0, %o0                                  
4000659c:	40 00 0c 0d 	call  400095d0 <_Thread_Set_state>             
400065a0:	92 10 21 00 	mov  0x100, %o1                                
                                                                      
  _ISR_Disable( level );                                              
400065a4:	7f ff ed e4 	call  40001d34 <sparc_disable_interrupts>      
400065a8:	01 00 00 00 	nop                                            
                                                                      
  sync_state = _Event_Sync_state;                                     
400065ac:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400065b0:	f0 00 61 e8 	ld  [ %g1 + 0x1e8 ], %i0	! 400155e8 <_Event_Sync_state>
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;         
400065b4:	c0 20 61 e8 	clr  [ %g1 + 0x1e8 ]                           
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {   
400065b8:	80 a6 20 01 	cmp  %i0, 1                                    
400065bc:	12 80 00 04 	bne  400065cc <_Event_Seize+0x10c>             
400065c0:	b2 10 00 10 	mov  %l0, %i1                                  
    _ISR_Enable( level );                                             
400065c4:	7f ff ed e0 	call  40001d44 <sparc_enable_interrupts>       
400065c8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   *  An interrupt completed the thread's blocking request.           
   *  The blocking thread was satisfied by an ISR or timed out.       
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  _Thread_blocking_operation_Cancel( sync_state, executing, level );  
400065cc:	40 00 08 42 	call  400086d4 <_Thread_blocking_operation_Cancel>
400065d0:	95 e8 00 08 	restore  %g0, %o0, %o2                         
                                                                      
===============================================================================
40006634 <_Event_Surrender>:                                          
 */                                                                   
                                                                      
void _Event_Surrender(                                                
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
40006634:	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 ];               
40006638:	e2 06 21 5c 	ld  [ %i0 + 0x15c ], %l1                       
                                                                      
  option_set = (rtems_option) the_thread->Wait.option;                
4000663c:	e4 06 20 30 	ld  [ %i0 + 0x30 ], %l2                        
                                                                      
  _ISR_Disable( level );                                              
40006640:	7f ff ed bd 	call  40001d34 <sparc_disable_interrupts>      
40006644:	a0 10 00 18 	mov  %i0, %l0                                  
40006648:	b0 10 00 08 	mov  %o0, %i0                                  
  pending_events  = api->pending_events;                              
4000664c:	c4 04 40 00 	ld  [ %l1 ], %g2                               
  event_condition = (rtems_event_set) the_thread->Wait.count;         
40006650:	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 ) ) {                      
40006654:	82 88 c0 02 	andcc  %g3, %g2, %g1                           
40006658:	12 80 00 03 	bne  40006664 <_Event_Surrender+0x30>          
4000665c:	09 10 00 55 	sethi  %hi(0x40015400), %g4                    
    _ISR_Enable( level );                                             
40006660:	30 80 00 42 	b,a   40006768 <_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() &&                                       
40006664:	88 11 21 cc 	or  %g4, 0x1cc, %g4	! 400155cc <_Per_CPU_Information>
40006668:	da 01 20 08 	ld  [ %g4 + 8 ], %o5                           
4000666c:	80 a3 60 00 	cmp  %o5, 0                                    
40006670:	22 80 00 1d 	be,a   400066e4 <_Event_Surrender+0xb0>        
40006674:	c8 04 20 10 	ld  [ %l0 + 0x10 ], %g4                        
40006678:	c8 01 20 0c 	ld  [ %g4 + 0xc ], %g4                         
4000667c:	80 a4 00 04 	cmp  %l0, %g4                                  
40006680:	32 80 00 19 	bne,a   400066e4 <_Event_Surrender+0xb0>       
40006684:	c8 04 20 10 	ld  [ %l0 + 0x10 ], %g4                        
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
40006688:	09 10 00 55 	sethi  %hi(0x40015400), %g4                    
4000668c:	da 01 21 e8 	ld  [ %g4 + 0x1e8 ], %o5	! 400155e8 <_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 ) &&                          
40006690:	80 a3 60 02 	cmp  %o5, 2                                    
40006694:	02 80 00 07 	be  400066b0 <_Event_Surrender+0x7c>           <== NEVER TAKEN
40006698:	80 a0 40 03 	cmp  %g1, %g3                                  
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
4000669c:	c8 01 21 e8 	ld  [ %g4 + 0x1e8 ], %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) ||   
400066a0:	80 a1 20 01 	cmp  %g4, 1                                    
400066a4:	32 80 00 10 	bne,a   400066e4 <_Event_Surrender+0xb0>       
400066a8:	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) ) {
400066ac:	80 a0 40 03 	cmp  %g1, %g3                                  
400066b0:	02 80 00 04 	be  400066c0 <_Event_Surrender+0x8c>           
400066b4:	80 8c a0 02 	btst  2, %l2                                   
400066b8:	02 80 00 0a 	be  400066e0 <_Event_Surrender+0xac>           <== NEVER TAKEN
400066bc:	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) );                            
400066c0:	84 28 80 01 	andn  %g2, %g1, %g2                            
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
400066c4:	c4 24 40 00 	st  %g2, [ %l1 ]                               
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
400066c8:	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;                                     
400066cc:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
400066d0:	c2 20 80 00 	st  %g1, [ %g2 ]                               
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;        
400066d4:	84 10 20 03 	mov  3, %g2                                    
400066d8:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400066dc:	c4 20 61 e8 	st  %g2, [ %g1 + 0x1e8 ]	! 400155e8 <_Event_Sync_state>
    }                                                                 
    _ISR_Enable( level );                                             
400066e0:	30 80 00 22 	b,a   40006768 <_Event_Surrender+0x134>        
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
400066e4:	80 89 21 00 	btst  0x100, %g4                               
400066e8:	02 80 00 20 	be  40006768 <_Event_Surrender+0x134>          
400066ec:	80 a0 40 03 	cmp  %g1, %g3                                  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
400066f0:	02 80 00 04 	be  40006700 <_Event_Surrender+0xcc>           
400066f4:	80 8c a0 02 	btst  2, %l2                                   
400066f8:	02 80 00 1c 	be  40006768 <_Event_Surrender+0x134>          <== NEVER TAKEN
400066fc:	01 00 00 00 	nop                                            
40006700:	84 28 80 01 	andn  %g2, %g1, %g2                            
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
40006704:	c4 24 40 00 	st  %g2, [ %l1 ]                               
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006708:	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;                                     
4000670c:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006710:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _ISR_Flash( level );                                            
40006714:	7f ff ed 8c 	call  40001d44 <sparc_enable_interrupts>       
40006718:	90 10 00 18 	mov  %i0, %o0                                  
4000671c:	7f ff ed 86 	call  40001d34 <sparc_disable_interrupts>      
40006720:	01 00 00 00 	nop                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
40006724:	c2 04 20 50 	ld  [ %l0 + 0x50 ], %g1                        
40006728:	80 a0 60 02 	cmp  %g1, 2                                    
4000672c:	02 80 00 06 	be  40006744 <_Event_Surrender+0x110>          
40006730:	82 10 20 03 	mov  3, %g1                                    
        _ISR_Enable( level );                                         
40006734:	7f ff ed 84 	call  40001d44 <sparc_enable_interrupts>       
40006738:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
4000673c:	10 80 00 08 	b  4000675c <_Event_Surrender+0x128>           
40006740:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
40006744:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
40006748:	7f ff ed 7f 	call  40001d44 <sparc_enable_interrupts>       
4000674c:	90 10 00 18 	mov  %i0, %o0                                  
        (void) _Watchdog_Remove( &the_thread->Timer );                
40006750:	40 00 0d e5 	call  40009ee4 <_Watchdog_Remove>              
40006754:	90 04 20 48 	add  %l0, 0x48, %o0                            
40006758:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
4000675c:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1003fff8 <RAM_SIZE+0xfc3fff8>
40006760:	40 00 08 6b 	call  4000890c <_Thread_Clear_state>           
40006764:	91 e8 00 10 	restore  %g0, %l0, %o0                         
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
40006768:	7f ff ed 77 	call  40001d44 <sparc_enable_interrupts>       
4000676c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40006774 <_Event_Timeout>:                                            
                                                                      
void _Event_Timeout(                                                  
  Objects_Id  id,                                                     
  void       *ignored                                                 
)                                                                     
{                                                                     
40006774:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
  ISR_Level          level;                                           
                                                                      
  the_thread = _Thread_Get( id, &location );                          
40006778:	90 10 00 18 	mov  %i0, %o0                                  
4000677c:	40 00 09 5c 	call  40008cec <_Thread_Get>                   
40006780:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40006784:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006788:	80 a0 60 00 	cmp  %g1, 0                                    
4000678c:	12 80 00 1c 	bne  400067fc <_Event_Timeout+0x88>            <== NEVER TAKEN
40006790:	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 );                                          
40006794:	7f ff ed 68 	call  40001d34 <sparc_disable_interrupts>      
40006798:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
4000679c:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
400067a0:	c2 00 61 d8 	ld  [ %g1 + 0x1d8 ], %g1	! 400155d8 <_Per_CPU_Information+0xc>
400067a4:	80 a4 00 01 	cmp  %l0, %g1                                  
400067a8:	12 80 00 09 	bne  400067cc <_Event_Timeout+0x58>            
400067ac:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
          if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
400067b0:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400067b4:	c4 00 61 e8 	ld  [ %g1 + 0x1e8 ], %g2	! 400155e8 <_Event_Sync_state>
400067b8:	80 a0 a0 01 	cmp  %g2, 1                                    
400067bc:	32 80 00 05 	bne,a   400067d0 <_Event_Timeout+0x5c>         
400067c0:	82 10 20 06 	mov  6, %g1                                    
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
400067c4:	84 10 20 02 	mov  2, %g2                                    
400067c8:	c4 20 61 e8 	st  %g2, [ %g1 + 0x1e8 ]                       
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
400067cc:	82 10 20 06 	mov  6, %g1                                    
400067d0:	c2 24 20 34 	st  %g1, [ %l0 + 0x34 ]                        
      _ISR_Enable( level );                                           
400067d4:	7f ff ed 5c 	call  40001d44 <sparc_enable_interrupts>       
400067d8:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
400067dc:	90 10 00 10 	mov  %l0, %o0                                  
400067e0:	13 04 00 ff 	sethi  %hi(0x1003fc00), %o1                    
400067e4:	40 00 08 4a 	call  4000890c <_Thread_Clear_state>           
400067e8:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1003fff8 <RAM_SIZE+0xfc3fff8>
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
400067ec:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
400067f0:	c4 00 63 68 	ld  [ %g1 + 0x368 ], %g2	! 40015368 <_Thread_Dispatch_disable_level>
400067f4:	84 00 bf ff 	add  %g2, -1, %g2                              
400067f8:	c4 20 63 68 	st  %g2, [ %g1 + 0x368 ]                       
400067fc:	81 c7 e0 08 	ret                                            
40006800:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000c2d8 <_Heap_Allocate_aligned_with_boundary>:                      
  Heap_Control *heap,                                                 
  uintptr_t alloc_size,                                               
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
4000c2d8:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000c2dc:	a0 10 00 18 	mov  %i0, %l0                                  
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000c2e0:	e4 06 20 08 	ld  [ %i0 + 8 ], %l2                           
)                                                                     
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );    
  Heap_Block *block = _Heap_Free_list_first( heap );                  
  uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
4000c2e4:	ac 06 60 04 	add  %i1, 4, %l6                               
    - HEAP_BLOCK_SIZE_OFFSET;                                         
  uintptr_t const page_size = heap->page_size;                        
4000c2e8:	e8 06 20 10 	ld  [ %i0 + 0x10 ], %l4                        
  uintptr_t alloc_begin = 0;                                          
  uint32_t search_count = 0;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
4000c2ec:	80 a5 80 19 	cmp  %l6, %i1                                  
4000c2f0:	0a 80 00 67 	bcs  4000c48c <_Heap_Allocate_aligned_with_boundary+0x1b4>
4000c2f4:	b0 10 20 00 	clr  %i0                                       
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
4000c2f8:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c2fc:	02 80 00 08 	be  4000c31c <_Heap_Allocate_aligned_with_boundary+0x44>
4000c300:	82 05 20 07 	add  %l4, 7, %g1                               
    if ( boundary < alloc_size ) {                                    
4000c304:	80 a6 c0 19 	cmp  %i3, %i1                                  
4000c308:	0a 80 00 61 	bcs  4000c48c <_Heap_Allocate_aligned_with_boundary+0x1b4>
4000c30c:	80 a6 a0 00 	cmp  %i2, 0                                    
      return NULL;                                                    
    }                                                                 
                                                                      
    if ( alignment == 0 ) {                                           
4000c310:	22 80 00 03 	be,a   4000c31c <_Heap_Allocate_aligned_with_boundary+0x44>
4000c314:	b4 10 00 14 	mov  %l4, %i2                                  
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
4000c318:	82 05 20 07 	add  %l4, 7, %g1                               
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;           
4000c31c:	b8 10 20 04 	mov  4, %i4                                    
    if ( boundary < alloc_size ) {                                    
      return NULL;                                                    
    }                                                                 
                                                                      
    if ( alignment == 0 ) {                                           
      alignment = page_size;                                          
4000c320:	a2 10 20 00 	clr  %l1                                       
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
4000c324:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;           
4000c328:	b8 27 00 19 	sub  %i4, %i1, %i4                             
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000c32c:	10 80 00 50 	b  4000c46c <_Heap_Allocate_aligned_with_boundary+0x194>
4000c330:	ba 10 3f f8 	mov  -8, %i5                                   
    /*                                                                
     * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
     * field.  Thus the value is about one unit larger than the real block
     * size.  The greater than operator takes this into account.      
     */                                                               
    if ( block->size_and_flag > block_size_floor ) {                  
4000c334:	80 a6 00 16 	cmp  %i0, %l6                                  
4000c338:	08 80 00 4c 	bleu  4000c468 <_Heap_Allocate_aligned_with_boundary+0x190>
4000c33c:	a2 04 60 01 	inc  %l1                                       
      if ( alignment == 0 ) {                                         
4000c340:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c344:	12 80 00 04 	bne  4000c354 <_Heap_Allocate_aligned_with_boundary+0x7c>
4000c348:	aa 04 a0 08 	add  %l2, 8, %l5                               
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(             
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;                  
4000c34c:	10 80 00 3a 	b  4000c434 <_Heap_Allocate_aligned_with_boundary+0x15c>
4000c350:	b0 10 00 15 	mov  %l5, %i0                                  
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
4000c354:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000c358:	ee 04 20 14 	ld  [ %l0 + 0x14 ], %l7                        
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000c35c:	b0 0e 3f fe 	and  %i0, -2, %i0                              
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
4000c360:	a6 20 40 17 	sub  %g1, %l7, %l3                             
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
                                                                      
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
4000c364:	b0 04 80 18 	add  %l2, %i0, %i0                             
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000c368:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
4000c36c:	a6 04 c0 18 	add  %l3, %i0, %l3                             
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;           
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
4000c370:	b0 07 00 18 	add  %i4, %i0, %i0                             
4000c374:	40 00 16 55 	call  40011cc8 <.urem>                         
4000c378:	90 10 00 18 	mov  %i0, %o0                                  
4000c37c:	b0 26 00 08 	sub  %i0, %o0, %i0                             
                                                                      
  alloc_begin = _Heap_Align_down( alloc_begin, alignment );           
                                                                      
  /* Ensure that the we have a valid new block at the end */          
  if ( alloc_begin > alloc_begin_ceiling ) {                          
4000c380:	80 a6 00 13 	cmp  %i0, %l3                                  
4000c384:	08 80 00 07 	bleu  4000c3a0 <_Heap_Allocate_aligned_with_boundary+0xc8>
4000c388:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c38c:	90 10 00 13 	mov  %l3, %o0                                  
4000c390:	40 00 16 4e 	call  40011cc8 <.urem>                         
4000c394:	92 10 00 1a 	mov  %i2, %o1                                  
4000c398:	b0 24 c0 08 	sub  %l3, %o0, %i0                             
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
4000c39c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c3a0:	02 80 00 18 	be  4000c400 <_Heap_Allocate_aligned_with_boundary+0x128>
4000c3a4:	80 a6 00 15 	cmp  %i0, %l5                                  
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
4000c3a8:	82 05 40 19 	add  %l5, %i1, %g1                             
  /* Ensure that the we have a valid new block at the end */          
  if ( alloc_begin > alloc_begin_ceiling ) {                          
    alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); 
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
4000c3ac:	a6 06 00 19 	add  %i0, %i1, %l3                             
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
4000c3b0:	10 80 00 0a 	b  4000c3d8 <_Heap_Allocate_aligned_with_boundary+0x100>
4000c3b4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
      if ( boundary_line < boundary_floor ) {                         
4000c3b8:	80 a2 00 01 	cmp  %o0, %g1                                  
4000c3bc:	0a 80 00 2b 	bcs  4000c468 <_Heap_Allocate_aligned_with_boundary+0x190>
4000c3c0:	b0 22 00 19 	sub  %o0, %i1, %i0                             
4000c3c4:	92 10 00 1a 	mov  %i2, %o1                                  
4000c3c8:	40 00 16 40 	call  40011cc8 <.urem>                         
4000c3cc:	90 10 00 18 	mov  %i0, %o0                                  
4000c3d0:	b0 26 00 08 	sub  %i0, %o0, %i0                             
        return 0;                                                     
      }                                                               
      alloc_begin = boundary_line - alloc_size;                       
      alloc_begin = _Heap_Align_down( alloc_begin, alignment );       
      alloc_end = alloc_begin + alloc_size;                           
4000c3d4:	a6 06 00 19 	add  %i0, %i1, %l3                             
4000c3d8:	90 10 00 13 	mov  %l3, %o0                                  
4000c3dc:	40 00 16 3b 	call  40011cc8 <.urem>                         
4000c3e0:	92 10 00 1b 	mov  %i3, %o1                                  
4000c3e4:	90 24 c0 08 	sub  %l3, %o0, %o0                             
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
4000c3e8:	80 a2 00 13 	cmp  %o0, %l3                                  
4000c3ec:	1a 80 00 04 	bcc  4000c3fc <_Heap_Allocate_aligned_with_boundary+0x124>
4000c3f0:	80 a6 00 08 	cmp  %i0, %o0                                  
4000c3f4:	0a bf ff f1 	bcs  4000c3b8 <_Heap_Allocate_aligned_with_boundary+0xe0>
4000c3f8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
      boundary_line = _Heap_Align_down( alloc_end, boundary );        
    }                                                                 
  }                                                                   
                                                                      
  /* Ensure that the we have a valid new block at the beginning */    
  if ( alloc_begin >= alloc_begin_floor ) {                           
4000c3fc:	80 a6 00 15 	cmp  %i0, %l5                                  
4000c400:	2a 80 00 1b 	bcs,a   4000c46c <_Heap_Allocate_aligned_with_boundary+0x194>
4000c404:	e4 04 a0 08 	ld  [ %l2 + 8 ], %l2                           
4000c408:	a6 27 40 12 	sub  %i5, %l2, %l3                             
4000c40c:	90 10 00 18 	mov  %i0, %o0                                  
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
4000c410:	a6 04 c0 18 	add  %l3, %i0, %l3                             
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000c414:	40 00 16 2d 	call  40011cc8 <.urem>                         
4000c418:	92 10 00 14 	mov  %l4, %o1                                  
    uintptr_t const alloc_block_begin =                               
      (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
    uintptr_t const free_size = alloc_block_begin - block_begin;      
                                                                      
    if ( free_size >= min_block_size || free_size == 0 ) {            
4000c41c:	90 a4 c0 08 	subcc  %l3, %o0, %o0                           
4000c420:	02 80 00 06 	be  4000c438 <_Heap_Allocate_aligned_with_boundary+0x160>
4000c424:	80 a6 20 00 	cmp  %i0, 0                                    
4000c428:	80 a2 00 17 	cmp  %o0, %l7                                  
4000c42c:	2a 80 00 10 	bcs,a   4000c46c <_Heap_Allocate_aligned_with_boundary+0x194>
4000c430:	e4 04 a0 08 	ld  [ %l2 + 8 ], %l2                           
          boundary                                                    
        );                                                            
      }                                                               
    }                                                                 
                                                                      
    if ( alloc_begin != 0 ) {                                         
4000c434:	80 a6 20 00 	cmp  %i0, 0                                    
4000c438:	22 80 00 0d 	be,a   4000c46c <_Heap_Allocate_aligned_with_boundary+0x194><== NEVER TAKEN
4000c43c:	e4 04 a0 08 	ld  [ %l2 + 8 ], %l2                           <== NOT EXECUTED
    block = block->next;                                              
  }                                                                   
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    stats->searches += search_count;                                  
4000c440:	c2 04 20 4c 	ld  [ %l0 + 0x4c ], %g1                        
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000c444:	90 10 00 10 	mov  %l0, %o0                                  
    block = block->next;                                              
  }                                                                   
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    stats->searches += search_count;                                  
4000c448:	82 00 40 11 	add  %g1, %l1, %g1                             
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000c44c:	92 10 00 12 	mov  %l2, %o1                                  
    block = block->next;                                              
  }                                                                   
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    stats->searches += search_count;                                  
4000c450:	c2 24 20 4c 	st  %g1, [ %l0 + 0x4c ]                        
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000c454:	94 10 00 18 	mov  %i0, %o2                                  
4000c458:	7f ff ee 16 	call  40007cb0 <_Heap_Block_allocate>          
4000c45c:	96 10 00 19 	mov  %i1, %o3                                  
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000c460:	10 80 00 08 	b  4000c480 <_Heap_Allocate_aligned_with_boundary+0x1a8>
4000c464:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
                                                                      
    if ( alloc_begin != 0 ) {                                         
      break;                                                          
    }                                                                 
                                                                      
    block = block->next;                                              
4000c468:	e4 04 a0 08 	ld  [ %l2 + 8 ], %l2                           
    if ( alignment == 0 ) {                                           
      alignment = page_size;                                          
    }                                                                 
  }                                                                   
                                                                      
  while ( block != free_list_tail ) {                                 
4000c46c:	80 a4 80 10 	cmp  %l2, %l0                                  
4000c470:	32 bf ff b1 	bne,a   4000c334 <_Heap_Allocate_aligned_with_boundary+0x5c>
4000c474:	f0 04 a0 04 	ld  [ %l2 + 4 ], %i0                           
4000c478:	b0 10 20 00 	clr  %i0                                       
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000c47c:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
4000c480:	80 a0 40 11 	cmp  %g1, %l1                                  
4000c484:	2a 80 00 02 	bcs,a   4000c48c <_Heap_Allocate_aligned_with_boundary+0x1b4>
4000c488:	e2 24 20 44 	st  %l1, [ %l0 + 0x44 ]                        
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000c48c:	81 c7 e0 08 	ret                                            
4000c490:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000c784 <_Heap_Extend>:                                              
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
4000c784:	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;                              
4000c788:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  Heap_Block *extend_last_block = NULL;                               
4000c78c:	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                                        
)                                                                     
{                                                                     
4000c790:	a0 10 00 18 	mov  %i0, %l0                                  
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const first_block = heap->first_block;                  
4000c794:	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;                        
4000c798:	e6 06 20 10 	ld  [ %i0 + 0x10 ], %l3                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000c79c:	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;
4000c7a0:	a2 06 40 1a 	add  %i1, %i2, %l1                             
  uintptr_t const free_size = stats->free_size;                       
4000c7a4:	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                                        
)                                                                     
{                                                                     
4000c7a8:	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 ) {                        
4000c7ac:	80 a4 40 19 	cmp  %l1, %i1                                  
4000c7b0:	0a 80 00 9f 	bcs  4000ca2c <_Heap_Extend+0x2a8>             
4000c7b4:	b0 10 20 00 	clr  %i0                                       
    return false;                                                     
  }                                                                   
                                                                      
  extend_area_ok = _Heap_Get_first_and_last_block(                    
4000c7b8:	90 10 00 19 	mov  %i1, %o0                                  
4000c7bc:	94 10 00 13 	mov  %l3, %o2                                  
4000c7c0:	98 07 bf fc 	add  %fp, -4, %o4                              
4000c7c4:	7f ff ed 5c 	call  40007d34 <_Heap_Get_first_and_last_block>
4000c7c8:	9a 07 bf f8 	add  %fp, -8, %o5                              
    page_size,                                                        
    min_block_size,                                                   
    &extend_first_block,                                              
    &extend_last_block                                                
  );                                                                  
  if (!extend_area_ok ) {                                             
4000c7cc:	80 8a 20 ff 	btst  0xff, %o0                                
4000c7d0:	02 80 00 97 	be  4000ca2c <_Heap_Extend+0x2a8>              
4000c7d4:	aa 10 00 12 	mov  %l2, %l5                                  
4000c7d8:	ba 10 20 00 	clr  %i5                                       
4000c7dc:	b8 10 20 00 	clr  %i4                                       
4000c7e0:	b0 10 20 00 	clr  %i0                                       
4000c7e4:	ae 10 20 00 	clr  %l7                                       
4000c7e8:	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 (                                                              
4000c7ec:	80 a0 40 11 	cmp  %g1, %l1                                  
4000c7f0:	1a 80 00 05 	bcc  4000c804 <_Heap_Extend+0x80>              
4000c7f4:	ec 05 40 00 	ld  [ %l5 ], %l6                               
4000c7f8:	80 a6 40 16 	cmp  %i1, %l6                                  
4000c7fc:	2a 80 00 8c 	bcs,a   4000ca2c <_Heap_Extend+0x2a8>          
4000c800:	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 ) {                        
4000c804:	80 a4 40 01 	cmp  %l1, %g1                                  
4000c808:	02 80 00 06 	be  4000c820 <_Heap_Extend+0x9c>               
4000c80c:	80 a4 40 16 	cmp  %l1, %l6                                  
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
4000c810:	2a 80 00 05 	bcs,a   4000c824 <_Heap_Extend+0xa0>           
4000c814:	b8 10 00 15 	mov  %l5, %i4                                  
4000c818:	10 80 00 04 	b  4000c828 <_Heap_Extend+0xa4>                
4000c81c:	90 10 00 16 	mov  %l6, %o0                                  
4000c820:	ae 10 00 15 	mov  %l5, %l7                                  
4000c824:	90 10 00 16 	mov  %l6, %o0                                  
4000c828:	40 00 16 62 	call  400121b0 <.urem>                         
4000c82c:	92 10 00 13 	mov  %l3, %o1                                  
4000c830:	b4 05 bf f8 	add  %l6, -8, %i2                              
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
4000c834:	80 a5 80 19 	cmp  %l6, %i1                                  
4000c838:	12 80 00 05 	bne  4000c84c <_Heap_Extend+0xc8>              
4000c83c:	90 26 80 08 	sub  %i2, %o0, %o0                             
      start_block->prev_size = extend_area_end;                       
4000c840:	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 )   
4000c844:	10 80 00 04 	b  4000c854 <_Heap_Extend+0xd0>                
4000c848:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
      merge_above_block = end_block;                                  
    } else if ( sub_area_end < extend_area_begin ) {                  
4000c84c:	2a 80 00 02 	bcs,a   4000c854 <_Heap_Extend+0xd0>           
4000c850:	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;                
4000c854:	ea 02 20 04 	ld  [ %o0 + 4 ], %l5                           
4000c858:	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);                 
4000c85c:	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 );                             
4000c860:	80 a5 40 12 	cmp  %l5, %l2                                  
4000c864:	12 bf ff e2 	bne  4000c7ec <_Heap_Extend+0x68>              
4000c868:	82 10 00 15 	mov  %l5, %g1                                  
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
4000c86c:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
4000c870:	80 a6 40 01 	cmp  %i1, %g1                                  
4000c874:	3a 80 00 04 	bcc,a   4000c884 <_Heap_Extend+0x100>          
4000c878:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
    heap->area_begin = extend_area_begin;                             
4000c87c:	10 80 00 05 	b  4000c890 <_Heap_Extend+0x10c>               
4000c880:	f2 24 20 18 	st  %i1, [ %l0 + 0x18 ]                        
  } else if ( heap->area_end < extend_area_end ) {                    
4000c884:	80 a0 40 11 	cmp  %g1, %l1                                  
4000c888:	2a 80 00 02 	bcs,a   4000c890 <_Heap_Extend+0x10c>          
4000c88c:	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;   
4000c890:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
4000c894:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
4000c898:	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 =                                           
4000c89c:	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;                   
4000c8a0:	88 10 e0 01 	or  %g3, 1, %g4                                
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
4000c8a4:	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 =                                 
4000c8a8:	c8 20 a0 04 	st  %g4, [ %g2 + 4 ]                           
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000c8ac:	c6 04 20 20 	ld  [ %l0 + 0x20 ], %g3                        
4000c8b0:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000c8b4:	08 80 00 04 	bleu  4000c8c4 <_Heap_Extend+0x140>            
4000c8b8:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
    heap->first_block = extend_first_block;                           
4000c8bc:	10 80 00 06 	b  4000c8d4 <_Heap_Extend+0x150>               
4000c8c0:	c4 24 20 20 	st  %g2, [ %l0 + 0x20 ]                        
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4000c8c4:	c4 04 20 24 	ld  [ %l0 + 0x24 ], %g2                        
4000c8c8:	80 a0 80 01 	cmp  %g2, %g1                                  
4000c8cc:	2a 80 00 02 	bcs,a   4000c8d4 <_Heap_Extend+0x150>          
4000c8d0:	c2 24 20 24 	st  %g1, [ %l0 + 0x24 ]                        
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
4000c8d4:	80 a5 e0 00 	cmp  %l7, 0                                    
4000c8d8:	02 80 00 14 	be  4000c928 <_Heap_Extend+0x1a4>              
4000c8dc:	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;                        
4000c8e0:	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;                            
4000c8e4:	92 10 00 12 	mov  %l2, %o1                                  
4000c8e8:	40 00 16 32 	call  400121b0 <.urem>                         
4000c8ec:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( remainder != 0 ) {                                             
4000c8f0:	80 a2 20 00 	cmp  %o0, 0                                    
4000c8f4:	02 80 00 04 	be  4000c904 <_Heap_Extend+0x180>              <== ALWAYS TAKEN
4000c8f8:	c2 05 c0 00 	ld  [ %l7 ], %g1                               
    return value - remainder + alignment;                             
4000c8fc:	b2 06 40 12 	add  %i1, %l2, %i1                             <== NOT EXECUTED
4000c900:	b2 26 40 08 	sub  %i1, %o0, %i1                             <== NOT EXECUTED
  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 =                             
4000c904:	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;                
4000c908:	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 =                              
4000c90c:	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;
4000c910:	82 10 60 01 	or  %g1, 1, %g1                                
                                                                      
  _Heap_Free_block( heap, new_first_block );                          
4000c914:	90 10 00 10 	mov  %l0, %o0                                  
4000c918:	7f ff ff 90 	call  4000c758 <_Heap_Free_block>              
4000c91c:	c2 22 60 04 	st  %g1, [ %o1 + 4 ]                           
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
4000c920:	10 80 00 09 	b  4000c944 <_Heap_Extend+0x1c0>               
4000c924:	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 ) {                            
4000c928:	80 a7 20 00 	cmp  %i4, 0                                    
4000c92c:	02 80 00 05 	be  4000c940 <_Heap_Extend+0x1bc>              
4000c930:	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;           
4000c934:	b8 27 00 01 	sub  %i4, %g1, %i4                             
4000c938:	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 =                                         
4000c93c:	f8 20 60 04 	st  %i4, [ %g1 + 4 ]                           
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
4000c940:	80 a6 20 00 	cmp  %i0, 0                                    
4000c944:	02 80 00 15 	be  4000c998 <_Heap_Extend+0x214>              
4000c948:	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);                                 
4000c94c:	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(             
4000c950:	a2 24 40 18 	sub  %l1, %i0, %l1                             
4000c954:	40 00 16 17 	call  400121b0 <.urem>                         
4000c958:	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)                 
4000c95c:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
4000c960:	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 =                                     
4000c964:	82 04 40 18 	add  %l1, %i0, %g1                             
    (last_block->size_and_flag - last_block_new_size)                 
4000c968:	84 20 80 11 	sub  %g2, %l1, %g2                             
      | HEAP_PREV_BLOCK_USED;                                         
4000c96c:	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 =                                     
4000c970:	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;       
4000c974:	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 );                               
4000c978:	90 10 00 10 	mov  %l0, %o0                                  
4000c97c:	82 08 60 01 	and  %g1, 1, %g1                               
4000c980:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
  block->size_and_flag = size | flag;                                 
4000c984:	a2 14 40 01 	or  %l1, %g1, %l1                              
4000c988:	7f ff ff 74 	call  4000c758 <_Heap_Free_block>              
4000c98c:	e2 26 20 04 	st  %l1, [ %i0 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000c990:	10 80 00 0f 	b  4000c9cc <_Heap_Extend+0x248>               
4000c994:	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 ) {                            
4000c998:	80 a7 60 00 	cmp  %i5, 0                                    
4000c99c:	02 80 00 0b 	be  4000c9c8 <_Heap_Extend+0x244>              
4000c9a0:	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;       
4000c9a4:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
    _Heap_Link_above(                                                 
4000c9a8:	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 );       
4000c9ac:	86 20 c0 1d 	sub  %g3, %i5, %g3                             
4000c9b0:	84 08 a0 01 	and  %g2, 1, %g2                               
                                                                      
  block->size_and_flag = size | flag;                                 
4000c9b4:	84 10 c0 02 	or  %g3, %g2, %g2                              
4000c9b8:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
                                                                      
  last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                  
4000c9bc:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000c9c0:	84 10 a0 01 	or  %g2, 1, %g2                                
4000c9c4:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000c9c8:	80 a6 20 00 	cmp  %i0, 0                                    
4000c9cc:	32 80 00 09 	bne,a   4000c9f0 <_Heap_Extend+0x26c>          
4000c9d0:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
4000c9d4:	80 a5 e0 00 	cmp  %l7, 0                                    
4000c9d8:	32 80 00 06 	bne,a   4000c9f0 <_Heap_Extend+0x26c>          
4000c9dc:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
    _Heap_Free_block( heap, extend_first_block );                     
4000c9e0:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
4000c9e4:	7f ff ff 5d 	call  4000c758 <_Heap_Free_block>              
4000c9e8:	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      
4000c9ec:	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(                                               
4000c9f0:	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;       
4000c9f4:	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(                                               
4000c9f8:	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;       
4000c9fc:	84 08 a0 01 	and  %g2, 1, %g2                               
                                                                      
  block->size_and_flag = size | flag;                                 
4000ca00:	84 10 c0 02 	or  %g3, %g2, %g2                              
4000ca04:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
4000ca08:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
  stats->size += extended_size;                                       
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
4000ca0c:	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;                       
4000ca10:	a8 20 40 14 	sub  %g1, %l4, %l4                             
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
4000ca14:	c2 04 20 2c 	ld  [ %l0 + 0x2c ], %g1                        
                                                                      
  if ( extended_size_ptr != NULL )                                    
4000ca18:	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;                                       
4000ca1c:	82 00 40 14 	add  %g1, %l4, %g1                             
                                                                      
  if ( extended_size_ptr != NULL )                                    
4000ca20:	02 80 00 03 	be  4000ca2c <_Heap_Extend+0x2a8>              <== NEVER TAKEN
4000ca24:	c2 24 20 2c 	st  %g1, [ %l0 + 0x2c ]                        
    *extended_size_ptr = extended_size;                               
4000ca28:	e8 26 c0 00 	st  %l4, [ %i3 ]                               
4000ca2c:	81 c7 e0 08 	ret                                            
4000ca30:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000c494 <_Heap_Free>:                                                
#include <rtems/system.h>                                             
#include <rtems/score/sysstate.h>                                     
#include <rtems/score/heap.h>                                         
                                                                      
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )          
{                                                                     
4000c494:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000c498:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
4000c49c:	40 00 16 0b 	call  40011cc8 <.urem>                         
4000c4a0:	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           
4000c4a4:	d8 06 20 20 	ld  [ %i0 + 0x20 ], %o4                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000c4a8:	a2 06 7f f8 	add  %i1, -8, %l1                              
4000c4ac:	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);                                        
4000c4b0:	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;             
4000c4b4:	80 a2 00 0c 	cmp  %o0, %o4                                  
4000c4b8:	0a 80 00 05 	bcs  4000c4cc <_Heap_Free+0x38>                
4000c4bc:	82 10 20 00 	clr  %g1                                       
4000c4c0:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000c4c4:	80 a0 40 08 	cmp  %g1, %o0                                  
4000c4c8:	82 60 3f ff 	subx  %g0, -1, %g1                             
  Heap_Block *next_block = NULL;                                      
  uintptr_t block_size = 0;                                           
  uintptr_t next_block_size = 0;                                      
  bool next_is_free = false;                                          
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, block ) ) {                     
4000c4cc:	80 a0 60 00 	cmp  %g1, 0                                    
4000c4d0:	02 80 00 6a 	be  4000c678 <_Heap_Free+0x1e4>                
4000c4d4:	b0 10 20 00 	clr  %i0                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000c4d8:	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;                
4000c4dc:	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);                 
4000c4e0:	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;             
4000c4e4:	80 a0 40 0c 	cmp  %g1, %o4                                  
4000c4e8:	0a 80 00 05 	bcs  4000c4fc <_Heap_Free+0x68>                <== NEVER TAKEN
4000c4ec:	86 10 20 00 	clr  %g3                                       
4000c4f0:	c6 04 20 24 	ld  [ %l0 + 0x24 ], %g3                        
4000c4f4:	80 a0 c0 01 	cmp  %g3, %g1                                  
4000c4f8:	86 60 3f ff 	subx  %g0, -1, %g3                             
  }                                                                   
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {                
4000c4fc:	80 a0 e0 00 	cmp  %g3, 0                                    
4000c500:	02 80 00 5e 	be  4000c678 <_Heap_Free+0x1e4>                <== NEVER TAKEN
4000c504:	b0 10 20 00 	clr  %i0                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000c508:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
  if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {                
    _HAssert( false );                                                
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
4000c50c:	80 89 20 01 	btst  1, %g4                                   
4000c510:	02 80 00 5a 	be  4000c678 <_Heap_Free+0x1e4>                <== NEVER TAKEN
4000c514:	88 09 3f fe 	and  %g4, -2, %g4                              
    _HAssert( false );                                                
    return false;                                                     
  }                                                                   
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
4000c518:	d2 04 20 24 	ld  [ %l0 + 0x24 ], %o1                        
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000c51c:	80 a0 40 09 	cmp  %g1, %o1                                  
4000c520:	02 80 00 07 	be  4000c53c <_Heap_Free+0xa8>                 
4000c524:	96 10 20 00 	clr  %o3                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000c528:	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;                 
4000c52c:	c6 00 e0 04 	ld  [ %g3 + 4 ], %g3                           
4000c530:	86 08 e0 01 	and  %g3, 1, %g3                               
    return false;                                                     
  }                                                                   
                                                                      
  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 ));
4000c534:	80 a0 00 03 	cmp  %g0, %g3                                  
4000c538:	96 60 3f ff 	subx  %g0, -1, %o3                             
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
4000c53c:	80 8b 60 01 	btst  1, %o5                                   
4000c540:	12 80 00 26 	bne  4000c5d8 <_Heap_Free+0x144>               
4000c544:	80 8a e0 ff 	btst  0xff, %o3                                
    uintptr_t const prev_size = block->prev_size;                     
4000c548:	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);                 
4000c54c:	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;             
4000c550:	80 a0 c0 0c 	cmp  %g3, %o4                                  
4000c554:	0a 80 00 04 	bcs  4000c564 <_Heap_Free+0xd0>                <== NEVER TAKEN
4000c558:	94 10 20 00 	clr  %o2                                       
4000c55c:	80 a2 40 03 	cmp  %o1, %g3                                  
4000c560:	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 ) ) {              
4000c564:	80 a2 a0 00 	cmp  %o2, 0                                    
4000c568:	02 80 00 44 	be  4000c678 <_Heap_Free+0x1e4>                <== NEVER TAKEN
4000c56c:	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;                 
4000c570:	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) ) {                        
4000c574:	80 8b 20 01 	btst  1, %o4                                   
4000c578:	02 80 00 40 	be  4000c678 <_Heap_Free+0x1e4>                <== NEVER TAKEN
4000c57c:	80 8a e0 ff 	btst  0xff, %o3                                
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
4000c580:	22 80 00 0f 	be,a   4000c5bc <_Heap_Free+0x128>             
4000c584:	9a 00 80 0d 	add  %g2, %o5, %o5                             
      uintptr_t const size = block_size + prev_size + next_block_size;
4000c588:	88 00 80 04 	add  %g2, %g4, %g4                             
4000c58c:	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;                                     
4000c590:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
  Heap_Block *prev = block->prev;                                     
4000c594:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
                                                                      
  prev->next = next;                                                  
4000c598:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
  next->prev = prev;                                                  
4000c59c:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
4000c5a0:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
4000c5a4:	82 00 7f ff 	add  %g1, -1, %g1                              
4000c5a8:	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;                                   
4000c5ac:	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;        
4000c5b0:	82 13 60 01 	or  %o5, 1, %g1                                
4000c5b4:	10 80 00 27 	b  4000c650 <_Heap_Free+0x1bc>                 
4000c5b8:	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;        
4000c5bc:	88 13 60 01 	or  %o5, 1, %g4                                
4000c5c0:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
4000c5c4:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
      next_block->prev_size = size;                                   
4000c5c8:	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;             
4000c5cc:	86 08 ff fe 	and  %g3, -2, %g3                              
4000c5d0:	10 80 00 20 	b  4000c650 <_Heap_Free+0x1bc>                 
4000c5d4:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
4000c5d8:	22 80 00 0d 	be,a   4000c60c <_Heap_Free+0x178>             
4000c5dc:	c6 04 20 08 	ld  [ %l0 + 8 ], %g3                           
    uintptr_t const size = block_size + next_block_size;              
4000c5e0:	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;                                 
4000c5e4:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
  Heap_Block *prev = old_block->prev;                                 
4000c5e8:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
                                                                      
  new_block->next = next;                                             
4000c5ec:	c8 22 20 08 	st  %g4, [ %o0 + 8 ]                           
  new_block->prev = prev;                                             
4000c5f0:	c2 22 20 0c 	st  %g1, [ %o0 + 0xc ]                         
                                                                      
  next->prev = new_block;                                             
  prev->next = new_block;                                             
4000c5f4:	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;                                             
4000c5f8:	d0 21 20 0c 	st  %o0, [ %g4 + 0xc ]                         
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
4000c5fc:	82 10 e0 01 	or  %g3, 1, %g1                                
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
4000c600:	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;               
4000c604:	10 80 00 13 	b  4000c650 <_Heap_Free+0x1bc>                 
4000c608:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
4000c60c:	e0 22 20 0c 	st  %l0, [ %o0 + 0xc ]                         
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
4000c610:	c6 22 20 08 	st  %g3, [ %o0 + 8 ]                           
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
4000c614:	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;         
4000c618:	86 10 a0 01 	or  %g2, 1, %g3                                
4000c61c:	c6 22 20 04 	st  %g3, [ %o0 + 4 ]                           
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
4000c620:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
    next_block->prev_size = block_size;                               
4000c624:	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;               
4000c628:	86 08 ff fe 	and  %g3, -2, %g3                              
4000c62c:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
4000c630:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000c634:	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;                                             
4000c638:	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;                                     
4000c63c:	d0 24 20 08 	st  %o0, [ %l0 + 8 ]                           
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000c640:	80 a0 c0 01 	cmp  %g3, %g1                                  
4000c644:	1a 80 00 03 	bcc  4000c650 <_Heap_Free+0x1bc>               
4000c648:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
4000c64c:	c2 24 20 3c 	st  %g1, [ %l0 + 0x3c ]                        
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000c650:	c2 04 20 40 	ld  [ %l0 + 0x40 ], %g1                        
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
4000c654:	b0 10 20 01 	mov  1, %i0                                    
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000c658:	82 00 7f ff 	add  %g1, -1, %g1                              
4000c65c:	c2 24 20 40 	st  %g1, [ %l0 + 0x40 ]                        
  ++stats->frees;                                                     
4000c660:	c2 04 20 50 	ld  [ %l0 + 0x50 ], %g1                        
4000c664:	82 00 60 01 	inc  %g1                                       
4000c668:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
  stats->free_size += block_size;                                     
4000c66c:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
4000c670:	84 00 40 02 	add  %g1, %g2, %g2                             
4000c674:	c4 24 20 30 	st  %g2, [ %l0 + 0x30 ]                        
                                                                      
  return( true );                                                     
}                                                                     
4000c678:	81 c7 e0 08 	ret                                            
4000c67c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40013634 <_Heap_Size_of_alloc_area>:                                  
bool _Heap_Size_of_alloc_area(                                        
  Heap_Control *heap,                                                 
  void *alloc_begin_ptr,                                              
  uintptr_t *alloc_size                                               
)                                                                     
{                                                                     
40013634:	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);                                 
40013638:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
4001363c:	7f ff f9 a3 	call  40011cc8 <.urem>                         
40013640:	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           
40013644:	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);                                 
40013648:	a2 06 7f f8 	add  %i1, -8, %l1                              
4001364c:	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);                                        
40013650:	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;             
40013654:	80 a2 00 02 	cmp  %o0, %g2                                  
40013658:	0a 80 00 05 	bcs  4001366c <_Heap_Size_of_alloc_area+0x38>  
4001365c:	82 10 20 00 	clr  %g1                                       
40013660:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40013664:	80 a0 40 08 	cmp  %g1, %o0                                  
40013668:	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 ) ) {                     
4001366c:	80 a0 60 00 	cmp  %g1, 0                                    
40013670:	02 80 00 15 	be  400136c4 <_Heap_Size_of_alloc_area+0x90>   
40013674:	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;                
40013678:	e2 02 20 04 	ld  [ %o0 + 4 ], %l1                           
4001367c:	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);                 
40013680:	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;             
40013684:	80 a4 40 02 	cmp  %l1, %g2                                  
40013688:	0a 80 00 05 	bcs  4001369c <_Heap_Size_of_alloc_area+0x68>  <== NEVER TAKEN
4001368c:	82 10 20 00 	clr  %g1                                       
40013690:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
40013694:	80 a0 40 11 	cmp  %g1, %l1                                  
40013698:	82 60 3f ff 	subx  %g0, -1, %g1                             
  }                                                                   
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if (                                                                
4001369c:	80 a0 60 00 	cmp  %g1, 0                                    
400136a0:	02 80 00 09 	be  400136c4 <_Heap_Size_of_alloc_area+0x90>   <== NEVER TAKEN
400136a4:	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;                 
400136a8:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
400136ac:	80 88 60 01 	btst  1, %g1                                   
400136b0:	02 80 00 05 	be  400136c4 <_Heap_Size_of_alloc_area+0x90>   <== NEVER TAKEN
400136b4:	a2 24 40 19 	sub  %l1, %i1, %l1                             
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_BLOCK_SIZE_OFFSET - alloc_begin;
                                                                      
  return true;                                                        
400136b8:	b0 10 20 01 	mov  1, %i0                                    
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_BLOCK_SIZE_OFFSET - alloc_begin;
400136bc:	a2 04 60 04 	add  %l1, 4, %l1                               
400136c0:	e2 26 80 00 	st  %l1, [ %i2 ]                               
                                                                      
  return true;                                                        
}                                                                     
400136c4:	81 c7 e0 08 	ret                                            
400136c8:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40008c4c <_Heap_Walk>:                                                
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
40008c4c:	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;                      
40008c50:	23 10 00 22 	sethi  %hi(0x40008800), %l1                    
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
40008c54:	a0 10 00 18 	mov  %i0, %l0                                  
  uintptr_t const page_size = heap->page_size;                        
40008c58:	e4 06 20 10 	ld  [ %i0 + 0x10 ], %l2                        
  uintptr_t const min_block_size = heap->min_block_size;              
40008c5c:	e8 06 20 14 	ld  [ %i0 + 0x14 ], %l4                        
  Heap_Block *const first_block = heap->first_block;                  
40008c60:	e6 06 20 20 	ld  [ %i0 + 0x20 ], %l3                        
  Heap_Block *const last_block = heap->last_block;                    
40008c64:	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;                      
40008c68:	80 8e a0 ff 	btst  0xff, %i2                                
40008c6c:	02 80 00 04 	be  40008c7c <_Heap_Walk+0x30>                 
40008c70:	a2 14 63 f8 	or  %l1, 0x3f8, %l1                            
40008c74:	23 10 00 23 	sethi  %hi(0x40008c00), %l1                    
40008c78:	a2 14 60 00 	mov  %l1, %l1	! 40008c00 <_Heap_Walk_print>    
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
40008c7c:	03 10 00 5e 	sethi  %hi(0x40017800), %g1                    
40008c80:	c2 00 63 8c 	ld  [ %g1 + 0x38c ], %g1	! 40017b8c <_System_state_Current>
40008c84:	80 a0 60 03 	cmp  %g1, 3                                    
40008c88:	12 80 01 2d 	bne  4000913c <_Heap_Walk+0x4f0>               
40008c8c:	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)(                                                         
40008c90:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40008c94:	da 04 20 18 	ld  [ %l0 + 0x18 ], %o5                        
40008c98:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40008c9c:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
40008ca0:	e6 23 a0 60 	st  %l3, [ %sp + 0x60 ]                        
40008ca4:	c2 23 a0 68 	st  %g1, [ %sp + 0x68 ]                        
40008ca8:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
40008cac:	ea 23 a0 64 	st  %l5, [ %sp + 0x64 ]                        
40008cb0:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
40008cb4:	90 10 00 19 	mov  %i1, %o0                                  
40008cb8:	92 10 20 00 	clr  %o1                                       
40008cbc:	15 10 00 54 	sethi  %hi(0x40015000), %o2                    
40008cc0:	96 10 00 12 	mov  %l2, %o3                                  
40008cc4:	94 12 a3 30 	or  %o2, 0x330, %o2                            
40008cc8:	9f c4 40 00 	call  %l1                                      
40008ccc:	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 ) {                                             
40008cd0:	80 a4 a0 00 	cmp  %l2, 0                                    
40008cd4:	12 80 00 07 	bne  40008cf0 <_Heap_Walk+0xa4>                
40008cd8:	80 8c a0 07 	btst  7, %l2                                   
    (*printer)( source, true, "page size is zero\n" );                
40008cdc:	15 10 00 54 	sethi  %hi(0x40015000), %o2                    
40008ce0:	90 10 00 19 	mov  %i1, %o0                                  
40008ce4:	92 10 20 01 	mov  1, %o1                                    
40008ce8:	10 80 00 38 	b  40008dc8 <_Heap_Walk+0x17c>                 
40008cec:	94 12 a3 c8 	or  %o2, 0x3c8, %o2                            
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
40008cf0:	22 80 00 08 	be,a   40008d10 <_Heap_Walk+0xc4>              
40008cf4:	90 10 00 14 	mov  %l4, %o0                                  
    (*printer)(                                                       
40008cf8:	15 10 00 54 	sethi  %hi(0x40015000), %o2                    
40008cfc:	90 10 00 19 	mov  %i1, %o0                                  
40008d00:	92 10 20 01 	mov  1, %o1                                    
40008d04:	94 12 a3 e0 	or  %o2, 0x3e0, %o2                            
40008d08:	10 80 01 0b 	b  40009134 <_Heap_Walk+0x4e8>                 
40008d0c:	96 10 00 12 	mov  %l2, %o3                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40008d10:	7f ff e3 6d 	call  40001ac4 <.urem>                         
40008d14:	92 10 00 12 	mov  %l2, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
40008d18:	80 a2 20 00 	cmp  %o0, 0                                    
40008d1c:	22 80 00 08 	be,a   40008d3c <_Heap_Walk+0xf0>              
40008d20:	90 04 e0 08 	add  %l3, 8, %o0                               
    (*printer)(                                                       
40008d24:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008d28:	90 10 00 19 	mov  %i1, %o0                                  
40008d2c:	92 10 20 01 	mov  1, %o1                                    
40008d30:	94 12 a0 00 	mov  %o2, %o2                                  
40008d34:	10 80 01 00 	b  40009134 <_Heap_Walk+0x4e8>                 
40008d38:	96 10 00 14 	mov  %l4, %o3                                  
40008d3c:	7f ff e3 62 	call  40001ac4 <.urem>                         
40008d40:	92 10 00 12 	mov  %l2, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
40008d44:	80 a2 20 00 	cmp  %o0, 0                                    
40008d48:	22 80 00 08 	be,a   40008d68 <_Heap_Walk+0x11c>             
40008d4c:	c2 04 e0 04 	ld  [ %l3 + 4 ], %g1                           
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
40008d50:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008d54:	90 10 00 19 	mov  %i1, %o0                                  
40008d58:	92 10 20 01 	mov  1, %o1                                    
40008d5c:	94 12 a0 28 	or  %o2, 0x28, %o2                             
40008d60:	10 80 00 f5 	b  40009134 <_Heap_Walk+0x4e8>                 
40008d64:	96 10 00 13 	mov  %l3, %o3                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
40008d68:	80 88 60 01 	btst  1, %g1                                   
40008d6c:	32 80 00 07 	bne,a   40008d88 <_Heap_Walk+0x13c>            
40008d70:	ec 05 60 04 	ld  [ %l5 + 4 ], %l6                           
    (*printer)(                                                       
40008d74:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008d78:	90 10 00 19 	mov  %i1, %o0                                  
40008d7c:	92 10 20 01 	mov  1, %o1                                    
40008d80:	10 80 00 12 	b  40008dc8 <_Heap_Walk+0x17c>                 
40008d84:	94 12 a0 60 	or  %o2, 0x60, %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;                
40008d88:	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);                 
40008d8c:	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;                 
40008d90:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
40008d94:	80 88 60 01 	btst  1, %g1                                   
40008d98:	12 80 00 07 	bne  40008db4 <_Heap_Walk+0x168>               
40008d9c:	80 a5 80 13 	cmp  %l6, %l3                                  
    (*printer)(                                                       
40008da0:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008da4:	90 10 00 19 	mov  %i1, %o0                                  
40008da8:	92 10 20 01 	mov  1, %o1                                    
40008dac:	10 80 00 07 	b  40008dc8 <_Heap_Walk+0x17c>                 
40008db0:	94 12 a0 90 	or  %o2, 0x90, %o2                             
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
40008db4:	02 80 00 08 	be  40008dd4 <_Heap_Walk+0x188>                <== ALWAYS TAKEN
40008db8:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
40008dbc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40008dc0:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40008dc4:	94 12 a0 a8 	or  %o2, 0xa8, %o2                             <== NOT EXECUTED
40008dc8:	9f c4 40 00 	call  %l1                                      
40008dcc:	b0 10 20 00 	clr  %i0                                       
40008dd0:	30 80 00 db 	b,a   4000913c <_Heap_Walk+0x4f0>              
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40008dd4:	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;                        
40008dd8:	fa 04 20 10 	ld  [ %l0 + 0x10 ], %i5                        
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
40008ddc:	ae 10 00 10 	mov  %l0, %l7                                  
40008de0:	10 80 00 32 	b  40008ea8 <_Heap_Walk+0x25c>                 
40008de4:	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;             
40008de8:	80 a0 80 1c 	cmp  %g2, %i4                                  
40008dec:	18 80 00 05 	bgu  40008e00 <_Heap_Walk+0x1b4>               
40008df0:	82 10 20 00 	clr  %g1                                       
40008df4:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
40008df8:	80 a0 40 1c 	cmp  %g1, %i4                                  
40008dfc:	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 ) ) {              
40008e00:	80 a0 60 00 	cmp  %g1, 0                                    
40008e04:	32 80 00 08 	bne,a   40008e24 <_Heap_Walk+0x1d8>            
40008e08:	90 07 20 08 	add  %i4, 8, %o0                               
      (*printer)(                                                     
40008e0c:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008e10:	96 10 00 1c 	mov  %i4, %o3                                  
40008e14:	90 10 00 19 	mov  %i1, %o0                                  
40008e18:	92 10 20 01 	mov  1, %o1                                    
40008e1c:	10 80 00 c6 	b  40009134 <_Heap_Walk+0x4e8>                 
40008e20:	94 12 a0 d8 	or  %o2, 0xd8, %o2                             
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40008e24:	7f ff e3 28 	call  40001ac4 <.urem>                         
40008e28:	92 10 00 1d 	mov  %i5, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
40008e2c:	80 a2 20 00 	cmp  %o0, 0                                    
40008e30:	22 80 00 08 	be,a   40008e50 <_Heap_Walk+0x204>             
40008e34:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
40008e38:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008e3c:	96 10 00 1c 	mov  %i4, %o3                                  
40008e40:	90 10 00 19 	mov  %i1, %o0                                  
40008e44:	92 10 20 01 	mov  1, %o1                                    
40008e48:	10 80 00 bb 	b  40009134 <_Heap_Walk+0x4e8>                 
40008e4c:	94 12 a0 f8 	or  %o2, 0xf8, %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;                
40008e50:	82 08 7f fe 	and  %g1, -2, %g1                              
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40008e54:	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;                 
40008e58:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
40008e5c:	80 88 60 01 	btst  1, %g1                                   
40008e60:	22 80 00 08 	be,a   40008e80 <_Heap_Walk+0x234>             
40008e64:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
      (*printer)(                                                     
40008e68:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008e6c:	96 10 00 1c 	mov  %i4, %o3                                  
40008e70:	90 10 00 19 	mov  %i1, %o0                                  
40008e74:	92 10 20 01 	mov  1, %o1                                    
40008e78:	10 80 00 af 	b  40009134 <_Heap_Walk+0x4e8>                 
40008e7c:	94 12 a1 28 	or  %o2, 0x128, %o2                            
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
40008e80:	80 a3 00 17 	cmp  %o4, %l7                                  
40008e84:	22 80 00 08 	be,a   40008ea4 <_Heap_Walk+0x258>             
40008e88:	ae 10 00 1c 	mov  %i4, %l7                                  
      (*printer)(                                                     
40008e8c:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008e90:	96 10 00 1c 	mov  %i4, %o3                                  
40008e94:	90 10 00 19 	mov  %i1, %o0                                  
40008e98:	92 10 20 01 	mov  1, %o1                                    
40008e9c:	10 80 00 49 	b  40008fc0 <_Heap_Walk+0x374>                 
40008ea0:	94 12 a1 48 	or  %o2, 0x148, %o2                            
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    prev_block = free_block;                                          
    free_block = free_block->next;                                    
40008ea4:	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 ) {                            
40008ea8:	80 a7 00 10 	cmp  %i4, %l0                                  
40008eac:	32 bf ff cf 	bne,a   40008de8 <_Heap_Walk+0x19c>            
40008eb0:	c4 04 20 20 	ld  [ %l0 + 0x20 ], %g2                        
40008eb4:	35 10 00 55 	sethi  %hi(0x40015400), %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)(                                                     
40008eb8:	31 10 00 55 	sethi  %hi(0x40015400), %i0                    
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
40008ebc:	b4 16 a3 08 	or  %i2, 0x308, %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)(                                                     
40008ec0:	b0 16 22 f0 	or  %i0, 0x2f0, %i0                            
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
40008ec4:	37 10 00 55 	sethi  %hi(0x40015400), %i3                    
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40008ec8:	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;             
40008ecc:	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;                
40008ed0:	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);                 
40008ed4:	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;             
40008ed8:	80 a0 c0 1d 	cmp  %g3, %i5                                  
40008edc:	18 80 00 05 	bgu  40008ef0 <_Heap_Walk+0x2a4>               <== NEVER TAKEN
40008ee0:	84 10 20 00 	clr  %g2                                       
40008ee4:	c4 04 20 24 	ld  [ %l0 + 0x24 ], %g2                        
40008ee8:	80 a0 80 1d 	cmp  %g2, %i5                                  
40008eec:	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 ) ) {              
40008ef0:	80 a0 a0 00 	cmp  %g2, 0                                    
40008ef4:	12 80 00 07 	bne  40008f10 <_Heap_Walk+0x2c4>               
40008ef8:	84 1d 80 15 	xor  %l6, %l5, %g2                             
      (*printer)(                                                     
40008efc:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008f00:	90 10 00 19 	mov  %i1, %o0                                  
40008f04:	92 10 20 01 	mov  1, %o1                                    
40008f08:	10 80 00 2c 	b  40008fb8 <_Heap_Walk+0x36c>                 
40008f0c:	94 12 a1 80 	or  %o2, 0x180, %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;               
40008f10:	80 a0 00 02 	cmp  %g0, %g2                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40008f14:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
40008f18:	b8 40 20 00 	addx  %g0, 0, %i4                              
40008f1c:	90 10 00 17 	mov  %l7, %o0                                  
40008f20:	7f ff e2 e9 	call  40001ac4 <.urem>                         
40008f24:	92 10 00 12 	mov  %l2, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40008f28:	80 a2 20 00 	cmp  %o0, 0                                    
40008f2c:	02 80 00 0c 	be  40008f5c <_Heap_Walk+0x310>                
40008f30:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008f34:	80 8f 20 ff 	btst  0xff, %i4                                
40008f38:	02 80 00 0a 	be  40008f60 <_Heap_Walk+0x314>                
40008f3c:	80 a5 c0 14 	cmp  %l7, %l4                                  
      (*printer)(                                                     
40008f40:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008f44:	90 10 00 19 	mov  %i1, %o0                                  
40008f48:	92 10 20 01 	mov  1, %o1                                    
40008f4c:	94 12 a1 b0 	or  %o2, 0x1b0, %o2                            
40008f50:	96 10 00 16 	mov  %l6, %o3                                  
40008f54:	10 80 00 1b 	b  40008fc0 <_Heap_Walk+0x374>                 
40008f58:	98 10 00 17 	mov  %l7, %o4                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
40008f5c:	80 a5 c0 14 	cmp  %l7, %l4                                  
40008f60:	1a 80 00 0d 	bcc  40008f94 <_Heap_Walk+0x348>               
40008f64:	80 a7 40 16 	cmp  %i5, %l6                                  
40008f68:	80 8f 20 ff 	btst  0xff, %i4                                
40008f6c:	02 80 00 0a 	be  40008f94 <_Heap_Walk+0x348>                <== NEVER TAKEN
40008f70:	80 a7 40 16 	cmp  %i5, %l6                                  
      (*printer)(                                                     
40008f74:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008f78:	90 10 00 19 	mov  %i1, %o0                                  
40008f7c:	92 10 20 01 	mov  1, %o1                                    
40008f80:	94 12 a1 e0 	or  %o2, 0x1e0, %o2                            
40008f84:	96 10 00 16 	mov  %l6, %o3                                  
40008f88:	98 10 00 17 	mov  %l7, %o4                                  
40008f8c:	10 80 00 3f 	b  40009088 <_Heap_Walk+0x43c>                 
40008f90:	9a 10 00 14 	mov  %l4, %o5                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
40008f94:	38 80 00 0e 	bgu,a   40008fcc <_Heap_Walk+0x380>            
40008f98:	b8 08 60 01 	and  %g1, 1, %i4                               
40008f9c:	80 8f 20 ff 	btst  0xff, %i4                                
40008fa0:	02 80 00 0b 	be  40008fcc <_Heap_Walk+0x380>                
40008fa4:	b8 08 60 01 	and  %g1, 1, %i4                               
      (*printer)(                                                     
40008fa8:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40008fac:	90 10 00 19 	mov  %i1, %o0                                  
40008fb0:	92 10 20 01 	mov  1, %o1                                    
40008fb4:	94 12 a2 10 	or  %o2, 0x210, %o2                            
40008fb8:	96 10 00 16 	mov  %l6, %o3                                  
40008fbc:	98 10 00 1d 	mov  %i5, %o4                                  
40008fc0:	9f c4 40 00 	call  %l1                                      
40008fc4:	b0 10 20 00 	clr  %i0                                       
40008fc8:	30 80 00 5d 	b,a   4000913c <_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;                 
40008fcc:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
40008fd0:	80 88 60 01 	btst  1, %g1                                   
40008fd4:	12 80 00 3f 	bne  400090d0 <_Heap_Walk+0x484>               
40008fd8:	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 ?                                 
40008fdc:	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)(                                                         
40008fe0:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
40008fe4:	05 10 00 54 	sethi  %hi(0x40015000), %g2                    
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40008fe8:	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)(                                                         
40008fec:	80 a3 40 01 	cmp  %o5, %g1                                  
40008ff0:	02 80 00 07 	be  4000900c <_Heap_Walk+0x3c0>                
40008ff4:	86 10 a2 f0 	or  %g2, 0x2f0, %g3                            
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
40008ff8:	80 a3 40 10 	cmp  %o5, %l0                                  
40008ffc:	12 80 00 04 	bne  4000900c <_Heap_Walk+0x3c0>               
40009000:	86 16 e2 b8 	or  %i3, 0x2b8, %g3                            
40009004:	19 10 00 54 	sethi  %hi(0x40015000), %o4                    
40009008:	86 13 23 00 	or  %o4, 0x300, %g3	! 40015300 <C.0.4109+0x44> 
    block->next,                                                      
    block->next == last_free_block ?                                  
4000900c:	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)(                                                         
40009010:	19 10 00 54 	sethi  %hi(0x40015000), %o4                    
40009014:	80 a0 80 04 	cmp  %g2, %g4                                  
40009018:	02 80 00 07 	be  40009034 <_Heap_Walk+0x3e8>                
4000901c:	82 13 23 10 	or  %o4, 0x310, %g1                            
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
40009020:	80 a0 80 10 	cmp  %g2, %l0                                  
40009024:	12 80 00 04 	bne  40009034 <_Heap_Walk+0x3e8>               
40009028:	82 16 e2 b8 	or  %i3, 0x2b8, %g1                            
4000902c:	09 10 00 54 	sethi  %hi(0x40015000), %g4                    
40009030:	82 11 23 20 	or  %g4, 0x320, %g1	! 40015320 <C.0.4109+0x64> 
  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)(                                                         
40009034:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
40009038:	c4 23 a0 60 	st  %g2, [ %sp + 0x60 ]                        
4000903c:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40009040:	90 10 00 19 	mov  %i1, %o0                                  
40009044:	92 10 20 00 	clr  %o1                                       
40009048:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
4000904c:	96 10 00 16 	mov  %l6, %o3                                  
40009050:	94 12 a2 48 	or  %o2, 0x248, %o2                            
40009054:	9f c4 40 00 	call  %l1                                      
40009058:	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 ) {                        
4000905c:	da 07 40 00 	ld  [ %i5 ], %o5                               
40009060:	80 a5 c0 0d 	cmp  %l7, %o5                                  
40009064:	02 80 00 0c 	be  40009094 <_Heap_Walk+0x448>                
40009068:	80 a7 20 00 	cmp  %i4, 0                                    
    (*printer)(                                                       
4000906c:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
40009070:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
40009074:	90 10 00 19 	mov  %i1, %o0                                  
40009078:	92 10 20 01 	mov  1, %o1                                    
4000907c:	94 12 a2 80 	or  %o2, 0x280, %o2                            
40009080:	96 10 00 16 	mov  %l6, %o3                                  
40009084:	98 10 00 17 	mov  %l7, %o4                                  
40009088:	9f c4 40 00 	call  %l1                                      
4000908c:	b0 10 20 00 	clr  %i0                                       
40009090:	30 80 00 2b 	b,a   4000913c <_Heap_Walk+0x4f0>              
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
40009094:	32 80 00 0a 	bne,a   400090bc <_Heap_Walk+0x470>            
40009098:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
    (*printer)(                                                       
4000909c:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
400090a0:	90 10 00 19 	mov  %i1, %o0                                  
400090a4:	92 10 20 01 	mov  1, %o1                                    
400090a8:	10 80 00 22 	b  40009130 <_Heap_Walk+0x4e4>                 
400090ac:	94 12 a2 c0 	or  %o2, 0x2c0, %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 ) {                                      
400090b0:	02 80 00 19 	be  40009114 <_Heap_Walk+0x4c8>                
400090b4:	80 a7 40 13 	cmp  %i5, %l3                                  
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
400090b8:	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 ) {                            
400090bc:	80 a0 40 10 	cmp  %g1, %l0                                  
400090c0:	12 bf ff fc 	bne  400090b0 <_Heap_Walk+0x464>               
400090c4:	80 a0 40 16 	cmp  %g1, %l6                                  
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
400090c8:	10 80 00 17 	b  40009124 <_Heap_Walk+0x4d8>                 
400090cc:	15 10 00 55 	sethi  %hi(0x40015400), %o2                    
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
400090d0:	22 80 00 0a 	be,a   400090f8 <_Heap_Walk+0x4ac>             
400090d4:	da 05 80 00 	ld  [ %l6 ], %o5                               
      (*printer)(                                                     
400090d8:	90 10 00 19 	mov  %i1, %o0                                  
400090dc:	92 10 20 00 	clr  %o1                                       
400090e0:	94 10 00 18 	mov  %i0, %o2                                  
400090e4:	96 10 00 16 	mov  %l6, %o3                                  
400090e8:	9f c4 40 00 	call  %l1                                      
400090ec:	98 10 00 17 	mov  %l7, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
400090f0:	10 80 00 09 	b  40009114 <_Heap_Walk+0x4c8>                 
400090f4:	80 a7 40 13 	cmp  %i5, %l3                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
400090f8:	90 10 00 19 	mov  %i1, %o0                                  
400090fc:	92 10 20 00 	clr  %o1                                       
40009100:	94 10 00 1a 	mov  %i2, %o2                                  
40009104:	96 10 00 16 	mov  %l6, %o3                                  
40009108:	9f c4 40 00 	call  %l1                                      
4000910c:	98 10 00 17 	mov  %l7, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
40009110:	80 a7 40 13 	cmp  %i5, %l3                                  
40009114:	32 bf ff 6d 	bne,a   40008ec8 <_Heap_Walk+0x27c>            
40009118:	ac 10 00 1d 	mov  %i5, %l6                                  
                                                                      
  return true;                                                        
}                                                                     
4000911c:	81 c7 e0 08 	ret                                            
40009120:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
40009124:	90 10 00 19 	mov  %i1, %o0                                  
40009128:	92 10 20 01 	mov  1, %o1                                    
4000912c:	94 12 a3 30 	or  %o2, 0x330, %o2                            
40009130:	96 10 00 16 	mov  %l6, %o3                                  
40009134:	9f c4 40 00 	call  %l1                                      
40009138:	b0 10 20 00 	clr  %i0                                       
4000913c:	81 c7 e0 08 	ret                                            
40009140:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40007de4 <_Internal_error_Occurred>:                                  
void _Internal_error_Occurred(                                        
  Internal_errors_Source  the_source,                                 
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
40007de4:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
40007de8:	05 10 00 54 	sethi  %hi(0x40015000), %g2                    
40007dec:	82 10 a3 fc 	or  %g2, 0x3fc, %g1	! 400153fc <_Internal_errors_What_happened>
void _Internal_error_Occurred(                                        
  Internal_errors_Source  the_source,                                 
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
40007df0:	90 10 00 18 	mov  %i0, %o0                                  
40007df4:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
40007df8:	f0 20 a3 fc 	st  %i0, [ %g2 + 0x3fc ]                       
  _Internal_errors_What_happened.is_internal = is_internal;           
40007dfc:	f2 28 60 04 	stb  %i1, [ %g1 + 4 ]                          
  _Internal_errors_What_happened.the_error   = the_error;             
40007e00:	f4 20 60 08 	st  %i2, [ %g1 + 8 ]                           
                                                                      
  _User_extensions_Fatal( the_source, is_internal, the_error );       
40007e04:	40 00 07 80 	call  40009c04 <_User_extensions_Fatal>        
40007e08:	92 0e 60 ff 	and  %i1, 0xff, %o1                            
                                                                      
RTEMS_INLINE_ROUTINE void _System_state_Set (                         
  System_state_Codes state                                            
)                                                                     
{                                                                     
  _System_state_Current = state;                                      
40007e0c:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
40007e10:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    <== NOT EXECUTED
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
40007e14:	7f ff e7 c8 	call  40001d34 <sparc_disable_interrupts>      <== NOT EXECUTED
40007e18:	c4 20 60 ec 	st  %g2, [ %g1 + 0xec ]	! 400154ec <_System_state_Current><== NOT EXECUTED
40007e1c:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
40007e20:	30 80 00 00 	b,a   40007e20 <_Internal_error_Occurred+0x3c> <== NOT EXECUTED
                                                                      
===============================================================================
40007e94 <_Objects_Allocate>:                                         
 */                                                                   
                                                                      
Objects_Control *_Objects_Allocate(                                   
  Objects_Information *information                                    
)                                                                     
{                                                                     
40007e94:	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 )                                       
40007e98:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 */                                                                   
                                                                      
Objects_Control *_Objects_Allocate(                                   
  Objects_Information *information                                    
)                                                                     
{                                                                     
40007e9c:	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 )                                       
40007ea0:	80 a0 60 00 	cmp  %g1, 0                                    
40007ea4:	02 80 00 20 	be  40007f24 <_Objects_Allocate+0x90>          <== NEVER TAKEN
40007ea8:	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 );
40007eac:	a2 04 20 20 	add  %l0, 0x20, %l1                            
40007eb0:	7f ff fd 86 	call  400074c8 <_Chain_Get>                    
40007eb4:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
  if ( information->auto_extend ) {                                   
40007eb8:	c2 0c 20 12 	ldub  [ %l0 + 0x12 ], %g1                      
40007ebc:	80 a0 60 00 	cmp  %g1, 0                                    
40007ec0:	02 80 00 19 	be  40007f24 <_Objects_Allocate+0x90>          
40007ec4:	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 ) {                                              
40007ec8:	80 a2 20 00 	cmp  %o0, 0                                    
40007ecc:	32 80 00 0a 	bne,a   40007ef4 <_Objects_Allocate+0x60>      
40007ed0:	c2 14 20 0a 	lduh  [ %l0 + 0xa ], %g1                       
      _Objects_Extend_information( information );                     
40007ed4:	40 00 00 1e 	call  40007f4c <_Objects_Extend_information>   
40007ed8:	90 10 00 10 	mov  %l0, %o0                                  
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
40007edc:	7f ff fd 7b 	call  400074c8 <_Chain_Get>                    
40007ee0:	90 10 00 11 	mov  %l1, %o0                                  
    }                                                                 
                                                                      
    if ( the_object ) {                                               
40007ee4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40007ee8:	02 80 00 0f 	be  40007f24 <_Objects_Allocate+0x90>          
40007eec:	01 00 00 00 	nop                                            
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
40007ef0:	c2 14 20 0a 	lduh  [ %l0 + 0xa ], %g1                       
40007ef4:	d0 16 20 0a 	lduh  [ %i0 + 0xa ], %o0                       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
40007ef8:	d2 14 20 14 	lduh  [ %l0 + 0x14 ], %o1                      
40007efc:	40 00 26 c7 	call  40011a18 <.udiv>                         
40007f00:	90 22 00 01 	sub  %o0, %g1, %o0                             
                                                                      
      information->inactive_per_block[ block ]--;                     
40007f04:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
40007f08:	91 2a 20 02 	sll  %o0, 2, %o0                               
40007f0c:	c4 00 40 08 	ld  [ %g1 + %o0 ], %g2                         
40007f10:	84 00 bf ff 	add  %g2, -1, %g2                              
40007f14:	c4 20 40 08 	st  %g2, [ %g1 + %o0 ]                         
      information->inactive--;                                        
40007f18:	c2 14 20 2c 	lduh  [ %l0 + 0x2c ], %g1                      
40007f1c:	82 00 7f ff 	add  %g1, -1, %g1                              
40007f20:	c2 34 20 2c 	sth  %g1, [ %l0 + 0x2c ]                       
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
40007f24:	81 c7 e0 08 	ret                                            
40007f28:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
400082a8 <_Objects_Get_information>:                                  
                                                                      
Objects_Information *_Objects_Get_information(                        
  Objects_APIs   the_api,                                             
  uint32_t       the_class                                            
)                                                                     
{                                                                     
400082a8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
400082ac:	80 a6 60 00 	cmp  %i1, 0                                    
400082b0:	02 80 00 17 	be  4000830c <_Objects_Get_information+0x64>   
400082b4:	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 );      
400082b8:	40 00 10 f2 	call  4000c680 <_Objects_API_maximum_class>    
400082bc:	90 10 00 18 	mov  %i0, %o0                                  
  if ( the_class_api_maximum == 0 )                                   
400082c0:	80 a2 20 00 	cmp  %o0, 0                                    
400082c4:	02 80 00 12 	be  4000830c <_Objects_Get_information+0x64>   
400082c8:	80 a6 40 08 	cmp  %i1, %o0                                  
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
400082cc:	18 80 00 10 	bgu  4000830c <_Objects_Get_information+0x64>  
400082d0:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
400082d4:	b1 2e 20 02 	sll  %i0, 2, %i0                               
400082d8:	82 10 62 cc 	or  %g1, 0x2cc, %g1                            
400082dc:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
400082e0:	80 a0 60 00 	cmp  %g1, 0                                    
400082e4:	02 80 00 0a 	be  4000830c <_Objects_Get_information+0x64>   <== NEVER TAKEN
400082e8:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
400082ec:	e0 00 40 19 	ld  [ %g1 + %i1 ], %l0                         
  if ( !info )                                                        
400082f0:	80 a4 20 00 	cmp  %l0, 0                                    
400082f4:	02 80 00 06 	be  4000830c <_Objects_Get_information+0x64>   <== NEVER TAKEN
400082f8:	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 )                                         
400082fc:	c2 14 20 10 	lduh  [ %l0 + 0x10 ], %g1                      
      return NULL;                                                    
40008300:	80 a0 00 01 	cmp  %g0, %g1                                  
40008304:	82 60 20 00 	subx  %g0, 0, %g1                              
40008308:	a0 0c 00 01 	and  %l0, %g1, %l0                             
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
4000830c:	81 c7 e0 08 	ret                                            
40008310:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      
===============================================================================
40019bac <_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;                           
40019bac:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
                                                                      
  if ( information->maximum >= index ) {                              
40019bb0:	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;                           
40019bb4:	82 22 40 01 	sub  %o1, %g1, %g1                             
40019bb8:	82 00 60 01 	inc  %g1                                       
                                                                      
  if ( information->maximum >= index ) {                              
40019bbc:	80 a0 80 01 	cmp  %g2, %g1                                  
40019bc0:	0a 80 00 09 	bcs  40019be4 <_Objects_Get_no_protection+0x38>
40019bc4:	83 28 60 02 	sll  %g1, 2, %g1                               
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
40019bc8:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
40019bcc:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0                         
40019bd0:	80 a2 20 00 	cmp  %o0, 0                                    
40019bd4:	02 80 00 05 	be  40019be8 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
40019bd8:	82 10 20 01 	mov  1, %g1                                    
      *location = OBJECTS_LOCAL;                                      
      return the_object;                                              
40019bdc:	81 c3 e0 08 	retl                                           
40019be0:	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;                                          
40019be4:	82 10 20 01 	mov  1, %g1                                    
  return NULL;                                                        
40019be8:	90 10 20 00 	clr  %o0                                       
}                                                                     
40019bec:	81 c3 e0 08 	retl                                           
40019bf0:	c2 22 80 00 	st  %g1, [ %o2 ]                               
                                                                      
===============================================================================
40009b74 <_Objects_Id_to_name>:                                       
 */                                                                   
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (                
  Objects_Id      id,                                                 
  Objects_Name   *name                                                
)                                                                     
{                                                                     
40009b74:	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;
40009b78:	92 96 20 00 	orcc  %i0, 0, %o1                              
40009b7c:	12 80 00 06 	bne  40009b94 <_Objects_Id_to_name+0x20>       
40009b80:	83 32 60 18 	srl  %o1, 0x18, %g1                            
40009b84:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40009b88:	c2 00 60 d8 	ld  [ %g1 + 0xd8 ], %g1	! 4001ecd8 <_Per_CPU_Information+0xc>
40009b8c:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
40009b90:	83 32 60 18 	srl  %o1, 0x18, %g1                            
40009b94:	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 )                      
40009b98:	84 00 7f ff 	add  %g1, -1, %g2                              
40009b9c:	80 a0 a0 02 	cmp  %g2, 2                                    
40009ba0:	18 80 00 12 	bgu  40009be8 <_Objects_Id_to_name+0x74>       
40009ba4:	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 ] )                       
40009ba8:	10 80 00 12 	b  40009bf0 <_Objects_Id_to_name+0x7c>         
40009bac:	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 ];   
40009bb0:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009bb4:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
  if ( !information )                                                 
40009bb8:	80 a2 20 00 	cmp  %o0, 0                                    
40009bbc:	02 80 00 0b 	be  40009be8 <_Objects_Id_to_name+0x74>        <== NEVER TAKEN
40009bc0:	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 ); 
40009bc4:	7f ff ff cf 	call  40009b00 <_Objects_Get>                  
40009bc8:	94 07 bf fc 	add  %fp, -4, %o2                              
  if ( !the_object )                                                  
40009bcc:	80 a2 20 00 	cmp  %o0, 0                                    
40009bd0:	02 80 00 06 	be  40009be8 <_Objects_Id_to_name+0x74>        
40009bd4:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
40009bd8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
40009bdc:	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();                                          
40009be0:	40 00 02 3a 	call  4000a4c8 <_Thread_Enable_dispatch>       
40009be4:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
}                                                                     
40009be8:	81 c7 e0 08 	ret                                            
40009bec:	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 ] )                       
40009bf0:	05 10 00 7a 	sethi  %hi(0x4001e800), %g2                    
40009bf4:	84 10 a1 cc 	or  %g2, 0x1cc, %g2	! 4001e9cc <_Objects_Information_table>
40009bf8:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
40009bfc:	80 a0 60 00 	cmp  %g1, 0                                    
40009c00:	12 bf ff ec 	bne  40009bb0 <_Objects_Id_to_name+0x3c>       <== ALWAYS TAKEN
40009c04:	85 32 60 1b 	srl  %o1, 0x1b, %g2                            
40009c08:	30 bf ff f8 	b,a   40009be8 <_Objects_Id_to_name+0x74>      <== NOT EXECUTED
                                                                      
===============================================================================
400083fc <_Objects_Initialize_information>:                           
  ,                                                                   
  bool                 supports_global,                               
  Objects_Thread_queue_Extract_callout extract                        
#endif                                                                
)                                                                     
{                                                                     
400083fc:	9d e3 bf a0 	save  %sp, -96, %sp                            
    uint32_t              index;                                      
  #endif                                                              
                                                                      
  information->the_api            = the_api;                          
  information->the_class          = the_class;                        
  information->size               = size;                             
40008400:	85 2f 20 10 	sll  %i4, 0x10, %g2                            
40008404:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
  information->maximum = 0;                                           
                                                                      
  /*                                                                  
   *  Register this Object Class in the Object Information Table.     
   */                                                                 
  _Objects_Information_table[ the_api ][ the_class ] = information;   
40008408:	07 10 00 54 	sethi  %hi(0x40015000), %g3                    
    uint32_t              index;                                      
  #endif                                                              
                                                                      
  information->the_api            = the_api;                          
  information->the_class          = the_class;                        
  information->size               = size;                             
4000840c:	c4 26 20 18 	st  %g2, [ %i0 + 0x18 ]                        
  information->maximum = 0;                                           
                                                                      
  /*                                                                  
   *  Register this Object Class in the Object Information Table.     
   */                                                                 
  _Objects_Information_table[ the_api ][ the_class ] = information;   
40008410:	86 10 e2 cc 	or  %g3, 0x2cc, %g3                            
40008414:	85 2e 60 02 	sll  %i1, 2, %g2                               
40008418:	c6 00 c0 02 	ld  [ %g3 + %g2 ], %g3                         
  uint32_t                maximum_per_allocation;                     
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t              index;                                      
  #endif                                                              
                                                                      
  information->the_api            = the_api;                          
4000841c:	f2 26 00 00 	st  %i1, [ %i0 ]                               
  information->the_class          = the_class;                        
40008420:	f4 36 20 04 	sth  %i2, [ %i0 + 4 ]                          
  information->size               = size;                             
  information->local_table        = 0;                                
40008424:	c0 26 20 1c 	clr  [ %i0 + 0x1c ]                            
  information->inactive_per_block = 0;                                
40008428:	c0 26 20 30 	clr  [ %i0 + 0x30 ]                            
  information->object_blocks      = 0;                                
4000842c:	c0 26 20 34 	clr  [ %i0 + 0x34 ]                            
  information->inactive           = 0;                                
40008430:	c0 36 20 2c 	clrh  [ %i0 + 0x2c ]                           
                                                                      
  /*                                                                  
   *  Set the maximum value to 0. It will be updated when objects are 
   *  added to the inactive set from _Objects_Extend_information()    
   */                                                                 
  information->maximum = 0;                                           
40008434:	c0 36 20 10 	clrh  [ %i0 + 0x10 ]                           
                                                                      
  /*                                                                  
   *  Register this Object Class in the Object Information Table.     
   */                                                                 
  _Objects_Information_table[ the_api ][ the_class ] = information;   
40008438:	85 2e a0 02 	sll  %i2, 2, %g2                               
  ,                                                                   
  bool                 supports_global,                               
  Objects_Thread_queue_Extract_callout extract                        
#endif                                                                
)                                                                     
{                                                                     
4000843c:	c2 07 a0 5c 	ld  [ %fp + 0x5c ], %g1                        
  information->maximum = 0;                                           
                                                                      
  /*                                                                  
   *  Register this Object Class in the Object Information Table.     
   */                                                                 
  _Objects_Information_table[ the_api ][ the_class ] = information;   
40008440:	f0 20 c0 02 	st  %i0, [ %g3 + %g2 ]                         
                                                                      
  /*                                                                  
   *  Are we operating in limited or unlimited (e.g. auto-extend) mode.
   */                                                                 
  information->auto_extend =                                          
        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;         
40008444:	85 36 e0 1f 	srl  %i3, 0x1f, %g2                            
  _Objects_Information_table[ the_api ][ the_class ] = information;   
                                                                      
  /*                                                                  
   *  Are we operating in limited or unlimited (e.g. auto-extend) mode.
   */                                                                 
  information->auto_extend =                                          
40008448:	c4 2e 20 12 	stb  %g2, [ %i0 + 0x12 ]                       
        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;         
  maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;      
4000844c:	07 20 00 00 	sethi  %hi(0x80000000), %g3                    
                                                                      
  /*                                                                  
   *  Unlimited and maximum of zero is illogical.                     
   */                                                                 
  if ( information->auto_extend && maximum_per_allocation == 0) {     
40008450:	80 a0 a0 00 	cmp  %g2, 0                                    
40008454:	02 80 00 09 	be  40008478 <_Objects_Initialize_information+0x7c>
40008458:	b6 2e c0 03 	andn  %i3, %g3, %i3                            
4000845c:	80 a6 e0 00 	cmp  %i3, 0                                    
40008460:	12 80 00 07 	bne  4000847c <_Objects_Initialize_information+0x80>
40008464:	05 10 00 53 	sethi  %hi(0x40014c00), %g2                    
    _Internal_error_Occurred(                                         
40008468:	90 10 20 00 	clr  %o0                                       
4000846c:	92 10 20 01 	mov  1, %o1                                    
40008470:	7f ff fe 5d 	call  40007de4 <_Internal_error_Occurred>      
40008474:	94 10 20 13 	mov  0x13, %o2                                 
  information->allocation_size = maximum_per_allocation;              
                                                                      
  /*                                                                  
   *  Provide a null local table entry for the case of any empty table.
   */                                                                 
  information->local_table = &null_local_table;                       
40008478:	05 10 00 53 	sethi  %hi(0x40014c00), %g2                    
4000847c:	84 10 a3 e4 	or  %g2, 0x3e4, %g2	! 40014fe4 <null_local_table.3194>
40008480:	c4 26 20 1c 	st  %g2, [ %i0 + 0x1c ]                        
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008484:	05 00 00 40 	sethi  %hi(0x10000), %g2                       
                                                                      
  /*                                                                  
   *  Calculate minimum and maximum Id's                              
   */                                                                 
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;              
40008488:	80 a0 00 1b 	cmp  %g0, %i3                                  
4000848c:	b3 2e 60 18 	sll  %i1, 0x18, %i1                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008490:	b5 2e a0 1b 	sll  %i2, 0x1b, %i2                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008494:	b2 16 40 02 	or  %i1, %g2, %i1                              
  }                                                                   
                                                                      
  /*                                                                  
   *  The allocation unit is the maximum value                        
   */                                                                 
  information->allocation_size = maximum_per_allocation;              
40008498:	f6 36 20 14 	sth  %i3, [ %i0 + 0x14 ]                       
  information->local_table = &null_local_table;                       
                                                                      
  /*                                                                  
   *  Calculate minimum and maximum Id's                              
   */                                                                 
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;              
4000849c:	84 40 20 00 	addx  %g0, 0, %g2                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
400084a0:	b4 16 40 1a 	or  %i1, %i2, %i2                              
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
400084a4:	b4 16 80 02 	or  %i2, %g2, %i2                              
  /*                                                                  
   *  Calculate the maximum name length                               
   */                                                                 
  name_length = maximum_name_length;                                  
                                                                      
  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )                     
400084a8:	80 88 60 03 	btst  3, %g1                                   
400084ac:	02 80 00 04 	be  400084bc <_Objects_Initialize_information+0xc0><== ALWAYS TAKEN
400084b0:	f4 26 20 08 	st  %i2, [ %i0 + 8 ]                           
    name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &            
400084b4:	82 00 60 04 	add  %g1, 4, %g1                               <== NOT EXECUTED
400084b8:	82 08 7f fc 	and  %g1, -4, %g1                              <== NOT EXECUTED
                  ~(OBJECTS_NAME_ALIGNMENT-1);                        
                                                                      
  information->name_length = name_length;                             
400084bc:	c2 36 20 38 	sth  %g1, [ %i0 + 0x38 ]                       
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
400084c0:	82 06 20 24 	add  %i0, 0x24, %g1                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
400084c4:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
400084c8:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
                                                                      
  _Chain_Initialize_empty( &information->Inactive );                  
400084cc:	82 06 20 20 	add  %i0, 0x20, %g1                            
                                                                      
  /*                                                                  
   *  Initialize objects .. if there are any                          
   */                                                                 
  if ( maximum_per_allocation ) {                                     
400084d0:	80 a6 e0 00 	cmp  %i3, 0                                    
400084d4:	02 80 00 04 	be  400084e4 <_Objects_Initialize_information+0xe8>
400084d8:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
    /*                                                                
     *  Always have the maximum size available so the current performance
     *  figures are create are met.  If the user moves past the maximum
     *  number then a performance hit is taken.                       
     */                                                               
    _Objects_Extend_information( information );                       
400084dc:	7f ff fe 9c 	call  40007f4c <_Objects_Extend_information>   
400084e0:	81 e8 00 00 	restore                                        
400084e4:	81 c7 e0 08 	ret                                            
400084e8:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000be58 <_RTEMS_tasks_Post_switch_extension>:                        
 */                                                                   
                                                                      
void _RTEMS_tasks_Post_switch_extension(                              
  Thread_Control *executing                                           
)                                                                     
{                                                                     
4000be58:	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 ];                
4000be5c:	e0 06 21 5c 	ld  [ %i0 + 0x15c ], %l0                       
  if ( !api )                                                         
4000be60:	80 a4 20 00 	cmp  %l0, 0                                    
4000be64:	02 80 00 1d 	be  4000bed8 <_RTEMS_tasks_Post_switch_extension+0x80><== NEVER TAKEN
4000be68:	01 00 00 00 	nop                                            
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
4000be6c:	7f ff d7 b2 	call  40001d34 <sparc_disable_interrupts>      
4000be70:	01 00 00 00 	nop                                            
    signal_set = asr->signals_posted;                                 
4000be74:	e6 04 20 14 	ld  [ %l0 + 0x14 ], %l3                        
    asr->signals_posted = 0;                                          
4000be78:	c0 24 20 14 	clr  [ %l0 + 0x14 ]                            
  _ISR_Enable( level );                                               
4000be7c:	7f ff d7 b2 	call  40001d44 <sparc_enable_interrupts>       
4000be80:	01 00 00 00 	nop                                            
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
4000be84:	80 a4 e0 00 	cmp  %l3, 0                                    
4000be88:	02 80 00 14 	be  4000bed8 <_RTEMS_tasks_Post_switch_extension+0x80>
4000be8c:	a2 07 bf fc 	add  %fp, -4, %l1                              
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
4000be90:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
4000be94:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
4000be98:	82 00 60 01 	inc  %g1                                       
4000be9c:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
4000bea0:	94 10 00 11 	mov  %l1, %o2                                  
4000bea4:	25 00 00 3f 	sethi  %hi(0xfc00), %l2                        
4000bea8:	40 00 07 93 	call  4000dcf4 <rtems_task_mode>               
4000beac:	92 14 a3 ff 	or  %l2, 0x3ff, %o1	! ffff <PROM_START+0xffff> 
                                                                      
  (*asr->handler)( signal_set );                                      
4000beb0:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
4000beb4:	9f c0 40 00 	call  %g1                                      
4000beb8:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
  asr->nest_level -= 1;                                               
4000bebc:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000bec0:	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;                                               
4000bec4:	82 00 7f ff 	add  %g1, -1, %g1                              
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000bec8:	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;                                               
4000becc:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000bed0:	40 00 07 89 	call  4000dcf4 <rtems_task_mode>               
4000bed4:	94 10 00 11 	mov  %l1, %o2                                  
4000bed8:	81 c7 e0 08 	ret                                            
4000bedc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
400081e8 <_Rate_monotonic_Timeout>:                                   
                                                                      
void _Rate_monotonic_Timeout(                                         
  Objects_Id  id,                                                     
  void       *ignored                                                 
)                                                                     
{                                                                     
400081e8:	9d e3 bf 98 	save  %sp, -104, %sp                           
400081ec:	11 10 00 7b 	sethi  %hi(0x4001ec00), %o0                    
400081f0:	92 10 00 18 	mov  %i0, %o1                                  
400081f4:	90 12 23 44 	or  %o0, 0x344, %o0                            
400081f8:	40 00 07 cb 	call  4000a124 <_Objects_Get>                  
400081fc:	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 ) {                                               
40008200:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008204:	80 a0 60 00 	cmp  %g1, 0                                    
40008208:	12 80 00 24 	bne  40008298 <_Rate_monotonic_Timeout+0xb0>   <== NEVER TAKEN
4000820c:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
40008210:	d0 02 20 40 	ld  [ %o0 + 0x40 ], %o0                        
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40008214:	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);                   
40008218:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
4000821c:	80 88 80 01 	btst  %g2, %g1                                 
40008220:	22 80 00 0b 	be,a   4000824c <_Rate_monotonic_Timeout+0x64> 
40008224:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
40008228:	c4 02 20 20 	ld  [ %o0 + 0x20 ], %g2                        
4000822c:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
40008230:	80 a0 80 01 	cmp  %g2, %g1                                  
40008234:	32 80 00 06 	bne,a   4000824c <_Rate_monotonic_Timeout+0x64>
40008238:	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 );                  
4000823c:	13 04 00 ff 	sethi  %hi(0x1003fc00), %o1                    
40008240:	40 00 09 1a 	call  4000a6a8 <_Thread_Clear_state>           
40008244:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1003fff8 <RAM_SIZE+0xfc3fff8>
40008248:	30 80 00 06 	b,a   40008260 <_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 ) {
4000824c:	80 a0 60 01 	cmp  %g1, 1                                    
40008250:	12 80 00 0d 	bne  40008284 <_Rate_monotonic_Timeout+0x9c>   
40008254:	82 10 20 04 	mov  4, %g1                                    
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
40008258:	82 10 20 03 	mov  3, %g1                                    
4000825c:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40008260:	7f ff fe 65 	call  40007bf4 <_Rate_monotonic_Initiate_statistics>
40008264:	90 10 00 10 	mov  %l0, %o0                                  
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40008268:	c2 04 20 3c 	ld  [ %l0 + 0x3c ], %g1                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000826c:	11 10 00 7c 	sethi  %hi(0x4001f000), %o0                    
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40008270:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40008274:	90 12 21 7c 	or  %o0, 0x17c, %o0                            
40008278:	40 00 0e f0 	call  4000be38 <_Watchdog_Insert>              
4000827c:	92 04 20 10 	add  %l0, 0x10, %o1                            
40008280:	30 80 00 02 	b,a   40008288 <_Rate_monotonic_Timeout+0xa0>  
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
40008284:	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;                                
40008288:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4000828c:	c4 00 60 b8 	ld  [ %g1 + 0xb8 ], %g2	! 4001f0b8 <_Thread_Dispatch_disable_level>
40008290:	84 00 bf ff 	add  %g2, -1, %g2                              
40008294:	c4 20 60 b8 	st  %g2, [ %g1 + 0xb8 ]                        
40008298:	81 c7 e0 08 	ret                                            
4000829c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40007bf8 <_TOD_Validate>:                                             
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
40007bf8:	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();                 
40007bfc:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
40007c00:	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();                 
40007c04:	d2 00 63 54 	ld  [ %g1 + 0x354 ], %o1                       
  if ((!the_tod)                                  ||                  
40007c08:	80 a4 20 00 	cmp  %l0, 0                                    
40007c0c:	02 80 00 2b 	be  40007cb8 <_TOD_Validate+0xc0>              <== NEVER TAKEN
40007c10:	b0 10 20 00 	clr  %i0                                       
)                                                                     
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
40007c14:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
40007c18:	40 00 46 fe 	call  40019810 <.udiv>                         
40007c1c:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
40007c20:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
40007c24:	80 a0 40 08 	cmp  %g1, %o0                                  
40007c28:	1a 80 00 24 	bcc  40007cb8 <_TOD_Validate+0xc0>             
40007c2c:	01 00 00 00 	nop                                            
      (the_tod->ticks  >= ticks_per_second)       ||                  
40007c30:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
40007c34:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
40007c38:	18 80 00 20 	bgu  40007cb8 <_TOD_Validate+0xc0>             
40007c3c:	01 00 00 00 	nop                                            
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
40007c40:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
40007c44:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
40007c48:	18 80 00 1c 	bgu  40007cb8 <_TOD_Validate+0xc0>             
40007c4c:	01 00 00 00 	nop                                            
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
40007c50:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
40007c54:	80 a0 60 17 	cmp  %g1, 0x17                                 
40007c58:	18 80 00 18 	bgu  40007cb8 <_TOD_Validate+0xc0>             
40007c5c:	01 00 00 00 	nop                                            
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
40007c60:	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)      ||                  
40007c64:	80 a0 60 00 	cmp  %g1, 0                                    
40007c68:	02 80 00 14 	be  40007cb8 <_TOD_Validate+0xc0>              <== NEVER TAKEN
40007c6c:	80 a0 60 0c 	cmp  %g1, 0xc                                  
      (the_tod->month  == 0)                      ||                  
40007c70:	18 80 00 12 	bgu  40007cb8 <_TOD_Validate+0xc0>             
40007c74:	01 00 00 00 	nop                                            
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
40007c78:	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)    ||                  
40007c7c:	80 a0 e7 c3 	cmp  %g3, 0x7c3                                
40007c80:	08 80 00 0e 	bleu  40007cb8 <_TOD_Validate+0xc0>            
40007c84:	01 00 00 00 	nop                                            
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
40007c88:	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)          ||                  
40007c8c:	80 a0 a0 00 	cmp  %g2, 0                                    
40007c90:	02 80 00 0a 	be  40007cb8 <_TOD_Validate+0xc0>              <== NEVER TAKEN
40007c94:	80 88 e0 03 	btst  3, %g3                                   
40007c98:	07 10 00 77 	sethi  %hi(0x4001dc00), %g3                    
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
40007c9c:	12 80 00 03 	bne  40007ca8 <_TOD_Validate+0xb0>             
40007ca0:	86 10 e0 18 	or  %g3, 0x18, %g3	! 4001dc18 <_TOD_Days_per_month>
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
40007ca4:	82 00 60 0d 	add  %g1, 0xd, %g1                             
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
40007ca8:	83 28 60 02 	sll  %g1, 2, %g1                               
40007cac:	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(                                                   
40007cb0:	80 a0 40 02 	cmp  %g1, %g2                                  
40007cb4:	b0 60 3f ff 	subx  %g0, -1, %i0                             
                                                                      
  if ( the_tod->day > days_in_month )                                 
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
40007cb8:	81 c7 e0 08 	ret                                            
40007cbc:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40008728 <_Thread_Change_priority>:                                   
void _Thread_Change_priority(                                         
  Thread_Control   *the_thread,                                       
  Priority_Control  new_priority,                                     
  bool              prepend_it                                        
)                                                                     
{                                                                     
40008728:	9d e3 bf a0 	save  %sp, -96, %sp                            
*/                                                                    
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
4000872c:	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 );                                
40008730:	40 00 04 0b 	call  4000975c <_Thread_Set_transient>         
40008734:	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 )                  
40008738:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4000873c:	80 a0 40 19 	cmp  %g1, %i1                                  
40008740:	02 80 00 05 	be  40008754 <_Thread_Change_priority+0x2c>    
40008744:	a0 10 00 18 	mov  %i0, %l0                                  
    _Thread_Set_priority( the_thread, new_priority );                 
40008748:	90 10 00 18 	mov  %i0, %o0                                  
4000874c:	40 00 03 87 	call  40009568 <_Thread_Set_priority>          
40008750:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  _ISR_Disable( level );                                              
40008754:	7f ff e5 78 	call  40001d34 <sparc_disable_interrupts>      
40008758:	01 00 00 00 	nop                                            
4000875c:	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;                                  
40008760:	f2 04 20 10 	ld  [ %l0 + 0x10 ], %i1                        
  if ( state != STATES_TRANSIENT ) {                                  
40008764:	80 a6 60 04 	cmp  %i1, 4                                    
40008768:	02 80 00 10 	be  400087a8 <_Thread_Change_priority+0x80>    
4000876c:	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 ) )                   
40008770:	80 a4 60 00 	cmp  %l1, 0                                    
40008774:	12 80 00 03 	bne  40008780 <_Thread_Change_priority+0x58>   <== NEVER TAKEN
40008778:	82 0e 7f fb 	and  %i1, -5, %g1                              
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
4000877c:	c2 24 20 10 	st  %g1, [ %l0 + 0x10 ]                        
    _ISR_Enable( level );                                             
40008780:	7f ff e5 71 	call  40001d44 <sparc_enable_interrupts>       
40008784:	90 10 00 18 	mov  %i0, %o0                                  
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
40008788:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
4000878c:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
40008790:	80 8e 40 01 	btst  %i1, %g1                                 
40008794:	02 80 00 5c 	be  40008904 <_Thread_Change_priority+0x1dc>   
40008798:	01 00 00 00 	nop                                            
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
4000879c:	f0 04 20 44 	ld  [ %l0 + 0x44 ], %i0                        
400087a0:	40 00 03 45 	call  400094b4 <_Thread_queue_Requeue>         
400087a4:	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 ) ) {                   
400087a8:	80 a4 60 00 	cmp  %l1, 0                                    
400087ac:	12 80 00 1c 	bne  4000881c <_Thread_Change_priority+0xf4>   <== NEVER TAKEN
400087b0:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (                  
  Priority_Information *the_priority_map                              
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
400087b4:	c2 04 20 90 	ld  [ %l0 + 0x90 ], %g1                        
400087b8:	c4 14 20 96 	lduh  [ %l0 + 0x96 ], %g2                      
400087bc:	c6 10 40 00 	lduh  [ %g1 ], %g3                             
     *  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 );
400087c0:	c0 24 20 10 	clr  [ %l0 + 0x10 ]                            
400087c4:	84 10 c0 02 	or  %g3, %g2, %g2                              
400087c8:	c4 30 40 00 	sth  %g2, [ %g1 ]                              
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
400087cc:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400087d0:	c6 14 20 94 	lduh  [ %l0 + 0x94 ], %g3                      
400087d4:	c4 10 60 08 	lduh  [ %g1 + 8 ], %g2                         
                                                                      
    _Priority_Add_to_bit_map( &the_thread->Priority_map );            
    if ( prepend_it )                                                 
400087d8:	80 8e a0 ff 	btst  0xff, %i2                                
400087dc:	84 10 c0 02 	or  %g3, %g2, %g2                              
400087e0:	c4 30 60 08 	sth  %g2, [ %g1 + 8 ]                          
400087e4:	02 80 00 08 	be  40008804 <_Thread_Change_priority+0xdc>    
400087e8:	c2 04 20 8c 	ld  [ %l0 + 0x8c ], %g1                        
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
400087ec:	c4 00 40 00 	ld  [ %g1 ], %g2                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
400087f0:	c2 24 20 04 	st  %g1, [ %l0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
400087f4:	e0 20 40 00 	st  %l0, [ %g1 ]                               
  the_node->next        = before_node;                                
400087f8:	c4 24 00 00 	st  %g2, [ %l0 ]                               
  before_node->previous = the_node;                                   
400087fc:	10 80 00 08 	b  4000881c <_Thread_Change_priority+0xf4>     
40008800:	e0 20 a0 04 	st  %l0, [ %g2 + 4 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
40008804:	84 00 60 04 	add  %g1, 4, %g2                               
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *old_last_node;                                          
                                                                      
  the_node->next      = _Chain_Tail(the_chain);                       
40008808:	c4 24 00 00 	st  %g2, [ %l0 ]                               
  old_last_node       = the_chain->last;                              
4000880c:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
  the_chain->last     = the_node;                                     
40008810:	e0 20 60 08 	st  %l0, [ %g1 + 8 ]                           
  old_last_node->next = the_node;                                     
40008814:	e0 20 80 00 	st  %l0, [ %g2 ]                               
  the_node->previous  = old_last_node;                                
40008818:	c4 24 20 04 	st  %g2, [ %l0 + 4 ]                           
      _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
    else                                                              
      _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
4000881c:	7f ff e5 4a 	call  40001d44 <sparc_enable_interrupts>       
40008820:	90 10 00 18 	mov  %i0, %o0                                  
40008824:	7f ff e5 44 	call  40001d34 <sparc_disable_interrupts>      
40008828:	01 00 00 00 	nop                                            
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )              
{                                                                     
  _Thread_Heir = (Thread_Control *)                                   
    _Thread_Ready_chain[ _Priority_Get_highest() ].first;             
4000882c:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40008830:	da 00 62 c4 	ld  [ %g1 + 0x2c4 ], %o5	! 400152c4 <_Thread_Ready_chain>
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )   
{                                                                     
  Priority_Bit_map_control minor;                                     
  Priority_Bit_map_control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
40008834:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40008838:	c4 10 60 08 	lduh  [ %g1 + 8 ], %g2	! 40015408 <_Priority_Major_bit_map>
4000883c:	03 10 00 4f 	sethi  %hi(0x40013c00), %g1                    
40008840:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40008844:	87 30 a0 10 	srl  %g2, 0x10, %g3                            
40008848:	80 a0 e0 ff 	cmp  %g3, 0xff                                 
4000884c:	18 80 00 05 	bgu  40008860 <_Thread_Change_priority+0x138>  
40008850:	82 10 63 d8 	or  %g1, 0x3d8, %g1                            
40008854:	c4 08 40 03 	ldub  [ %g1 + %g3 ], %g2                       
40008858:	10 80 00 04 	b  40008868 <_Thread_Change_priority+0x140>    
4000885c:	84 00 a0 08 	add  %g2, 8, %g2                               
40008860:	85 30 a0 18 	srl  %g2, 0x18, %g2                            
40008864:	c4 08 40 02 	ldub  [ %g1 + %g2 ], %g2                       
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
40008868:	83 28 a0 10 	sll  %g2, 0x10, %g1                            
4000886c:	07 10 00 55 	sethi  %hi(0x40015400), %g3                    
40008870:	83 30 60 0f 	srl  %g1, 0xf, %g1                             
40008874:	86 10 e0 80 	or  %g3, 0x80, %g3                             
40008878:	c6 10 c0 01 	lduh  [ %g3 + %g1 ], %g3                       
4000887c:	03 10 00 4f 	sethi  %hi(0x40013c00), %g1                    
40008880:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40008884:	89 30 e0 10 	srl  %g3, 0x10, %g4                            
40008888:	80 a1 20 ff 	cmp  %g4, 0xff                                 
4000888c:	18 80 00 05 	bgu  400088a0 <_Thread_Change_priority+0x178>  
40008890:	82 10 63 d8 	or  %g1, 0x3d8, %g1                            
40008894:	c2 08 40 04 	ldub  [ %g1 + %g4 ], %g1                       
40008898:	10 80 00 04 	b  400088a8 <_Thread_Change_priority+0x180>    
4000889c:	82 00 60 08 	add  %g1, 8, %g1                               
400088a0:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
400088a4:	c2 08 40 03 	ldub  [ %g1 + %g3 ], %g1                       
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
          _Priority_Bits_index( minor );                              
400088a8:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400088ac:	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) +                       
400088b0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400088b4:	85 30 a0 0c 	srl  %g2, 0xc, %g2                             
400088b8:	84 00 40 02 	add  %g1, %g2, %g2                             
400088bc:	83 28 a0 02 	sll  %g2, 2, %g1                               
400088c0:	85 28 a0 04 	sll  %g2, 4, %g2                               
400088c4:	84 20 80 01 	sub  %g2, %g1, %g2                             
 *  ready thread.                                                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )              
{                                                                     
  _Thread_Heir = (Thread_Control *)                                   
400088c8:	c6 03 40 02 	ld  [ %o5 + %g2 ], %g3                         
400088cc:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400088d0:	82 10 61 cc 	or  %g1, 0x1cc, %g1	! 400155cc <_Per_CPU_Information>
 *  is also the heir thread, and false otherwise.                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )  
{                                                                     
  return ( _Thread_Executing == _Thread_Heir );                       
400088d4:	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.               
   */                                                                 
  _Thread_Calculate_heir();                                           
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
400088d8:	80 a0 80 03 	cmp  %g2, %g3                                  
400088dc:	02 80 00 08 	be  400088fc <_Thread_Change_priority+0x1d4>   
400088e0:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
400088e4:	c4 08 a0 74 	ldub  [ %g2 + 0x74 ], %g2                      
400088e8:	80 a0 a0 00 	cmp  %g2, 0                                    
400088ec:	02 80 00 04 	be  400088fc <_Thread_Change_priority+0x1d4>   
400088f0:	01 00 00 00 	nop                                            
       _Thread_Executing->is_preemptible )                            
    _Context_Switch_necessary = true;                                 
400088f4:	84 10 20 01 	mov  1, %g2	! 1 <PROM_START+0x1>               
400088f8:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
  _ISR_Enable( level );                                               
400088fc:	7f ff e5 12 	call  40001d44 <sparc_enable_interrupts>       
40008900:	81 e8 00 00 	restore                                        
40008904:	81 c7 e0 08 	ret                                            
40008908:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000890c <_Thread_Clear_state>:                                       
                                                                      
void _Thread_Clear_state(                                             
  Thread_Control *the_thread,                                         
  States_Control  state                                               
)                                                                     
{                                                                     
4000890c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
40008910:	7f ff e5 09 	call  40001d34 <sparc_disable_interrupts>      
40008914:	a0 10 00 18 	mov  %i0, %l0                                  
40008918:	b0 10 00 08 	mov  %o0, %i0                                  
    current_state = the_thread->current_state;                        
4000891c:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
                                                                      
    if ( current_state & state ) {                                    
40008920:	80 8e 40 01 	btst  %i1, %g1                                 
40008924:	02 80 00 2f 	be  400089e0 <_Thread_Clear_state+0xd4>        
40008928:	01 00 00 00 	nop                                            
RTEMS_INLINE_ROUTINE States_Control _States_Clear (                   
  States_Control states_to_clear,                                     
  States_Control current_state                                        
)                                                                     
{                                                                     
   return (current_state & ~states_to_clear);                         
4000892c:	b2 28 40 19 	andn  %g1, %i1, %i1                            
      current_state =                                                 
      the_thread->current_state = _States_Clear( state, current_state );
                                                                      
      if ( _States_Is_ready( current_state ) ) {                      
40008930:	80 a6 60 00 	cmp  %i1, 0                                    
40008934:	12 80 00 2b 	bne  400089e0 <_Thread_Clear_state+0xd4>       
40008938:	f2 24 20 10 	st  %i1, [ %l0 + 0x10 ]                        
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (                  
  Priority_Information *the_priority_map                              
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
4000893c:	c2 04 20 90 	ld  [ %l0 + 0x90 ], %g1                        
40008940:	c4 14 20 96 	lduh  [ %l0 + 0x96 ], %g2                      
40008944:	c6 10 40 00 	lduh  [ %g1 ], %g3                             
40008948:	84 10 c0 02 	or  %g3, %g2, %g2                              
4000894c:	c4 30 40 00 	sth  %g2, [ %g1 ]                              
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
40008950:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40008954:	c6 14 20 94 	lduh  [ %l0 + 0x94 ], %g3                      
40008958:	c4 10 60 08 	lduh  [ %g1 + 8 ], %g2                         
4000895c:	84 10 c0 02 	or  %g3, %g2, %g2                              
40008960:	c4 30 60 08 	sth  %g2, [ %g1 + 8 ]                          
                                                                      
        _Priority_Add_to_bit_map( &the_thread->Priority_map );        
                                                                      
        _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
40008964:	c2 04 20 8c 	ld  [ %l0 + 0x8c ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
40008968:	84 00 60 04 	add  %g1, 4, %g2                               
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *old_last_node;                                          
                                                                      
  the_node->next      = _Chain_Tail(the_chain);                       
4000896c:	c4 24 00 00 	st  %g2, [ %l0 ]                               
  old_last_node       = the_chain->last;                              
40008970:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
  the_chain->last     = the_node;                                     
40008974:	e0 20 60 08 	st  %l0, [ %g1 + 8 ]                           
  old_last_node->next = the_node;                                     
40008978:	e0 20 80 00 	st  %l0, [ %g2 ]                               
  the_node->previous  = old_last_node;                                
4000897c:	c4 24 20 04 	st  %g2, [ %l0 + 4 ]                           
                                                                      
        _ISR_Flash( level );                                          
40008980:	7f ff e4 f1 	call  40001d44 <sparc_enable_interrupts>       
40008984:	01 00 00 00 	nop                                            
40008988:	7f ff e4 eb 	call  40001d34 <sparc_disable_interrupts>      
4000898c:	01 00 00 00 	nop                                            
         *    a context switch.                                       
         *  Pseudo-ISR case:                                          
         *    Even if the thread isn't preemptible, if the new heir is
         *    a pseudo-ISR system task, we need to do a context switch.
         */                                                           
        if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
40008990:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40008994:	82 10 61 cc 	or  %g1, 0x1cc, %g1	! 400155cc <_Per_CPU_Information>
40008998:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
4000899c:	c4 04 20 14 	ld  [ %l0 + 0x14 ], %g2                        
400089a0:	c6 00 e0 14 	ld  [ %g3 + 0x14 ], %g3                        
400089a4:	80 a0 80 03 	cmp  %g2, %g3                                  
400089a8:	1a 80 00 0e 	bcc  400089e0 <_Thread_Clear_state+0xd4>       
400089ac:	01 00 00 00 	nop                                            
          _Thread_Heir = the_thread;                                  
400089b0:	e0 20 60 10 	st  %l0, [ %g1 + 0x10 ]                        
          if ( _Thread_Executing->is_preemptible ||                   
400089b4:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
400089b8:	c2 08 60 74 	ldub  [ %g1 + 0x74 ], %g1                      
400089bc:	80 a0 60 00 	cmp  %g1, 0                                    
400089c0:	32 80 00 05 	bne,a   400089d4 <_Thread_Clear_state+0xc8>    
400089c4:	84 10 20 01 	mov  1, %g2                                    
400089c8:	80 a0 a0 00 	cmp  %g2, 0                                    
400089cc:	12 80 00 05 	bne  400089e0 <_Thread_Clear_state+0xd4>       <== ALWAYS TAKEN
400089d0:	84 10 20 01 	mov  1, %g2                                    
               the_thread->current_priority == 0 )                    
            _Context_Switch_necessary = true;                         
400089d4:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400089d8:	82 10 61 cc 	or  %g1, 0x1cc, %g1	! 400155cc <_Per_CPU_Information>
400089dc:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
        }                                                             
      }                                                               
  }                                                                   
  _ISR_Enable( level );                                               
400089e0:	7f ff e4 d9 	call  40001d44 <sparc_enable_interrupts>       
400089e4:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40008b68 <_Thread_Delay_ended>:                                       
                                                                      
void _Thread_Delay_ended(                                             
  Objects_Id  id,                                                     
  void       *ignored __attribute__((unused))                         
)                                                                     
{                                                                     
40008b68:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
40008b6c:	90 10 00 18 	mov  %i0, %o0                                  
40008b70:	40 00 00 5f 	call  40008cec <_Thread_Get>                   
40008b74:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40008b78:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008b7c:	80 a0 60 00 	cmp  %g1, 0                                    
40008b80:	12 80 00 08 	bne  40008ba0 <_Thread_Delay_ended+0x38>       <== NEVER TAKEN
40008b84:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
40008b88:	7f ff ff 61 	call  4000890c <_Thread_Clear_state>           
40008b8c:	92 12 60 18 	or  %o1, 0x18, %o1	! 10000018 <RAM_SIZE+0xfc00018>
40008b90:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40008b94:	c4 00 63 68 	ld  [ %g1 + 0x368 ], %g2	! 40015368 <_Thread_Dispatch_disable_level>
40008b98:	84 00 bf ff 	add  %g2, -1, %g2                              
40008b9c:	c4 20 63 68 	st  %g2, [ %g1 + 0x368 ]                       
40008ba0:	81 c7 e0 08 	ret                                            
40008ba4:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40008ba8 <_Thread_Dispatch>:                                          
 *    dispatch thread                                                 
 *    no dispatch thread                                              
 */                                                                   
                                                                      
void _Thread_Dispatch( void )                                         
{                                                                     
40008ba8:	9d e3 bf 90 	save  %sp, -112, %sp                           
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
40008bac:	2b 10 00 55 	sethi  %hi(0x40015400), %l5                    
40008bb0:	82 15 61 cc 	or  %l5, 0x1cc, %g1	! 400155cc <_Per_CPU_Information>
  _ISR_Disable( level );                                              
40008bb4:	7f ff e4 60 	call  40001d34 <sparc_disable_interrupts>      
40008bb8:	e2 00 60 0c 	ld  [ %g1 + 0xc ], %l1                         
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
        _Timestamp_Subtract(                                          
40008bbc:	25 10 00 55 	sethi  %hi(0x40015400), %l2                    
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Context_Switch_necessary == true ) {                       
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
40008bc0:	39 10 00 54 	sethi  %hi(0x40015000), %i4                    
40008bc4:	ba 10 20 01 	mov  1, %i5                                    
#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;            
40008bc8:	2f 10 00 54 	sethi  %hi(0x40015000), %l7                    
    _ISR_Enable( level );                                             
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
40008bcc:	a8 07 bf f8 	add  %fp, -8, %l4                              
        _Timestamp_Subtract(                                          
40008bd0:	a6 07 bf f0 	add  %fp, -16, %l3                             
40008bd4:	a4 14 a0 18 	or  %l2, 0x18, %l2                             
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Context_Switch_necessary == true ) {                       
40008bd8:	10 80 00 2b 	b  40008c84 <_Thread_Dispatch+0xdc>            
40008bdc:	2d 10 00 54 	sethi  %hi(0x40015000), %l6                    
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
40008be0:	fa 27 23 68 	st  %i5, [ %i4 + 0x368 ]                       
    _Context_Switch_necessary = false;                                
40008be4:	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 )                                          
40008be8:	80 a4 00 11 	cmp  %l0, %l1                                  
40008bec:	02 80 00 2b 	be  40008c98 <_Thread_Dispatch+0xf0>           
40008bf0:	e0 20 60 0c 	st  %l0, [ %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 )
40008bf4:	c2 04 20 7c 	ld  [ %l0 + 0x7c ], %g1                        
40008bf8:	80 a0 60 01 	cmp  %g1, 1                                    
40008bfc:	12 80 00 03 	bne  40008c08 <_Thread_Dispatch+0x60>          
40008c00:	c2 05 e2 c8 	ld  [ %l7 + 0x2c8 ], %g1                       
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
40008c04:	c2 24 20 78 	st  %g1, [ %l0 + 0x78 ]                        
                                                                      
    _ISR_Enable( level );                                             
40008c08:	7f ff e4 4f 	call  40001d44 <sparc_enable_interrupts>       
40008c0c:	01 00 00 00 	nop                                            
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
40008c10:	40 00 0d 93 	call  4000c25c <_TOD_Get_uptime>               
40008c14:	90 10 00 14 	mov  %l4, %o0                                  
        _Timestamp_Subtract(                                          
40008c18:	90 10 00 12 	mov  %l2, %o0                                  
40008c1c:	92 10 00 14 	mov  %l4, %o1                                  
40008c20:	40 00 03 98 	call  40009a80 <_Timespec_Subtract>            
40008c24:	94 10 00 13 	mov  %l3, %o2                                  
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
40008c28:	90 04 60 84 	add  %l1, 0x84, %o0                            
40008c2c:	40 00 03 7c 	call  40009a1c <_Timespec_Add_to>              
40008c30:	92 10 00 13 	mov  %l3, %o1                                  
        _Thread_Time_of_last_context_switch = uptime;                 
40008c34:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40008c38:	c2 24 80 00 	st  %g1, [ %l2 ]                               
40008c3c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008c40:	c2 24 a0 04 	st  %g1, [ %l2 + 4 ]                           
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
40008c44:	c2 05 a3 ec 	ld  [ %l6 + 0x3ec ], %g1                       
40008c48:	80 a0 60 00 	cmp  %g1, 0                                    
40008c4c:	02 80 00 06 	be  40008c64 <_Thread_Dispatch+0xbc>           <== NEVER TAKEN
40008c50:	90 10 00 11 	mov  %l1, %o0                                  
      executing->libc_reent = *_Thread_libc_reent;                    
40008c54:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40008c58:	c4 24 61 58 	st  %g2, [ %l1 + 0x158 ]                       
      *_Thread_libc_reent = heir->libc_reent;                         
40008c5c:	c4 04 21 58 	ld  [ %l0 + 0x158 ], %g2                       
40008c60:	c4 20 40 00 	st  %g2, [ %g1 ]                               
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
40008c64:	40 00 04 37 	call  40009d40 <_User_extensions_Thread_switch>
40008c68:	92 10 00 10 	mov  %l0, %o1                                  
    if ( executing->fp_context != NULL )                              
      _Context_Save_fp( &executing->fp_context );                     
#endif                                                                
#endif                                                                
                                                                      
    _Context_Switch( &executing->Registers, &heir->Registers );       
40008c6c:	90 04 60 d0 	add  %l1, 0xd0, %o0                            
40008c70:	40 00 05 26 	call  4000a108 <_CPU_Context_switch>           
40008c74:	92 04 20 d0 	add  %l0, 0xd0, %o1                            
    if ( executing->fp_context != NULL )                              
      _Context_Restore_fp( &executing->fp_context );                  
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
40008c78:	82 15 61 cc 	or  %l5, 0x1cc, %g1                            
                                                                      
    _ISR_Disable( level );                                            
40008c7c:	7f ff e4 2e 	call  40001d34 <sparc_disable_interrupts>      
40008c80:	e2 00 60 0c 	ld  [ %g1 + 0xc ], %l1                         
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Context_Switch_necessary == true ) {                       
40008c84:	82 15 61 cc 	or  %l5, 0x1cc, %g1                            
40008c88:	c4 08 60 18 	ldub  [ %g1 + 0x18 ], %g2                      
40008c8c:	80 a0 a0 00 	cmp  %g2, 0                                    
40008c90:	32 bf ff d4 	bne,a   40008be0 <_Thread_Dispatch+0x38>       
40008c94:	e0 00 60 10 	ld  [ %g1 + 0x10 ], %l0                        
                                                                      
    _ISR_Disable( level );                                            
  }                                                                   
                                                                      
post_switch:                                                          
  _Thread_Dispatch_disable_level = 0;                                 
40008c98:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40008c9c:	c0 20 63 68 	clr  [ %g1 + 0x368 ]	! 40015368 <_Thread_Dispatch_disable_level>
                                                                      
  _ISR_Enable( level );                                               
40008ca0:	7f ff e4 29 	call  40001d44 <sparc_enable_interrupts>       
40008ca4:	01 00 00 00 	nop                                            
                                                                      
  _API_extensions_Run_postswitch();                                   
40008ca8:	7f ff f9 a7 	call  40007344 <_API_extensions_Run_postswitch>
40008cac:	01 00 00 00 	nop                                            
}                                                                     
40008cb0:	81 c7 e0 08 	ret                                            
40008cb4:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40008cec <_Thread_Get>:                                               
                                                                      
Thread_Control *_Thread_Get (                                         
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
40008cec:	82 10 00 08 	mov  %o0, %g1                                  
  uint32_t             the_class;                                     
  Objects_Information **api_information;                              
  Objects_Information *information;                                   
  Thread_Control      *tp = (Thread_Control *) 0;                     
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {           
40008cf0:	80 a2 20 00 	cmp  %o0, 0                                    
40008cf4:	12 80 00 0a 	bne  40008d1c <_Thread_Get+0x30>               
40008cf8:	94 10 00 09 	mov  %o1, %o2                                  
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
40008cfc:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40008d00:	c4 00 63 68 	ld  [ %g1 + 0x368 ], %g2	! 40015368 <_Thread_Dispatch_disable_level>
40008d04:	84 00 a0 01 	inc  %g2                                       
40008d08:	c4 20 63 68 	st  %g2, [ %g1 + 0x368 ]                       
    _Thread_Disable_dispatch();                                       
    *location = OBJECTS_LOCAL;                                        
    tp = _Thread_Executing;                                           
40008d0c:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
  Objects_Information *information;                                   
  Thread_Control      *tp = (Thread_Control *) 0;                     
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {           
    _Thread_Disable_dispatch();                                       
    *location = OBJECTS_LOCAL;                                        
40008d10:	c0 22 40 00 	clr  [ %o1 ]                                   
    tp = _Thread_Executing;                                           
    goto done;                                                        
40008d14:	81 c3 e0 08 	retl                                           
40008d18:	d0 00 61 d8 	ld  [ %g1 + 0x1d8 ], %o0                       
 */                                                                   
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(                   
  Objects_Id id                                                       
)                                                                     
{                                                                     
  return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
40008d1c:	87 32 20 18 	srl  %o0, 0x18, %g3                            
40008d20:	86 08 e0 07 	and  %g3, 7, %g3                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(                      
  uint32_t   the_api                                                  
)                                                                     
{                                                                     
  if ( !the_api || the_api > OBJECTS_APIS_LAST )                      
40008d24:	84 00 ff ff 	add  %g3, -1, %g2                              
40008d28:	80 a0 a0 02 	cmp  %g2, 2                                    
40008d2c:	28 80 00 16 	bleu,a   40008d84 <_Thread_Get+0x98>           
40008d30:	85 32 20 1b 	srl  %o0, 0x1b, %g2                            
    goto done;                                                        
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
    *location = OBJECTS_ERROR;                                        
40008d34:	82 10 20 01 	mov  1, %g1                                    
40008d38:	10 80 00 09 	b  40008d5c <_Thread_Get+0x70>                 
40008d3c:	c2 22 80 00 	st  %g1, [ %o2 ]                               
    goto done;                                                        
  }                                                                   
                                                                      
  api_information = _Objects_Information_table[ the_api ];            
40008d40:	09 10 00 54 	sethi  %hi(0x40015000), %g4                    
40008d44:	88 11 22 cc 	or  %g4, 0x2cc, %g4	! 400152cc <_Objects_Information_table>
40008d48:	c6 01 00 03 	ld  [ %g4 + %g3 ], %g3                         
  if ( !api_information ) {                                           
40008d4c:	80 a0 e0 00 	cmp  %g3, 0                                    
40008d50:	32 80 00 05 	bne,a   40008d64 <_Thread_Get+0x78>            <== ALWAYS TAKEN
40008d54:	d0 00 e0 04 	ld  [ %g3 + 4 ], %o0                           
    *location = OBJECTS_ERROR;                                        
40008d58:	c4 22 80 00 	st  %g2, [ %o2 ]                               <== NOT EXECUTED
    goto done;                                                        
40008d5c:	81 c3 e0 08 	retl                                           
40008d60:	90 10 20 00 	clr  %o0                                       
  }                                                                   
                                                                      
  information = api_information[ the_class ];                         
  if ( !information ) {                                               
40008d64:	80 a2 20 00 	cmp  %o0, 0                                    
40008d68:	12 80 00 04 	bne  40008d78 <_Thread_Get+0x8c>               
40008d6c:	92 10 00 01 	mov  %g1, %o1                                  
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
40008d70:	81 c3 e0 08 	retl                                           
40008d74:	c4 22 80 00 	st  %g2, [ %o2 ]                               
  }                                                                   
                                                                      
  tp = (Thread_Control *) _Objects_Get( information, id, location );  
40008d78:	82 13 c0 00 	mov  %o7, %g1                                  
40008d7c:	7f ff fd 83 	call  40008388 <_Objects_Get>                  
40008d80:	9e 10 40 00 	mov  %g1, %o7                                  
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
40008d84:	80 a0 a0 01 	cmp  %g2, 1                                    
40008d88:	22 bf ff ee 	be,a   40008d40 <_Thread_Get+0x54>             
40008d8c:	87 28 e0 02 	sll  %g3, 2, %g3                               
    *location = OBJECTS_ERROR;                                        
40008d90:	10 bf ff ea 	b  40008d38 <_Thread_Get+0x4c>                 
40008d94:	82 10 20 01 	mov  1, %g1                                    
                                                                      
===============================================================================
4000e038 <_Thread_Handler>:                                           
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Thread_Handler( void )                                          
{                                                                     
4000e038:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static char doneConstructors;                                     
    char doneCons;                                                    
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
4000e03c:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
4000e040:	e0 00 61 d8 	ld  [ %g1 + 0x1d8 ], %l0	! 400155d8 <_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();                          
4000e044:	3f 10 00 38 	sethi  %hi(0x4000e000), %i7                    
4000e048:	be 17 e0 38 	or  %i7, 0x38, %i7	! 4000e038 <_Thread_Handler>
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
                                                                      
  level = executing->Start.isr_level;                                 
4000e04c:	d0 04 20 b8 	ld  [ %l0 + 0xb8 ], %o0                        
  _ISR_Set_level(level);                                              
4000e050:	7f ff cf 3d 	call  40001d44 <sparc_enable_interrupts>       
4000e054:	91 2a 20 08 	sll  %o0, 8, %o0                               
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
4000e058:	03 10 00 53 	sethi  %hi(0x40014c00), %g1                    
    doneConstructors = 1;                                             
4000e05c:	84 10 20 01 	mov  1, %g2                                    
                                                                      
  level = executing->Start.isr_level;                                 
  _ISR_Set_level(level);                                              
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
4000e060:	e2 08 63 ec 	ldub  [ %g1 + 0x3ec ], %l1                     
  /*                                                                  
   * 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 );                         
4000e064:	90 10 00 10 	mov  %l0, %o0                                  
4000e068:	7f ff ee c6 	call  40009b80 <_User_extensions_Thread_begin> 
4000e06c:	c4 28 63 ec 	stb  %g2, [ %g1 + 0x3ec ]                      
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
4000e070:	7f ff eb 12 	call  40008cb8 <_Thread_Enable_dispatch>       
4000e074:	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) */ {                 
4000e078:	80 a4 60 00 	cmp  %l1, 0                                    
4000e07c:	32 80 00 05 	bne,a   4000e090 <_Thread_Handler+0x58>        
4000e080:	c2 04 20 a0 	ld  [ %l0 + 0xa0 ], %g1                        
      INIT_NAME ();                                                   
4000e084:	40 00 19 ed 	call  40014838 <_init>                         
4000e088:	01 00 00 00 	nop                                            
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
4000e08c:	c2 04 20 a0 	ld  [ %l0 + 0xa0 ], %g1                        
4000e090:	80 a0 60 00 	cmp  %g1, 0                                    
4000e094:	12 80 00 06 	bne  4000e0ac <_Thread_Handler+0x74>           <== NEVER TAKEN
4000e098:	01 00 00 00 	nop                                            
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
4000e09c:	c2 04 20 9c 	ld  [ %l0 + 0x9c ], %g1                        
4000e0a0:	9f c0 40 00 	call  %g1                                      
4000e0a4:	d0 04 20 a8 	ld  [ %l0 + 0xa8 ], %o0                        
      INIT_NAME ();                                                   
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
    executing->Wait.return_argument =                                 
4000e0a8:	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 );                       
4000e0ac:	7f ff ee c6 	call  40009bc4 <_User_extensions_Thread_exitted>
4000e0b0:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  _Internal_error_Occurred(                                           
4000e0b4:	90 10 20 00 	clr  %o0                                       
4000e0b8:	92 10 20 01 	mov  1, %o1                                    
4000e0bc:	7f ff e7 4a 	call  40007de4 <_Internal_error_Occurred>      
4000e0c0:	94 10 20 05 	mov  5, %o2                                    
                                                                      
===============================================================================
40008d98 <_Thread_Initialize>:                                        
  Thread_CPU_budget_algorithms          budget_algorithm,             
  Thread_CPU_budget_algorithm_callout   budget_callout,               
  uint32_t                              isr_level,                    
  Objects_Name                          name                          
)                                                                     
{                                                                     
40008d98:	9d e3 bf a0 	save  %sp, -96, %sp                            
40008d9c:	c2 07 a0 6c 	ld  [ %fp + 0x6c ], %g1                        
40008da0:	e2 0f a0 5f 	ldub  [ %fp + 0x5f ], %l1                      
40008da4:	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;                             
40008da8:	c0 26 61 5c 	clr  [ %i1 + 0x15c ]                           
40008dac:	c0 26 61 60 	clr  [ %i1 + 0x160 ]                           
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
40008db0:	c0 26 61 58 	clr  [ %i1 + 0x158 ]                           
                                                                      
  /*                                                                  
   *  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 );
40008db4:	90 10 00 19 	mov  %i1, %o0                                  
40008db8:	40 00 02 8e 	call  400097f0 <_Thread_Stack_Allocate>        
40008dbc:	92 10 00 1b 	mov  %i3, %o1                                  
    if ( !actual_stack_size || actual_stack_size < stack_size )       
40008dc0:	80 a2 00 1b 	cmp  %o0, %i3                                  
40008dc4:	0a 80 00 5b 	bcs  40008f30 <_Thread_Initialize+0x198>       
40008dc8:	80 a2 20 00 	cmp  %o0, 0                                    
40008dcc:	22 80 00 57 	be,a   40008f28 <_Thread_Initialize+0x190>     <== NEVER TAKEN
40008dd0:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
40008dd4:	c2 06 60 c8 	ld  [ %i1 + 0xc8 ], %g1                        
  the_stack->size = size;                                             
40008dd8:	d0 26 60 c0 	st  %o0, [ %i1 + 0xc0 ]                        
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
40008ddc:	c2 26 60 c4 	st  %g1, [ %i1 + 0xc4 ]                        
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
40008de0:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40008de4:	d0 00 63 f8 	ld  [ %g1 + 0x3f8 ], %o0	! 400153f8 <_Thread_Maximum_extensions>
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40008de8:	c0 26 60 50 	clr  [ %i1 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
40008dec:	c0 26 60 64 	clr  [ %i1 + 0x64 ]                            
  the_watchdog->id        = id;                                       
40008df0:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
  the_watchdog->user_data = user_data;                                
40008df4:	c0 26 60 6c 	clr  [ %i1 + 0x6c ]                            
40008df8:	80 a2 20 00 	cmp  %o0, 0                                    
40008dfc:	02 80 00 08 	be  40008e1c <_Thread_Initialize+0x84>         
40008e00:	b6 10 20 00 	clr  %i3                                       
    extensions_area = _Workspace_Allocate(                            
40008e04:	90 02 20 01 	inc  %o0                                       
40008e08:	40 00 04 a2 	call  4000a090 <_Workspace_Allocate>           
40008e0c:	91 2a 20 02 	sll  %o0, 2, %o0                               
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
40008e10:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40008e14:	22 80 00 2c 	be,a   40008ec4 <_Thread_Initialize+0x12c>     
40008e18:	d0 06 61 58 	ld  [ %i1 + 0x158 ], %o0                       
   * 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 ) {                                     
40008e1c:	80 a6 e0 00 	cmp  %i3, 0                                    
40008e20:	02 80 00 0b 	be  40008e4c <_Thread_Initialize+0xb4>         
40008e24:	f6 26 61 64 	st  %i3, [ %i1 + 0x164 ]                       
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
40008e28:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40008e2c:	c4 00 63 f8 	ld  [ %g1 + 0x3f8 ], %g2	! 400153f8 <_Thread_Maximum_extensions>
40008e30:	10 80 00 04 	b  40008e40 <_Thread_Initialize+0xa8>          
40008e34:	82 10 20 00 	clr  %g1                                       
40008e38:	82 00 60 01 	inc  %g1                                       
      the_thread->extensions[i] = NULL;                               
40008e3c:	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++ )              
40008e40:	80 a0 40 02 	cmp  %g1, %g2                                  
40008e44:	08 bf ff fd 	bleu  40008e38 <_Thread_Initialize+0xa0>       
40008e48:	87 28 60 02 	sll  %g1, 2, %g3                               
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
40008e4c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
  the_thread->real_priority           = priority;                     
  the_thread->Start.initial_priority  = priority;                     
  _Thread_Set_priority( the_thread, priority );                       
40008e50:	90 10 00 19 	mov  %i1, %o0                                  
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
40008e54:	c2 26 60 b0 	st  %g1, [ %i1 + 0xb0 ]                        
  the_thread->Start.budget_callout   = budget_callout;                
40008e58:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
  the_thread->real_priority           = priority;                     
  the_thread->Start.initial_priority  = priority;                     
  _Thread_Set_priority( the_thread, priority );                       
40008e5c:	92 10 00 1d 	mov  %i5, %o1                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
40008e60:	c2 26 60 b4 	st  %g1, [ %i1 + 0xb4 ]                        
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
40008e64:	c2 07 a0 68 	ld  [ %fp + 0x68 ], %g1                        
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
40008e68:	e2 2e 60 ac 	stb  %l1, [ %i1 + 0xac ]                       
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
40008e6c:	c2 26 60 b8 	st  %g1, [ %i1 + 0xb8 ]                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
40008e70:	82 10 20 01 	mov  1, %g1                                    
  the_thread->Wait.queue              = NULL;                         
40008e74:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
40008e78:	c2 26 60 10 	st  %g1, [ %i1 + 0x10 ]                        
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
40008e7c:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  the_thread->real_priority           = priority;                     
40008e80:	fa 26 60 18 	st  %i5, [ %i1 + 0x18 ]                        
  the_thread->Start.initial_priority  = priority;                     
  _Thread_Set_priority( the_thread, priority );                       
40008e84:	40 00 01 b9 	call  40009568 <_Thread_Set_priority>          
40008e88:	fa 26 60 bc 	st  %i5, [ %i1 + 0xbc ]                        
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
                                                                      
                                                                      
}                                                                     
40008e8c:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008e90:	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 );             
40008e94:	c0 26 60 84 	clr  [ %i1 + 0x84 ]                            
40008e98:	c0 26 60 88 	clr  [ %i1 + 0x88 ]                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008e9c:	83 28 60 02 	sll  %g1, 2, %g1                               
40008ea0:	f2 20 80 01 	st  %i1, [ %g2 + %g1 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
40008ea4:	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 );    
40008ea8:	90 10 00 19 	mov  %i1, %o0                                  
40008eac:	40 00 03 68 	call  40009c4c <_User_extensions_Thread_create>
40008eb0:	b0 10 20 01 	mov  1, %i0                                    
  if ( extension_status )                                             
40008eb4:	80 8a 20 ff 	btst  0xff, %o0                                
40008eb8:	12 80 00 1f 	bne  40008f34 <_Thread_Initialize+0x19c>       
40008ebc:	01 00 00 00 	nop                                            
    return true;                                                      
                                                                      
failed:                                                               
  if ( the_thread->libc_reent )                                       
40008ec0:	d0 06 61 58 	ld  [ %i1 + 0x158 ], %o0                       
40008ec4:	80 a2 20 00 	cmp  %o0, 0                                    
40008ec8:	22 80 00 05 	be,a   40008edc <_Thread_Initialize+0x144>     
40008ecc:	d0 06 61 5c 	ld  [ %i1 + 0x15c ], %o0                       
    _Workspace_Free( the_thread->libc_reent );                        
40008ed0:	40 00 04 79 	call  4000a0b4 <_Workspace_Free>               
40008ed4:	01 00 00 00 	nop                                            
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    if ( the_thread->API_Extensions[i] )                              
40008ed8:	d0 06 61 5c 	ld  [ %i1 + 0x15c ], %o0                       
40008edc:	80 a2 20 00 	cmp  %o0, 0                                    
40008ee0:	22 80 00 05 	be,a   40008ef4 <_Thread_Initialize+0x15c>     
40008ee4:	d0 06 61 60 	ld  [ %i1 + 0x160 ], %o0                       
      _Workspace_Free( the_thread->API_Extensions[i] );               
40008ee8:	40 00 04 73 	call  4000a0b4 <_Workspace_Free>               
40008eec:	01 00 00 00 	nop                                            
failed:                                                               
  if ( the_thread->libc_reent )                                       
    _Workspace_Free( the_thread->libc_reent );                        
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    if ( the_thread->API_Extensions[i] )                              
40008ef0:	d0 06 61 60 	ld  [ %i1 + 0x160 ], %o0                       
40008ef4:	80 a2 20 00 	cmp  %o0, 0                                    
40008ef8:	02 80 00 05 	be  40008f0c <_Thread_Initialize+0x174>        <== ALWAYS TAKEN
40008efc:	80 a6 e0 00 	cmp  %i3, 0                                    
      _Workspace_Free( the_thread->API_Extensions[i] );               
40008f00:	40 00 04 6d 	call  4000a0b4 <_Workspace_Free>               <== NOT EXECUTED
40008f04:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  if ( extensions_area )                                              
40008f08:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
40008f0c:	02 80 00 05 	be  40008f20 <_Thread_Initialize+0x188>        
40008f10:	90 10 00 19 	mov  %i1, %o0                                  
    (void) _Workspace_Free( extensions_area );                        
40008f14:	40 00 04 68 	call  4000a0b4 <_Workspace_Free>               
40008f18:	90 10 00 1b 	mov  %i3, %o0                                  
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    if ( fp_area )                                                    
      (void) _Workspace_Free( fp_area );                              
  #endif                                                              
                                                                      
   _Thread_Stack_Free( the_thread );                                  
40008f1c:	90 10 00 19 	mov  %i1, %o0                                  
40008f20:	40 00 02 4b 	call  4000984c <_Thread_Stack_Free>            
40008f24:	b0 10 20 00 	clr  %i0                                       
  return false;                                                       
40008f28:	81 c7 e0 08 	ret                                            
40008f2c:	81 e8 00 00 	restore                                        
   *  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 );
    if ( !actual_stack_size || actual_stack_size < stack_size )       
      return false;                     /* stack allocation failed */ 
40008f30:	b0 10 20 00 	clr  %i0                                       
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
                                                                      
                                                                      
}                                                                     
40008f34:	81 c7 e0 08 	ret                                            
40008f38:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000cde0 <_Thread_Resume>:                                            
                                                                      
void _Thread_Resume(                                                  
  Thread_Control   *the_thread,                                       
  bool              force                                             
)                                                                     
{                                                                     
4000cde0:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
4000cde4:	7f ff d4 28 	call  40001e84 <sparc_disable_interrupts>      
4000cde8:	a0 10 00 18 	mov  %i0, %l0                                  
4000cdec:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  current_state = the_thread->current_state;                          
4000cdf0:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
  if ( current_state & STATES_SUSPENDED ) {                           
4000cdf4:	80 88 60 02 	btst  2, %g1                                   
4000cdf8:	02 80 00 2e 	be  4000ceb0 <_Thread_Resume+0xd0>             <== NEVER TAKEN
4000cdfc:	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 ) ) {                        
4000ce00:	80 a0 60 00 	cmp  %g1, 0                                    
4000ce04:	12 80 00 2b 	bne  4000ceb0 <_Thread_Resume+0xd0>            
4000ce08:	c2 24 20 10 	st  %g1, [ %l0 + 0x10 ]                        
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (                  
  Priority_Information *the_priority_map                              
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
4000ce0c:	c2 04 20 90 	ld  [ %l0 + 0x90 ], %g1                        
4000ce10:	c4 14 20 96 	lduh  [ %l0 + 0x96 ], %g2                      
4000ce14:	c6 10 40 00 	lduh  [ %g1 ], %g3                             
4000ce18:	84 10 c0 02 	or  %g3, %g2, %g2                              
4000ce1c:	c4 30 40 00 	sth  %g2, [ %g1 ]                              
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
4000ce20:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000ce24:	c6 14 20 94 	lduh  [ %l0 + 0x94 ], %g3                      
4000ce28:	c4 10 61 68 	lduh  [ %g1 + 0x168 ], %g2                     
4000ce2c:	84 10 c0 02 	or  %g3, %g2, %g2                              
4000ce30:	c4 30 61 68 	sth  %g2, [ %g1 + 0x168 ]                      
                                                                      
      _Priority_Add_to_bit_map( &the_thread->Priority_map );          
                                                                      
      _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
4000ce34:	c2 04 20 8c 	ld  [ %l0 + 0x8c ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
4000ce38:	84 00 60 04 	add  %g1, 4, %g2                               
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *old_last_node;                                          
                                                                      
  the_node->next      = _Chain_Tail(the_chain);                       
4000ce3c:	c4 24 00 00 	st  %g2, [ %l0 ]                               
  old_last_node       = the_chain->last;                              
4000ce40:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
  the_chain->last     = the_node;                                     
4000ce44:	e0 20 60 08 	st  %l0, [ %g1 + 8 ]                           
  old_last_node->next = the_node;                                     
4000ce48:	e0 20 80 00 	st  %l0, [ %g2 ]                               
  the_node->previous  = old_last_node;                                
4000ce4c:	c4 24 20 04 	st  %g2, [ %l0 + 4 ]                           
                                                                      
      _ISR_Flash( level );                                            
4000ce50:	7f ff d4 11 	call  40001e94 <sparc_enable_interrupts>       
4000ce54:	01 00 00 00 	nop                                            
4000ce58:	7f ff d4 0b 	call  40001e84 <sparc_disable_interrupts>      
4000ce5c:	01 00 00 00 	nop                                            
                                                                      
      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
4000ce60:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000ce64:	82 10 63 2c 	or  %g1, 0x32c, %g1	! 4001972c <_Per_CPU_Information>
4000ce68:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
4000ce6c:	c4 04 20 14 	ld  [ %l0 + 0x14 ], %g2                        
4000ce70:	c6 00 e0 14 	ld  [ %g3 + 0x14 ], %g3                        
4000ce74:	80 a0 80 03 	cmp  %g2, %g3                                  
4000ce78:	1a 80 00 0e 	bcc  4000ceb0 <_Thread_Resume+0xd0>            
4000ce7c:	01 00 00 00 	nop                                            
        _Thread_Heir = the_thread;                                    
4000ce80:	e0 20 60 10 	st  %l0, [ %g1 + 0x10 ]                        
        if ( _Thread_Executing->is_preemptible ||                     
4000ce84:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000ce88:	c2 08 60 74 	ldub  [ %g1 + 0x74 ], %g1                      
4000ce8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ce90:	32 80 00 05 	bne,a   4000cea4 <_Thread_Resume+0xc4>         
4000ce94:	84 10 20 01 	mov  1, %g2                                    
4000ce98:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ce9c:	12 80 00 05 	bne  4000ceb0 <_Thread_Resume+0xd0>            <== ALWAYS TAKEN
4000cea0:	84 10 20 01 	mov  1, %g2                                    
             the_thread->current_priority == 0 )                      
          _Context_Switch_necessary = true;                           
4000cea4:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000cea8:	82 10 63 2c 	or  %g1, 0x32c, %g1	! 4001972c <_Per_CPU_Information>
4000ceac:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000ceb0:	7f ff d3 f9 	call  40001e94 <sparc_enable_interrupts>       
4000ceb4:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40009974 <_Thread_Yield_processor>:                                   
 *    ready chain                                                     
 *    select heir                                                     
 */                                                                   
                                                                      
void _Thread_Yield_processor( void )                                  
{                                                                     
40009974:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  Thread_Control *executing;                                          
  Chain_Control  *ready;                                              
                                                                      
  executing = _Thread_Executing;                                      
40009978:	23 10 00 55 	sethi  %hi(0x40015400), %l1                    
4000997c:	a2 14 61 cc 	or  %l1, 0x1cc, %l1	! 400155cc <_Per_CPU_Information>
40009980:	e0 04 60 0c 	ld  [ %l1 + 0xc ], %l0                         
  ready     = executing->ready;                                       
  _ISR_Disable( level );                                              
40009984:	7f ff e0 ec 	call  40001d34 <sparc_disable_interrupts>      
40009988:	e4 04 20 8c 	ld  [ %l0 + 0x8c ], %l2                        
4000998c:	b0 10 00 08 	mov  %o0, %i0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Has_only_one_node(                   
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return (the_chain->first == the_chain->last);                       
40009990:	c2 04 a0 08 	ld  [ %l2 + 8 ], %g1                           
    if ( !_Chain_Has_only_one_node( ready ) ) {                       
40009994:	c4 04 80 00 	ld  [ %l2 ], %g2                               
40009998:	80 a0 80 01 	cmp  %g2, %g1                                  
4000999c:	22 80 00 19 	be,a   40009a00 <_Thread_Yield_processor+0x8c> 
400099a0:	c2 04 60 10 	ld  [ %l1 + 0x10 ], %g1                        
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
400099a4:	c6 04 00 00 	ld  [ %l0 ], %g3                               
  previous       = the_node->previous;                                
400099a8:	c4 04 20 04 	ld  [ %l0 + 4 ], %g2                           
  next->previous = previous;                                          
  previous->next = next;                                              
400099ac:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
400099b0:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
400099b4:	84 04 a0 04 	add  %l2, 4, %g2                               
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *old_last_node;                                          
                                                                      
  the_node->next      = _Chain_Tail(the_chain);                       
400099b8:	c4 24 00 00 	st  %g2, [ %l0 ]                               
  old_last_node       = the_chain->last;                              
  the_chain->last     = the_node;                                     
400099bc:	e0 24 a0 08 	st  %l0, [ %l2 + 8 ]                           
  old_last_node->next = the_node;                                     
400099c0:	e0 20 40 00 	st  %l0, [ %g1 ]                               
  the_node->previous  = old_last_node;                                
400099c4:	c2 24 20 04 	st  %g1, [ %l0 + 4 ]                           
      _Chain_Extract_unprotected( &executing->Object.Node );          
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
400099c8:	7f ff e0 df 	call  40001d44 <sparc_enable_interrupts>       
400099cc:	01 00 00 00 	nop                                            
400099d0:	7f ff e0 d9 	call  40001d34 <sparc_disable_interrupts>      
400099d4:	01 00 00 00 	nop                                            
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
400099d8:	c2 04 60 10 	ld  [ %l1 + 0x10 ], %g1                        
400099dc:	80 a4 00 01 	cmp  %l0, %g1                                  
400099e0:	12 80 00 04 	bne  400099f0 <_Thread_Yield_processor+0x7c>   <== NEVER TAKEN
400099e4:	84 10 20 01 	mov  1, %g2                                    
        _Thread_Heir = (Thread_Control *) ready->first;               
400099e8:	c2 04 80 00 	ld  [ %l2 ], %g1                               
400099ec:	c2 24 60 10 	st  %g1, [ %l1 + 0x10 ]                        
      _Context_Switch_necessary = true;                               
400099f0:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
400099f4:	82 10 61 cc 	or  %g1, 0x1cc, %g1	! 400155cc <_Per_CPU_Information>
400099f8:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
400099fc:	30 80 00 05 	b,a   40009a10 <_Thread_Yield_processor+0x9c>  
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
40009a00:	80 a4 00 01 	cmp  %l0, %g1                                  
40009a04:	02 80 00 03 	be  40009a10 <_Thread_Yield_processor+0x9c>    <== ALWAYS TAKEN
40009a08:	82 10 20 01 	mov  1, %g1                                    
      _Context_Switch_necessary = true;                               
40009a0c:	c2 2c 60 18 	stb  %g1, [ %l1 + 0x18 ]                       <== NOT EXECUTED
                                                                      
  _ISR_Enable( level );                                               
40009a10:	7f ff e0 cd 	call  40001d44 <sparc_enable_interrupts>       
40009a14:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000c800 <_Thread_queue_Extract_priority_helper>:                     
void _Thread_queue_Extract_priority_helper(                           
  Thread_queue_Control *the_thread_queue __attribute__((unused)),     
  Thread_Control       *the_thread,                                   
  bool                  requeuing                                     
)                                                                     
{                                                                     
4000c800:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Chain_Node     *new_first_node;                                     
  Chain_Node     *new_second_node;                                    
  Chain_Node     *last_node;                                          
                                                                      
  the_node = (Chain_Node *) the_thread;                               
  _ISR_Disable( level );                                              
4000c804:	7f ff d5 4c 	call  40001d34 <sparc_disable_interrupts>      
4000c808:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_ON_THREAD_QUEUE);              
4000c80c:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000c810:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
4000c814:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
4000c818:	80 88 80 01 	btst  %g2, %g1                                 
4000c81c:	32 80 00 03 	bne,a   4000c828 <_Thread_queue_Extract_priority_helper+0x28>
4000c820:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
    _ISR_Enable( level );                                             
4000c824:	30 80 00 1a 	b,a   4000c88c <_Thread_queue_Extract_priority_helper+0x8c>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
4000c828:	88 06 60 3c 	add  %i1, 0x3c, %g4                            
                                                                      
  /*                                                                  
   *  The thread was actually waiting on a thread queue so let's remove it.
   */                                                                 
                                                                      
  next_node     = the_node->next;                                     
4000c82c:	c4 06 40 00 	ld  [ %i1 ], %g2                               
  previous_node = the_node->previous;                                 
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
4000c830:	80 a0 40 04 	cmp  %g1, %g4                                  
4000c834:	02 80 00 11 	be  4000c878 <_Thread_queue_Extract_priority_helper+0x78>
4000c838:	c6 06 60 04 	ld  [ %i1 + 4 ], %g3                           
    new_first_node   = the_thread->Wait.Block2n.first;                
    new_first_thread = (Thread_Control *) new_first_node;             
    last_node        = the_thread->Wait.Block2n.last;                 
4000c83c:	c8 06 60 40 	ld  [ %i1 + 0x40 ], %g4                        
    new_second_node  = new_first_node->next;                          
4000c840:	da 00 40 00 	ld  [ %g1 ], %o5                               
                                                                      
    previous_node->next      = new_first_node;                        
    next_node->previous      = new_first_node;                        
4000c844:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
    new_first_node   = the_thread->Wait.Block2n.first;                
    new_first_thread = (Thread_Control *) new_first_node;             
    last_node        = the_thread->Wait.Block2n.last;                 
    new_second_node  = new_first_node->next;                          
                                                                      
    previous_node->next      = new_first_node;                        
4000c848:	c2 20 c0 00 	st  %g1, [ %g3 ]                               
    next_node->previous      = new_first_node;                        
    new_first_node->next     = next_node;                             
4000c84c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
    new_first_node->previous = previous_node;                         
                                                                      
    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {   
4000c850:	80 a0 40 04 	cmp  %g1, %g4                                  
4000c854:	02 80 00 0b 	be  4000c880 <_Thread_queue_Extract_priority_helper+0x80>
4000c858:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
                                        /* > two threads on 2-n */    
      new_second_node->previous =                                     
                _Chain_Head( &new_first_thread->Wait.Block2n );       
4000c85c:	84 00 60 38 	add  %g1, 0x38, %g2                            
    new_first_node->next     = next_node;                             
    new_first_node->previous = previous_node;                         
                                                                      
    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {   
                                        /* > two threads on 2-n */    
      new_second_node->previous =                                     
4000c860:	c4 23 60 04 	st  %g2, [ %o5 + 4 ]                           
                _Chain_Head( &new_first_thread->Wait.Block2n );       
      new_first_thread->Wait.Block2n.first = new_second_node;         
4000c864:	da 20 60 38 	st  %o5, [ %g1 + 0x38 ]                        
                                                                      
      new_first_thread->Wait.Block2n.last = last_node;                
4000c868:	c8 20 60 40 	st  %g4, [ %g1 + 0x40 ]                        
4000c86c:	82 00 60 3c 	add  %g1, 0x3c, %g1                            
      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
4000c870:	10 80 00 04 	b  4000c880 <_Thread_queue_Extract_priority_helper+0x80>
4000c874:	c2 21 00 00 	st  %g1, [ %g4 ]                               
    }                                                                 
  } else {                                                            
    previous_node->next = next_node;                                  
4000c878:	c4 20 c0 00 	st  %g2, [ %g3 ]                               
    next_node->previous = previous_node;                              
4000c87c:	c6 20 a0 04 	st  %g3, [ %g2 + 4 ]                           
                                                                      
  /*                                                                  
   *  If we are not supposed to touch timers or the thread's state, return.
   */                                                                 
                                                                      
  if ( requeuing ) {                                                  
4000c880:	80 8e a0 ff 	btst  0xff, %i2                                
4000c884:	22 80 00 04 	be,a   4000c894 <_Thread_queue_Extract_priority_helper+0x94>
4000c888:	c2 06 60 50 	ld  [ %i1 + 0x50 ], %g1                        
    _ISR_Enable( level );                                             
4000c88c:	7f ff d5 2e 	call  40001d44 <sparc_enable_interrupts>       
4000c890:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    return;                                                           
  }                                                                   
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
4000c894:	80 a0 60 02 	cmp  %g1, 2                                    
4000c898:	02 80 00 06 	be  4000c8b0 <_Thread_queue_Extract_priority_helper+0xb0><== NEVER TAKEN
4000c89c:	82 10 20 03 	mov  3, %g1                                    
    _ISR_Enable( level );                                             
4000c8a0:	7f ff d5 29 	call  40001d44 <sparc_enable_interrupts>       
4000c8a4:	b0 10 00 19 	mov  %i1, %i0                                  
4000c8a8:	10 80 00 08 	b  4000c8c8 <_Thread_queue_Extract_priority_helper+0xc8>
4000c8ac:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
4000c8b0:	c2 26 60 50 	st  %g1, [ %i1 + 0x50 ]	! 1003fc50 <RAM_SIZE+0xfc3fc50><== NOT EXECUTED
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
4000c8b4:	7f ff d5 24 	call  40001d44 <sparc_enable_interrupts>       <== NOT EXECUTED
4000c8b8:	b0 10 00 19 	mov  %i1, %i0                                  <== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );                    
4000c8bc:	7f ff f5 8a 	call  40009ee4 <_Watchdog_Remove>              <== NOT EXECUTED
4000c8c0:	90 06 60 48 	add  %i1, 0x48, %o0                            <== NOT EXECUTED
4000c8c4:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    <== NOT EXECUTED
4000c8c8:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1003fff8 <RAM_SIZE+0xfc3fff8>
4000c8cc:	7f ff f0 10 	call  4000890c <_Thread_Clear_state>           
4000c8d0:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
400094b4 <_Thread_queue_Requeue>:                                     
                                                                      
void _Thread_queue_Requeue(                                           
  Thread_queue_Control *the_thread_queue,                             
  Thread_Control       *the_thread                                    
)                                                                     
{                                                                     
400094b4:	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 )                                            
400094b8:	80 a6 20 00 	cmp  %i0, 0                                    
400094bc:	02 80 00 19 	be  40009520 <_Thread_queue_Requeue+0x6c>      <== NEVER TAKEN
400094c0:	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 ) {
400094c4:	e2 06 20 34 	ld  [ %i0 + 0x34 ], %l1                        
400094c8:	80 a4 60 01 	cmp  %l1, 1                                    
400094cc:	12 80 00 15 	bne  40009520 <_Thread_queue_Requeue+0x6c>     <== NEVER TAKEN
400094d0:	01 00 00 00 	nop                                            
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
400094d4:	7f ff e2 18 	call  40001d34 <sparc_disable_interrupts>      
400094d8:	01 00 00 00 	nop                                            
400094dc:	a0 10 00 08 	mov  %o0, %l0                                  
400094e0:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
400094e4:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
400094e8:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
400094ec:	80 88 80 01 	btst  %g2, %g1                                 
400094f0:	02 80 00 0a 	be  40009518 <_Thread_queue_Requeue+0x64>      <== NEVER TAKEN
400094f4:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
400094f8:	92 10 00 19 	mov  %i1, %o1                                  
400094fc:	94 10 20 01 	mov  1, %o2                                    
40009500:	40 00 0c c0 	call  4000c800 <_Thread_queue_Extract_priority_helper>
40009504:	e2 26 20 30 	st  %l1, [ %i0 + 0x30 ]                        
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
40009508:	90 10 00 18 	mov  %i0, %o0                                  
4000950c:	92 10 00 19 	mov  %i1, %o1                                  
40009510:	7f ff ff 4b 	call  4000923c <_Thread_queue_Enqueue_priority>
40009514:	94 07 bf fc 	add  %fp, -4, %o2                              
    }                                                                 
    _ISR_Enable( level );                                             
40009518:	7f ff e2 0b 	call  40001d44 <sparc_enable_interrupts>       
4000951c:	90 10 00 10 	mov  %l0, %o0                                  
40009520:	81 c7 e0 08 	ret                                            
40009524:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40009528 <_Thread_queue_Timeout>:                                     
                                                                      
void _Thread_queue_Timeout(                                           
  Objects_Id  id,                                                     
  void       *ignored __attribute__((unused))                         
)                                                                     
{                                                                     
40009528:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000952c:	90 10 00 18 	mov  %i0, %o0                                  
40009530:	7f ff fd ef 	call  40008cec <_Thread_Get>                   
40009534:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40009538:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000953c:	80 a0 60 00 	cmp  %g1, 0                                    
40009540:	12 80 00 08 	bne  40009560 <_Thread_queue_Timeout+0x38>     <== NEVER TAKEN
40009544:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
40009548:	40 00 0c e4 	call  4000c8d8 <_Thread_queue_Process_timeout> 
4000954c:	01 00 00 00 	nop                                            
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
40009550:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40009554:	c4 00 63 68 	ld  [ %g1 + 0x368 ], %g2	! 40015368 <_Thread_Dispatch_disable_level>
40009558:	84 00 bf ff 	add  %g2, -1, %g2                              
4000955c:	c4 20 63 68 	st  %g2, [ %g1 + 0x368 ]                       
40009560:	81 c7 e0 08 	ret                                            
40009564:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40017384 <_Timer_server_Body>:                                        
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
40017384:	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;            
40017388:	35 10 00 f6 	sethi  %hi(0x4003d800), %i2                    
4001738c:	a4 07 bf e8 	add  %fp, -24, %l2                             
40017390:	b2 07 bf f4 	add  %fp, -12, %i1                             
40017394:	ac 07 bf f8 	add  %fp, -8, %l6                              
40017398:	a6 07 bf ec 	add  %fp, -20, %l3                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
4001739c:	ec 27 bf f4 	st  %l6, [ %fp + -12 ]                         
  the_chain->permanent_null = NULL;                                   
400173a0:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  the_chain->last           = _Chain_Head(the_chain);                 
400173a4:	f2 27 bf fc 	st  %i1, [ %fp + -4 ]                          
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
400173a8:	e6 27 bf e8 	st  %l3, [ %fp + -24 ]                         
  the_chain->permanent_null = NULL;                                   
400173ac:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  the_chain->last           = _Chain_Head(the_chain);                 
400173b0:	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 );  
400173b4:	aa 06 20 30 	add  %i0, 0x30, %l5                            
                                                                      
  _Chain_Initialize_empty( &insert_chain );                           
  _Chain_Initialize_empty( &fire_chain );                             
                                                                      
  while ( true ) {                                                    
    _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
400173b8:	a8 10 00 12 	mov  %l2, %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();
400173bc:	37 10 00 f6 	sethi  %hi(0x4003d800), %i3                    
     /*                                                               
      *  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 ); 
400173c0:	a2 06 20 68 	add  %i0, 0x68, %l1                            
        _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;                                              
400173c4:	b8 10 20 01 	mov  1, %i4                                    
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
400173c8:	ba 06 20 08 	add  %i0, 8, %i5                               
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
400173cc:	ae 06 20 40 	add  %i0, 0x40, %l7                            
{                                                                     
  /*                                                                  
   *  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;                                    
400173d0:	f2 26 20 78 	st  %i1, [ %i0 + 0x78 ]                        
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
400173d4:	c2 06 a3 34 	ld  [ %i2 + 0x334 ], %g1                       
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
400173d8:	d2 06 20 3c 	ld  [ %i0 + 0x3c ], %o1                        
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
400173dc:	94 10 00 14 	mov  %l4, %o2                                  
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
400173e0:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
400173e4:	90 10 00 15 	mov  %l5, %o0                                  
400173e8:	40 00 11 93 	call  4001ba34 <_Watchdog_Adjust_to_chain>     
400173ec:	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;         
400173f0:	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();
400173f4:	e0 06 e2 80 	ld  [ %i3 + 0x280 ], %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 ) {                                   
400173f8:	80 a4 00 0a 	cmp  %l0, %o2                                  
400173fc:	08 80 00 06 	bleu  40017414 <_Timer_server_Body+0x90>       
40017400:	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 );
40017404:	90 10 00 11 	mov  %l1, %o0                                  
40017408:	40 00 11 8b 	call  4001ba34 <_Watchdog_Adjust_to_chain>     
4001740c:	94 10 00 14 	mov  %l4, %o2                                  
40017410:	30 80 00 06 	b,a   40017428 <_Timer_server_Body+0xa4>       
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
40017414:	1a 80 00 05 	bcc  40017428 <_Timer_server_Body+0xa4>        
40017418:	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 ); 
4001741c:	92 10 20 01 	mov  1, %o1                                    
40017420:	40 00 11 5d 	call  4001b994 <_Watchdog_Adjust>              
40017424:	94 22 80 10 	sub  %o2, %l0, %o2                             
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
40017428:	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 );
4001742c:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
40017430:	40 00 02 bc 	call  40017f20 <_Chain_Get>                    
40017434:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
40017438:	92 92 20 00 	orcc  %o0, 0, %o1                              
4001743c:	02 80 00 0c 	be  4001746c <_Timer_server_Body+0xe8>         
40017440:	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 ) {                 
40017444:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        
40017448:	80 a0 60 01 	cmp  %g1, 1                                    
4001744c:	02 80 00 05 	be  40017460 <_Timer_server_Body+0xdc>         
40017450:	90 10 00 15 	mov  %l5, %o0                                  
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
40017454:	80 a0 60 03 	cmp  %g1, 3                                    
40017458:	12 bf ff f5 	bne  4001742c <_Timer_server_Body+0xa8>        <== NEVER TAKEN
4001745c:	90 10 00 11 	mov  %l1, %o0                                  
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
40017460:	40 00 11 a9 	call  4001bb04 <_Watchdog_Insert>              
40017464:	92 02 60 10 	add  %o1, 0x10, %o1                            
40017468:	30 bf ff f1 	b,a   4001742c <_Timer_server_Body+0xa8>       
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
4001746c:	7f ff e0 11 	call  4000f4b0 <sparc_disable_interrupts>      
40017470:	01 00 00 00 	nop                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
40017474:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40017478:	80 a0 40 16 	cmp  %g1, %l6                                  
4001747c:	12 80 00 0a 	bne  400174a4 <_Timer_server_Body+0x120>       <== NEVER TAKEN
40017480:	01 00 00 00 	nop                                            
      ts->insert_chain = NULL;                                        
40017484:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
      _ISR_Enable( level );                                           
40017488:	7f ff e0 0e 	call  4000f4c0 <sparc_enable_interrupts>       
4001748c:	01 00 00 00 	nop                                            
  _Chain_Initialize_empty( &fire_chain );                             
                                                                      
  while ( true ) {                                                    
    _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
                                                                      
    if ( !_Chain_Is_empty( &fire_chain ) ) {                          
40017490:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
40017494:	80 a0 40 13 	cmp  %g1, %l3                                  
40017498:	12 80 00 06 	bne  400174b0 <_Timer_server_Body+0x12c>       
4001749c:	01 00 00 00 	nop                                            
400174a0:	30 80 00 1a 	b,a   40017508 <_Timer_server_Body+0x184>      
      ts->insert_chain = NULL;                                        
      _ISR_Enable( level );                                           
                                                                      
      break;                                                          
    } else {                                                          
      _ISR_Enable( level );                                           
400174a4:	7f ff e0 07 	call  4000f4c0 <sparc_enable_interrupts>       <== NOT EXECUTED
400174a8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400174ac:	30 bf ff ca 	b,a   400173d4 <_Timer_server_Body+0x50>       <== NOT EXECUTED
                                                                      
        /*                                                            
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
400174b0:	7f ff e0 00 	call  4000f4b0 <sparc_disable_interrupts>      
400174b4:	01 00 00 00 	nop                                            
400174b8:	84 10 00 08 	mov  %o0, %g2                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
400174bc:	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))                                   
400174c0:	80 a4 00 13 	cmp  %l0, %l3                                  
400174c4:	02 80 00 0e 	be  400174fc <_Timer_server_Body+0x178>        
400174c8:	80 a4 20 00 	cmp  %l0, 0                                    
{                                                                     
  Chain_Node  *return_node;                                           
  Chain_Node  *new_first;                                             
                                                                      
  return_node         = the_chain->first;                             
  new_first           = return_node->next;                            
400174cc:	c2 04 00 00 	ld  [ %l0 ], %g1                               
  the_chain->first    = new_first;                                    
400174d0:	c2 27 bf e8 	st  %g1, [ %fp + -24 ]                         
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
400174d4:	02 80 00 0a 	be  400174fc <_Timer_server_Body+0x178>        <== NEVER TAKEN
400174d8:	e4 20 60 04 	st  %l2, [ %g1 + 4 ]                           
          watchdog->state = WATCHDOG_INACTIVE;                        
400174dc:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
          _ISR_Enable( level );                                       
400174e0:	7f ff df f8 	call  4000f4c0 <sparc_enable_interrupts>       
400174e4:	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 );    
400174e8:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
400174ec:	d0 04 20 20 	ld  [ %l0 + 0x20 ], %o0                        
400174f0:	9f c0 40 00 	call  %g1                                      
400174f4:	d2 04 20 24 	ld  [ %l0 + 0x24 ], %o1                        
      }                                                               
400174f8:	30 bf ff ee 	b,a   400174b0 <_Timer_server_Body+0x12c>      
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
          _ISR_Enable( level );                                       
        } else {                                                      
          _ISR_Enable( level );                                       
400174fc:	7f ff df f1 	call  4000f4c0 <sparc_enable_interrupts>       
40017500:	90 10 00 02 	mov  %g2, %o0                                  
40017504:	30 bf ff b3 	b,a   400173d0 <_Timer_server_Body+0x4c>       
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
40017508:	c0 2e 20 7c 	clrb  [ %i0 + 0x7c ]                           
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
4001750c:	7f ff ff 6e 	call  400172c4 <_Thread_Disable_dispatch>      
40017510:	01 00 00 00 	nop                                            
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
40017514:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40017518:	40 00 0e 9b 	call  4001af84 <_Thread_Set_state>             
4001751c:	92 10 20 08 	mov  8, %o1                                    
        _Timer_server_Reset_interval_system_watchdog( ts );           
40017520:	7f ff ff 6f 	call  400172dc <_Timer_server_Reset_interval_system_watchdog>
40017524:	90 10 00 18 	mov  %i0, %o0                                  
        _Timer_server_Reset_tod_system_watchdog( ts );                
40017528:	7f ff ff 82 	call  40017330 <_Timer_server_Reset_tod_system_watchdog>
4001752c:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_Enable_dispatch();                                      
40017530:	40 00 0b fd 	call  4001a524 <_Thread_Enable_dispatch>       
40017534:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40017538:	90 10 00 1d 	mov  %i5, %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;                                              
4001753c:	f8 2e 20 7c 	stb  %i4, [ %i0 + 0x7c ]                       
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40017540:	40 00 11 cb 	call  4001bc6c <_Watchdog_Remove>              
40017544:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
40017548:	40 00 11 c9 	call  4001bc6c <_Watchdog_Remove>              
4001754c:	90 10 00 17 	mov  %l7, %o0                                  
40017550:	30 bf ff a0 	b,a   400173d0 <_Timer_server_Body+0x4c>       
                                                                      
===============================================================================
40017554 <_Timer_server_Schedule_operation_method>:                   
                                                                      
static void _Timer_server_Schedule_operation_method(                  
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
40017554:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( ts->insert_chain == NULL ) {                                   
40017558:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
4001755c:	80 a0 60 00 	cmp  %g1, 0                                    
40017560:	12 80 00 49 	bne  40017684 <_Timer_server_Schedule_operation_method+0x130>
40017564:	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();                                         
40017568:	7f ff ff 57 	call  400172c4 <_Thread_Disable_dispatch>      
4001756c:	01 00 00 00 	nop                                            
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
40017570:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
40017574:	80 a0 60 01 	cmp  %g1, 1                                    
40017578:	12 80 00 1f 	bne  400175f4 <_Timer_server_Schedule_operation_method+0xa0>
4001757c:	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 );                                            
40017580:	7f ff df cc 	call  4000f4b0 <sparc_disable_interrupts>      
40017584:	01 00 00 00 	nop                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
40017588:	03 10 00 f6 	sethi  %hi(0x4003d800), %g1                    
4001758c:	c4 00 63 34 	ld  [ %g1 + 0x334 ], %g2	! 4003db34 <_Watchdog_Ticks_since_boot>
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
40017590:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
40017594:	c8 06 20 3c 	ld  [ %i0 + 0x3c ], %g4                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
40017598:	86 06 20 34 	add  %i0, 0x34, %g3                            
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
4001759c:	80 a0 40 03 	cmp  %g1, %g3                                  
400175a0:	02 80 00 08 	be  400175c0 <_Timer_server_Schedule_operation_method+0x6c>
400175a4:	88 20 80 04 	sub  %g2, %g4, %g4                             
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
400175a8:	da 00 60 10 	ld  [ %g1 + 0x10 ], %o5                        
      if (delta_interval > delta) {                                   
400175ac:	80 a3 40 04 	cmp  %o5, %g4                                  
400175b0:	08 80 00 03 	bleu  400175bc <_Timer_server_Schedule_operation_method+0x68>
400175b4:	86 10 20 00 	clr  %g3                                       
        delta_interval -= delta;                                      
400175b8:	86 23 40 04 	sub  %o5, %g4, %g3                             
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
400175bc:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
400175c0:	c4 26 20 3c 	st  %g2, [ %i0 + 0x3c ]                        
    _ISR_Enable( level );                                             
400175c4:	7f ff df bf 	call  4000f4c0 <sparc_enable_interrupts>       
400175c8:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
400175cc:	90 06 20 30 	add  %i0, 0x30, %o0                            
400175d0:	40 00 11 4d 	call  4001bb04 <_Watchdog_Insert>              
400175d4:	92 04 20 10 	add  %l0, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
400175d8:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
400175dc:	80 a0 60 00 	cmp  %g1, 0                                    
400175e0:	12 80 00 27 	bne  4001767c <_Timer_server_Schedule_operation_method+0x128>
400175e4:	01 00 00 00 	nop                                            
      _Timer_server_Reset_interval_system_watchdog( ts );             
400175e8:	7f ff ff 3d 	call  400172dc <_Timer_server_Reset_interval_system_watchdog>
400175ec:	90 10 00 18 	mov  %i0, %o0                                  
400175f0:	30 80 00 23 	b,a   4001767c <_Timer_server_Schedule_operation_method+0x128>
    }                                                                 
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
400175f4:	12 80 00 22 	bne  4001767c <_Timer_server_Schedule_operation_method+0x128>
400175f8:	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 );                                            
400175fc:	7f ff df ad 	call  4000f4b0 <sparc_disable_interrupts>      
40017600:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
40017604:	c4 06 20 68 	ld  [ %i0 + 0x68 ], %g2                        
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
40017608:	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();        
4001760c:	03 10 00 f6 	sethi  %hi(0x4003d800), %g1                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
40017610:	86 06 20 6c 	add  %i0, 0x6c, %g3                            
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
40017614:	80 a0 80 03 	cmp  %g2, %g3                                  
40017618:	02 80 00 0d 	be  4001764c <_Timer_server_Schedule_operation_method+0xf8>
4001761c:	c2 00 62 80 	ld  [ %g1 + 0x280 ], %g1                       
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
40017620:	c8 00 a0 10 	ld  [ %g2 + 0x10 ], %g4                        
      if ( snapshot > last_snapshot ) {                               
40017624:	80 a0 40 0d 	cmp  %g1, %o5                                  
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
40017628:	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 ) {                               
4001762c:	08 80 00 07 	bleu  40017648 <_Timer_server_Schedule_operation_method+0xf4>
40017630:	86 20 c0 01 	sub  %g3, %g1, %g3                             
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
40017634:	9a 20 40 0d 	sub  %g1, %o5, %o5                             
        if (delta_interval > delta) {                                 
40017638:	80 a1 00 0d 	cmp  %g4, %o5                                  
4001763c:	08 80 00 03 	bleu  40017648 <_Timer_server_Schedule_operation_method+0xf4><== NEVER TAKEN
40017640:	86 10 20 00 	clr  %g3                                       
          delta_interval -= delta;                                    
40017644:	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;                
40017648:	c6 20 a0 10 	st  %g3, [ %g2 + 0x10 ]                        
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
4001764c:	c2 26 20 74 	st  %g1, [ %i0 + 0x74 ]                        
    _ISR_Enable( level );                                             
40017650:	7f ff df 9c 	call  4000f4c0 <sparc_enable_interrupts>       
40017654:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
40017658:	90 06 20 68 	add  %i0, 0x68, %o0                            
4001765c:	40 00 11 2a 	call  4001bb04 <_Watchdog_Insert>              
40017660:	92 04 20 10 	add  %l0, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
40017664:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
40017668:	80 a0 60 00 	cmp  %g1, 0                                    
4001766c:	12 80 00 04 	bne  4001767c <_Timer_server_Schedule_operation_method+0x128>
40017670:	01 00 00 00 	nop                                            
      _Timer_server_Reset_tod_system_watchdog( ts );                  
40017674:	7f ff ff 2f 	call  40017330 <_Timer_server_Reset_tod_system_watchdog>
40017678:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
4001767c:	40 00 0b aa 	call  4001a524 <_Thread_Enable_dispatch>       
40017680:	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 );           
40017684:	f0 06 20 78 	ld  [ %i0 + 0x78 ], %i0                        
40017688:	40 00 02 10 	call  40017ec8 <_Chain_Append>                 
4001768c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000bab4 <_Timespec_Greater_than>:                                    
bool _Timespec_Greater_than(                                          
  const struct timespec *lhs,                                         
  const struct timespec *rhs                                          
)                                                                     
{                                                                     
  if ( lhs->tv_sec > rhs->tv_sec )                                    
4000bab4:	c6 02 00 00 	ld  [ %o0 ], %g3                               
4000bab8:	c4 02 40 00 	ld  [ %o1 ], %g2                               
                                                                      
bool _Timespec_Greater_than(                                          
  const struct timespec *lhs,                                         
  const struct timespec *rhs                                          
)                                                                     
{                                                                     
4000babc:	82 10 00 08 	mov  %o0, %g1                                  
  if ( lhs->tv_sec > rhs->tv_sec )                                    
4000bac0:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000bac4:	14 80 00 0b 	bg  4000baf0 <_Timespec_Greater_than+0x3c>     
4000bac8:	90 10 20 01 	mov  1, %o0                                    
    return true;                                                      
                                                                      
  if ( lhs->tv_sec < rhs->tv_sec )                                    
4000bacc:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000bad0:	06 80 00 08 	bl  4000baf0 <_Timespec_Greater_than+0x3c>     <== NEVER TAKEN
4000bad4:	90 10 20 00 	clr  %o0                                       
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
                                                                      
bool _Timespec_Greater_than(                                          
4000bad8:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000badc:	c2 02 60 04 	ld  [ %o1 + 4 ], %g1                           
4000bae0:	80 a0 80 01 	cmp  %g2, %g1                                  
4000bae4:	14 80 00 03 	bg  4000baf0 <_Timespec_Greater_than+0x3c>     
4000bae8:	90 10 20 01 	mov  1, %o0                                    
4000baec:	90 10 20 00 	clr  %o0                                       
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */                            
  if ( lhs->tv_nsec > rhs->tv_nsec )                                  
    return true;                                                      
                                                                      
  return false;                                                       
}                                                                     
4000baf0:	81 c3 e0 08 	retl                                           
                                                                      
===============================================================================
40009c04 <_User_extensions_Fatal>:                                    
void _User_extensions_Fatal (                                         
  Internal_errors_Source  the_source,                                 
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
40009c04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
40009c08:	23 10 00 55 	sethi  %hi(0x40015400), %l1                    
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
40009c0c:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
40009c10:	a2 14 61 88 	or  %l1, 0x188, %l1                            
40009c14:	10 80 00 09 	b  40009c38 <_User_extensions_Fatal+0x34>      
40009c18:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
40009c1c:	80 a0 60 00 	cmp  %g1, 0                                    
40009c20:	02 80 00 05 	be  40009c34 <_User_extensions_Fatal+0x30>     
40009c24:	90 10 00 18 	mov  %i0, %o0                                  
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
40009c28:	92 10 00 19 	mov  %i1, %o1                                  
40009c2c:	9f c0 40 00 	call  %g1                                      
40009c30:	94 10 00 1a 	mov  %i2, %o2                                  
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
40009c34:	e0 04 20 04 	ld  [ %l0 + 4 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
40009c38:	80 a4 00 11 	cmp  %l0, %l1                                  
40009c3c:	32 bf ff f8 	bne,a   40009c1c <_User_extensions_Fatal+0x18> <== ALWAYS TAKEN
40009c40:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
40009c44:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40009c48:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
===============================================================================
40009ac8 <_User_extensions_Handler_initialization>:                   
#include <rtems/score/userext.h>                                      
#include <rtems/score/wkspace.h>                                      
#include <string.h>                                                   
                                                                      
void _User_extensions_Handler_initialization(void)                    
{                                                                     
40009ac8:	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;  
40009acc:	03 10 00 52 	sethi  %hi(0x40014800), %g1                    
40009ad0:	82 10 61 38 	or  %g1, 0x138, %g1	! 40014938 <Configuration> 
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
40009ad4:	05 10 00 55 	sethi  %hi(0x40015400), %g2                    
  initial_extensions   = Configuration.User_extension_table;          
40009ad8:	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;  
40009adc:	e4 00 60 38 	ld  [ %g1 + 0x38 ], %l2                        
40009ae0:	82 10 a1 88 	or  %g2, 0x188, %g1                            
40009ae4:	86 00 60 04 	add  %g1, 4, %g3                               
  the_chain->permanent_null = NULL;                                   
40009ae8:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
  the_chain->last           = _Chain_Head(the_chain);                 
40009aec:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
40009af0:	c6 20 a1 88 	st  %g3, [ %g2 + 0x188 ]                       
40009af4:	05 10 00 54 	sethi  %hi(0x40015000), %g2                    
40009af8:	82 10 a3 6c 	or  %g2, 0x36c, %g1	! 4001536c <_User_extensions_Switches_list>
40009afc:	86 00 60 04 	add  %g1, 4, %g3                               
  the_chain->permanent_null = NULL;                                   
40009b00:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
40009b04:	c6 20 a3 6c 	st  %g3, [ %g2 + 0x36c ]                       
  initial_extensions   = Configuration.User_extension_table;          
                                                                      
  _Chain_Initialize_empty( &_User_extensions_List );                  
  _Chain_Initialize_empty( &_User_extensions_Switches_list );         
                                                                      
  if ( initial_extensions ) {                                         
40009b08:	80 a4 e0 00 	cmp  %l3, 0                                    
40009b0c:	02 80 00 1b 	be  40009b78 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
40009b10:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
    extension = (User_extensions_Control *)                           
      _Workspace_Allocate_or_fatal_error(                             
        number_of_extensions * sizeof( User_extensions_Control )      
40009b14:	83 2c a0 02 	sll  %l2, 2, %g1                               
40009b18:	a1 2c a0 04 	sll  %l2, 4, %l0                               
40009b1c:	a0 24 00 01 	sub  %l0, %g1, %l0                             
40009b20:	a0 04 00 12 	add  %l0, %l2, %l0                             
40009b24:	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(                             
40009b28:	40 00 01 6a 	call  4000a0d0 <_Workspace_Allocate_or_fatal_error>
40009b2c:	90 10 00 10 	mov  %l0, %o0                                  
        number_of_extensions * sizeof( User_extensions_Control )      
      );                                                              
                                                                      
    memset (                                                          
40009b30:	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(                             
40009b34:	a2 10 00 08 	mov  %o0, %l1                                  
        number_of_extensions * sizeof( User_extensions_Control )      
      );                                                              
                                                                      
    memset (                                                          
40009b38:	92 10 20 00 	clr  %o1                                       
40009b3c:	40 00 14 37 	call  4000ec18 <memset>                        
40009b40:	a0 10 20 00 	clr  %l0                                       
      extension,                                                      
      0,                                                              
      number_of_extensions * sizeof( User_extensions_Control )        
    );                                                                
                                                                      
    for ( i = 0 ; i < number_of_extensions ; i++ ) {                  
40009b44:	10 80 00 0b 	b  40009b70 <_User_extensions_Handler_initialization+0xa8>
40009b48:	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;                             
40009b4c:	90 04 60 14 	add  %l1, 0x14, %o0                            
40009b50:	92 04 c0 09 	add  %l3, %o1, %o1                             
40009b54:	40 00 13 f2 	call  4000eb1c <memcpy>                        
40009b58:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
  _User_extensions_Add_set( extension );                              
40009b5c:	90 10 00 11 	mov  %l1, %o0                                  
40009b60:	40 00 0b c6 	call  4000ca78 <_User_extensions_Add_set>      
40009b64:	a0 04 20 01 	inc  %l0                                       
      _User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
      extension++;                                                    
40009b68:	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++ ) {                  
40009b6c:	80 a4 00 12 	cmp  %l0, %l2                                  
40009b70:	0a bf ff f7 	bcs  40009b4c <_User_extensions_Handler_initialization+0x84>
40009b74:	93 2c 20 05 	sll  %l0, 5, %o1                               
40009b78:	81 c7 e0 08 	ret                                            
40009b7c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40009bc4 <_User_extensions_Thread_exitted>:                           
                                                                      
void _User_extensions_Thread_exitted (                                
  Thread_Control *executing                                           
)                                                                     
{                                                                     
40009bc4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
40009bc8:	23 10 00 55 	sethi  %hi(0x40015400), %l1                    
40009bcc:	a2 14 61 88 	or  %l1, 0x188, %l1	! 40015588 <_User_extensions_List>
40009bd0:	10 80 00 08 	b  40009bf0 <_User_extensions_Thread_exitted+0x2c>
40009bd4:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_exitted != NULL )             
40009bd8:	80 a0 60 00 	cmp  %g1, 0                                    
40009bdc:	22 80 00 05 	be,a   40009bf0 <_User_extensions_Thread_exitted+0x2c>
40009be0:	e0 04 20 04 	ld  [ %l0 + 4 ], %l0                           
      (*the_extension->Callouts.thread_exitted)( executing );         
40009be4:	9f c0 40 00 	call  %g1                                      
40009be8:	90 10 00 18 	mov  %i0, %o0                                  
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
40009bec:	e0 04 20 04 	ld  [ %l0 + 4 ], %l0                           <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _User_extensions_List.last ;                       
40009bf0:	80 a4 00 11 	cmp  %l0, %l1                                  
40009bf4:	32 bf ff f9 	bne,a   40009bd8 <_User_extensions_Thread_exitted+0x14>
40009bf8:	c2 04 20 2c 	ld  [ %l0 + 0x2c ], %g1                        
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_exitted != NULL )             
      (*the_extension->Callouts.thread_exitted)( executing );         
  }                                                                   
}                                                                     
40009bfc:	81 c7 e0 08 	ret                                            
40009c00:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000bf78 <_Watchdog_Adjust>:                                          
void _Watchdog_Adjust(                                                
  Chain_Control               *header,                                
  Watchdog_Adjust_directions   direction,                             
  Watchdog_Interval            units                                  
)                                                                     
{                                                                     
4000bf78:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
4000bf7c:	7f ff db 79 	call  40002d60 <sparc_disable_interrupts>      
4000bf80:	a0 10 00 18 	mov  %i0, %l0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
4000bf84:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
4000bf88:	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 ) ) {                                 
4000bf8c:	80 a0 40 11 	cmp  %g1, %l1                                  
4000bf90:	02 80 00 1f 	be  4000c00c <_Watchdog_Adjust+0x94>           
4000bf94:	80 a6 60 00 	cmp  %i1, 0                                    
    switch ( direction ) {                                            
4000bf98:	02 80 00 1a 	be  4000c000 <_Watchdog_Adjust+0x88>           
4000bf9c:	a4 10 20 01 	mov  1, %l2                                    
4000bfa0:	80 a6 60 01 	cmp  %i1, 1                                    
4000bfa4:	12 80 00 1a 	bne  4000c00c <_Watchdog_Adjust+0x94>          <== NEVER TAKEN
4000bfa8:	01 00 00 00 	nop                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
4000bfac:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000bfb0:	10 80 00 07 	b  4000bfcc <_Watchdog_Adjust+0x54>            
4000bfb4:	b4 00 80 1a 	add  %g2, %i2, %i2                             
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000bfb8:	f2 00 60 10 	ld  [ %g1 + 0x10 ], %i1                        
4000bfbc:	80 a6 80 19 	cmp  %i2, %i1                                  
4000bfc0:	3a 80 00 05 	bcc,a   4000bfd4 <_Watchdog_Adjust+0x5c>       
4000bfc4:	e4 20 60 10 	st  %l2, [ %g1 + 0x10 ]                        
            _Watchdog_First( header )->delta_interval -= units;       
4000bfc8:	b4 26 40 1a 	sub  %i1, %i2, %i2                             
            break;                                                    
4000bfcc:	10 80 00 10 	b  4000c00c <_Watchdog_Adjust+0x94>            
4000bfd0:	f4 20 60 10 	st  %i2, [ %g1 + 0x10 ]                        
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
                                                                      
            _ISR_Enable( level );                                     
4000bfd4:	7f ff db 67 	call  40002d70 <sparc_enable_interrupts>       
4000bfd8:	01 00 00 00 	nop                                            
                                                                      
            _Watchdog_Tickle( header );                               
4000bfdc:	40 00 00 92 	call  4000c224 <_Watchdog_Tickle>              
4000bfe0:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
            _ISR_Disable( level );                                    
4000bfe4:	7f ff db 5f 	call  40002d60 <sparc_disable_interrupts>      
4000bfe8:	01 00 00 00 	nop                                            
                                                                      
            if ( _Chain_Is_empty( header ) )                          
4000bfec:	c2 04 00 00 	ld  [ %l0 ], %g1                               
4000bff0:	80 a0 40 11 	cmp  %g1, %l1                                  
4000bff4:	02 80 00 06 	be  4000c00c <_Watchdog_Adjust+0x94>           
4000bff8:	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;       
4000bffc:	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 ) {                                             
4000c000:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c004:	32 bf ff ed 	bne,a   4000bfb8 <_Watchdog_Adjust+0x40>       <== ALWAYS TAKEN
4000c008:	c2 04 00 00 	ld  [ %l0 ], %g1                               
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000c00c:	7f ff db 59 	call  40002d70 <sparc_enable_interrupts>       
4000c010:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
===============================================================================
40009ee4 <_Watchdog_Remove>:                                          
 */                                                                   
                                                                      
Watchdog_States _Watchdog_Remove(                                     
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
40009ee4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
40009ee8:	7f ff df 93 	call  40001d34 <sparc_disable_interrupts>      
40009eec:	a0 10 00 18 	mov  %i0, %l0                                  
  previous_state = the_watchdog->state;                               
40009ef0:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  switch ( previous_state ) {                                         
40009ef4:	80 a6 20 01 	cmp  %i0, 1                                    
40009ef8:	22 80 00 1d 	be,a   40009f6c <_Watchdog_Remove+0x88>        
40009efc:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
40009f00:	0a 80 00 1c 	bcs  40009f70 <_Watchdog_Remove+0x8c>          
40009f04:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40009f08:	80 a6 20 03 	cmp  %i0, 3                                    
40009f0c:	18 80 00 19 	bgu  40009f70 <_Watchdog_Remove+0x8c>          <== NEVER TAKEN
40009f10:	01 00 00 00 	nop                                            
40009f14:	c2 04 00 00 	ld  [ %l0 ], %g1                               
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
40009f18:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
40009f1c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40009f20:	80 a0 a0 00 	cmp  %g2, 0                                    
40009f24:	02 80 00 07 	be  40009f40 <_Watchdog_Remove+0x5c>           
40009f28:	05 10 00 55 	sethi  %hi(0x40015400), %g2                    
        next_watchdog->delta_interval += the_watchdog->delta_interval;
40009f2c:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
40009f30:	c4 04 20 10 	ld  [ %l0 + 0x10 ], %g2                        
40009f34:	84 00 c0 02 	add  %g3, %g2, %g2                             
40009f38:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
      if ( _Watchdog_Sync_count )                                     
40009f3c:	05 10 00 55 	sethi  %hi(0x40015400), %g2                    
40009f40:	c4 00 a0 a0 	ld  [ %g2 + 0xa0 ], %g2	! 400154a0 <_Watchdog_Sync_count>
40009f44:	80 a0 a0 00 	cmp  %g2, 0                                    
40009f48:	22 80 00 07 	be,a   40009f64 <_Watchdog_Remove+0x80>        
40009f4c:	c4 04 20 04 	ld  [ %l0 + 4 ], %g2                           
        _Watchdog_Sync_level = _ISR_Nest_level;                       
40009f50:	05 10 00 55 	sethi  %hi(0x40015400), %g2                    
40009f54:	c6 00 a1 d4 	ld  [ %g2 + 0x1d4 ], %g3	! 400155d4 <_Per_CPU_Information+0x8>
40009f58:	05 10 00 55 	sethi  %hi(0x40015400), %g2                    
40009f5c:	c6 20 a0 10 	st  %g3, [ %g2 + 0x10 ]	! 40015410 <_Watchdog_Sync_level>
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40009f60:	c4 04 20 04 	ld  [ %l0 + 4 ], %g2                           
  next->previous = previous;                                          
40009f64:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  previous->next = next;                                              
40009f68:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
40009f6c:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
40009f70:	c2 00 60 a4 	ld  [ %g1 + 0xa4 ], %g1	! 400154a4 <_Watchdog_Ticks_since_boot>
40009f74:	c2 24 20 18 	st  %g1, [ %l0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
40009f78:	7f ff df 73 	call  40001d44 <sparc_enable_interrupts>       
40009f7c:	01 00 00 00 	nop                                            
  return( previous_state );                                           
}                                                                     
40009f80:	81 c7 e0 08 	ret                                            
40009f84:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000b78c <_Watchdog_Report_chain>:                                    
                                                                      
void _Watchdog_Report_chain(                                          
  const char        *name,                                            
  Chain_Control     *header                                           
)                                                                     
{                                                                     
4000b78c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
4000b790:	7f ff dc 4b 	call  400028bc <sparc_disable_interrupts>      
4000b794:	a0 10 00 18 	mov  %i0, %l0                                  
4000b798:	b0 10 00 08 	mov  %o0, %i0                                  
    printk( "Watchdog Chain: %s %p\n", name, header );                
4000b79c:	11 10 00 75 	sethi  %hi(0x4001d400), %o0                    
4000b7a0:	94 10 00 19 	mov  %i1, %o2                                  
4000b7a4:	90 12 21 20 	or  %o0, 0x120, %o0                            
4000b7a8:	7f ff e6 47 	call  400050c4 <printk>                        
4000b7ac:	92 10 00 10 	mov  %l0, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
4000b7b0:	e2 06 40 00 	ld  [ %i1 ], %l1                               
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
4000b7b4:	b2 06 60 04 	add  %i1, 4, %i1                               
    if ( !_Chain_Is_empty( header ) ) {                               
4000b7b8:	80 a4 40 19 	cmp  %l1, %i1                                  
4000b7bc:	02 80 00 0e 	be  4000b7f4 <_Watchdog_Report_chain+0x68>     
4000b7c0:	11 10 00 75 	sethi  %hi(0x4001d400), %o0                    
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
4000b7c4:	92 10 00 11 	mov  %l1, %o1                                  
4000b7c8:	40 00 00 10 	call  4000b808 <_Watchdog_Report>              
4000b7cc:	90 10 20 00 	clr  %o0                                       
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = header->first ;                                    
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
4000b7d0:	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 = header->first ;                                    
4000b7d4:	80 a4 40 19 	cmp  %l1, %i1                                  
4000b7d8:	12 bf ff fc 	bne  4000b7c8 <_Watchdog_Report_chain+0x3c>    <== NEVER TAKEN
4000b7dc:	92 10 00 11 	mov  %l1, %o1                                  
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
4000b7e0:	11 10 00 75 	sethi  %hi(0x4001d400), %o0                    
4000b7e4:	92 10 00 10 	mov  %l0, %o1                                  
4000b7e8:	7f ff e6 37 	call  400050c4 <printk>                        
4000b7ec:	90 12 21 38 	or  %o0, 0x138, %o0                            
4000b7f0:	30 80 00 03 	b,a   4000b7fc <_Watchdog_Report_chain+0x70>   
    } else {                                                          
      printk( "Chain is empty\n" );                                   
4000b7f4:	7f ff e6 34 	call  400050c4 <printk>                        
4000b7f8:	90 12 21 48 	or  %o0, 0x148, %o0                            
    }                                                                 
  _ISR_Enable( level );                                               
4000b7fc:	7f ff dc 34 	call  400028cc <sparc_enable_interrupts>       
4000b800:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40009ad4 <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) 
{                                                                     
40009ad4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
40009ad8:	80 a6 20 00 	cmp  %i0, 0                                    
40009adc:	02 80 00 1d 	be  40009b50 <rtems_iterate_over_all_threads+0x7c><== NEVER TAKEN
40009ae0:	21 10 00 9d 	sethi  %hi(0x40027400), %l0                    
40009ae4:	a0 14 22 e0 	or  %l0, 0x2e0, %l0	! 400276e0 <_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) 
40009ae8:	a6 04 20 0c 	add  %l0, 0xc, %l3                             
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
    if ( !_Objects_Information_table[ api_index ] )                   
40009aec:	c2 04 00 00 	ld  [ %l0 ], %g1                               
40009af0:	80 a0 60 00 	cmp  %g1, 0                                    
40009af4:	22 80 00 14 	be,a   40009b44 <rtems_iterate_over_all_threads+0x70>
40009af8:	a0 04 20 04 	add  %l0, 4, %l0                               
      continue;                                                       
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
40009afc:	e4 00 60 04 	ld  [ %g1 + 4 ], %l2                           
    if ( !information )                                               
40009b00:	80 a4 a0 00 	cmp  %l2, 0                                    
40009b04:	12 80 00 0b 	bne  40009b30 <rtems_iterate_over_all_threads+0x5c>
40009b08:	a2 10 20 01 	mov  1, %l1                                    
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
40009b0c:	10 80 00 0e 	b  40009b44 <rtems_iterate_over_all_threads+0x70>
40009b10:	a0 04 20 04 	add  %l0, 4, %l0                               
      the_thread = (Thread_Control *)information->local_table[ i ];   
40009b14:	83 2c 60 02 	sll  %l1, 2, %g1                               
40009b18:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0                         
                                                                      
      if ( !the_thread )                                              
40009b1c:	80 a2 20 00 	cmp  %o0, 0                                    
40009b20:	02 80 00 04 	be  40009b30 <rtems_iterate_over_all_threads+0x5c><== NEVER TAKEN
40009b24:	a2 04 60 01 	inc  %l1                                       
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
40009b28:	9f c6 00 00 	call  %i0                                      
40009b2c:	01 00 00 00 	nop                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
40009b30:	c2 14 a0 10 	lduh  [ %l2 + 0x10 ], %g1                      
40009b34:	80 a4 40 01 	cmp  %l1, %g1                                  
40009b38:	28 bf ff f7 	bleu,a   40009b14 <rtems_iterate_over_all_threads+0x40>
40009b3c:	c4 04 a0 1c 	ld  [ %l2 + 0x1c ], %g2                        
40009b40:	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++ ) {
40009b44:	80 a4 00 13 	cmp  %l0, %l3                                  
40009b48:	32 bf ff ea 	bne,a   40009af0 <rtems_iterate_over_all_threads+0x1c>
40009b4c:	c2 04 00 00 	ld  [ %l0 ], %g1                               
40009b50:	81 c7 e0 08 	ret                                            
40009b54:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40014d24 <rtems_partition_create>:                                    
  uint32_t         length,                                            
  uint32_t         buffer_size,                                       
  rtems_attribute  attribute_set,                                     
  rtems_id        *id                                                 
)                                                                     
{                                                                     
40014d24:	9d e3 bf a0 	save  %sp, -96, %sp                            
40014d28:	a0 10 00 18 	mov  %i0, %l0                                  
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
40014d2c:	80 a4 20 00 	cmp  %l0, 0                                    
40014d30:	02 80 00 1f 	be  40014dac <rtems_partition_create+0x88>     
40014d34:	b0 10 20 03 	mov  3, %i0                                    
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
40014d38:	80 a6 60 00 	cmp  %i1, 0                                    
40014d3c:	02 80 00 1c 	be  40014dac <rtems_partition_create+0x88>     
40014d40:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
40014d44:	80 a7 60 00 	cmp  %i5, 0                                    
40014d48:	02 80 00 19 	be  40014dac <rtems_partition_create+0x88>     <== NEVER TAKEN
40014d4c:	80 a6 e0 00 	cmp  %i3, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
40014d50:	02 80 00 32 	be  40014e18 <rtems_partition_create+0xf4>     
40014d54:	80 a6 a0 00 	cmp  %i2, 0                                    
40014d58:	02 80 00 30 	be  40014e18 <rtems_partition_create+0xf4>     
40014d5c:	80 a6 80 1b 	cmp  %i2, %i3                                  
40014d60:	0a 80 00 13 	bcs  40014dac <rtems_partition_create+0x88>    
40014d64:	b0 10 20 08 	mov  8, %i0                                    
40014d68:	80 8e e0 07 	btst  7, %i3                                   
40014d6c:	12 80 00 10 	bne  40014dac <rtems_partition_create+0x88>    
40014d70:	80 8e 60 07 	btst  7, %i1                                   
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
40014d74:	12 80 00 0e 	bne  40014dac <rtems_partition_create+0x88>    
40014d78:	b0 10 20 09 	mov  9, %i0                                    
40014d7c:	03 10 00 f6 	sethi  %hi(0x4003d800), %g1                    
40014d80:	c4 00 61 f8 	ld  [ %g1 + 0x1f8 ], %g2	! 4003d9f8 <_Thread_Dispatch_disable_level>
40014d84:	84 00 a0 01 	inc  %g2                                       
40014d88:	c4 20 61 f8 	st  %g2, [ %g1 + 0x1f8 ]                       
 *  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 );
40014d8c:	25 10 00 f6 	sethi  %hi(0x4003d800), %l2                    
40014d90:	40 00 12 4a 	call  400196b8 <_Objects_Allocate>             
40014d94:	90 14 a0 04 	or  %l2, 4, %o0	! 4003d804 <_Partition_Information>
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
40014d98:	a2 92 20 00 	orcc  %o0, 0, %l1                              
40014d9c:	12 80 00 06 	bne  40014db4 <rtems_partition_create+0x90>    
40014da0:	92 10 00 1b 	mov  %i3, %o1                                  
    _Thread_Enable_dispatch();                                        
40014da4:	40 00 15 e0 	call  4001a524 <_Thread_Enable_dispatch>       
40014da8:	b0 10 20 05 	mov  5, %i0                                    
    return RTEMS_TOO_MANY;                                            
40014dac:	81 c7 e0 08 	ret                                            
40014db0:	81 e8 00 00 	restore                                        
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
40014db4:	f2 24 60 10 	st  %i1, [ %l1 + 0x10 ]                        
  the_partition->length                = length;                      
40014db8:	f4 24 60 14 	st  %i2, [ %l1 + 0x14 ]                        
  the_partition->buffer_size           = buffer_size;                 
40014dbc:	f6 24 60 18 	st  %i3, [ %l1 + 0x18 ]                        
  the_partition->attribute_set         = attribute_set;               
40014dc0:	f8 24 60 1c 	st  %i4, [ %l1 + 0x1c ]                        
  the_partition->number_of_used_blocks = 0;                           
40014dc4:	c0 24 60 20 	clr  [ %l1 + 0x20 ]                            
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
                        length / buffer_size, buffer_size );          
40014dc8:	40 00 5e f1 	call  4002c98c <.udiv>                         
40014dcc:	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,        
40014dd0:	92 10 00 19 	mov  %i1, %o1                                  
                        length / buffer_size, buffer_size );          
40014dd4:	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,        
40014dd8:	96 10 00 1b 	mov  %i3, %o3                                  
40014ddc:	a6 04 60 24 	add  %l1, 0x24, %l3                            
40014de0:	40 00 0c 5f 	call  40017f5c <_Chain_Initialize>             
40014de4:	90 10 00 13 	mov  %l3, %o0                                  
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40014de8:	c4 14 60 0a 	lduh  [ %l1 + 0xa ], %g2                       
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40014dec:	a4 14 a0 04 	or  %l2, 4, %l2                                
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40014df0:	c6 04 a0 1c 	ld  [ %l2 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40014df4:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40014df8:	85 28 a0 02 	sll  %g2, 2, %g2                               
40014dfc:	e2 20 c0 02 	st  %l1, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
40014e00:	e0 24 60 0c 	st  %l0, [ %l1 + 0xc ]                         
    &_Partition_Information,                                          
    &the_partition->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_partition->Object.id;                                     
40014e04:	c2 27 40 00 	st  %g1, [ %i5 ]                               
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
40014e08:	40 00 15 c7 	call  4001a524 <_Thread_Enable_dispatch>       
40014e0c:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
40014e10:	81 c7 e0 08 	ret                                            
40014e14:	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;                                        
40014e18:	b0 10 20 08 	mov  8, %i0                                    
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40014e1c:	81 c7 e0 08 	ret                                            
40014e20:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40007d5c <rtems_rate_monotonic_period>:                               
                                                                      
rtems_status_code rtems_rate_monotonic_period(                        
  rtems_id       id,                                                  
  rtems_interval length                                               
)                                                                     
{                                                                     
40007d5c:	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 );       
40007d60:	11 10 00 7b 	sethi  %hi(0x4001ec00), %o0                    
40007d64:	92 10 00 18 	mov  %i0, %o1                                  
40007d68:	90 12 23 44 	or  %o0, 0x344, %o0                            
40007d6c:	40 00 08 ee 	call  4000a124 <_Objects_Get>                  
40007d70:	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 ) {                                               
40007d74:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40007d78:	80 a0 60 00 	cmp  %g1, 0                                    
40007d7c:	12 80 00 66 	bne  40007f14 <rtems_rate_monotonic_period+0x1b8>
40007d80:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
40007d84:	25 10 00 7c 	sethi  %hi(0x4001f000), %l2                    
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
40007d88:	c4 02 20 40 	ld  [ %o0 + 0x40 ], %g2                        
40007d8c:	a4 14 a3 1c 	or  %l2, 0x31c, %l2                            
40007d90:	c2 04 a0 0c 	ld  [ %l2 + 0xc ], %g1                         
40007d94:	80 a0 80 01 	cmp  %g2, %g1                                  
40007d98:	02 80 00 06 	be  40007db0 <rtems_rate_monotonic_period+0x54>
40007d9c:	80 a6 60 00 	cmp  %i1, 0                                    
        _Thread_Enable_dispatch();                                    
40007da0:	40 00 0b 2d 	call  4000aa54 <_Thread_Enable_dispatch>       
40007da4:	b0 10 20 17 	mov  0x17, %i0                                 
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
40007da8:	81 c7 e0 08 	ret                                            
40007dac:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
40007db0:	12 80 00 0e 	bne  40007de8 <rtems_rate_monotonic_period+0x8c>
40007db4:	01 00 00 00 	nop                                            
        switch ( the_period->state ) {                                
40007db8:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40007dbc:	80 a0 60 04 	cmp  %g1, 4                                    
40007dc0:	18 80 00 06 	bgu  40007dd8 <rtems_rate_monotonic_period+0x7c><== NEVER TAKEN
40007dc4:	b0 10 20 00 	clr  %i0                                       
40007dc8:	83 28 60 02 	sll  %g1, 2, %g1                               
40007dcc:	05 10 00 74 	sethi  %hi(0x4001d000), %g2                    
40007dd0:	84 10 a1 94 	or  %g2, 0x194, %g2	! 4001d194 <CSWTCH.2>      
40007dd4:	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();                                    
40007dd8:	40 00 0b 1f 	call  4000aa54 <_Thread_Enable_dispatch>       
40007ddc:	01 00 00 00 	nop                                            
        return( return_value );                                       
40007de0:	81 c7 e0 08 	ret                                            
40007de4:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
40007de8:	7f ff eb 98 	call  40002c48 <sparc_disable_interrupts>      
40007dec:	01 00 00 00 	nop                                            
40007df0:	a6 10 00 08 	mov  %o0, %l3                                  
      switch ( the_period->state ) {                                  
40007df4:	e2 04 20 38 	ld  [ %l0 + 0x38 ], %l1                        
40007df8:	80 a4 60 02 	cmp  %l1, 2                                    
40007dfc:	02 80 00 19 	be  40007e60 <rtems_rate_monotonic_period+0x104>
40007e00:	80 a4 60 04 	cmp  %l1, 4                                    
40007e04:	02 80 00 33 	be  40007ed0 <rtems_rate_monotonic_period+0x174>
40007e08:	80 a4 60 00 	cmp  %l1, 0                                    
40007e0c:	12 80 00 44 	bne  40007f1c <rtems_rate_monotonic_period+0x1c0><== NEVER TAKEN
40007e10:	01 00 00 00 	nop                                            
        case RATE_MONOTONIC_INACTIVE: {                               
                                                                      
          _ISR_Enable( level );                                       
40007e14:	7f ff eb 91 	call  40002c58 <sparc_enable_interrupts>       
40007e18:	01 00 00 00 	nop                                            
                                                                      
          /*                                                          
           *  Baseline statistics information for the beginning of a period.
           */                                                         
          _Rate_monotonic_Initiate_statistics( the_period );          
40007e1c:	7f ff ff 76 	call  40007bf4 <_Rate_monotonic_Initiate_statistics>
40007e20:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
40007e24:	82 10 20 02 	mov  2, %g1                                    
40007e28:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40007e2c:	03 10 00 20 	sethi  %hi(0x40008000), %g1                    
40007e30:	82 10 61 e8 	or  %g1, 0x1e8, %g1	! 400081e8 <_Rate_monotonic_Timeout>
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40007e34:	c0 24 20 18 	clr  [ %l0 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
40007e38:	c2 24 20 2c 	st  %g1, [ %l0 + 0x2c ]                        
  the_watchdog->id        = id;                                       
40007e3c:	f0 24 20 30 	st  %i0, [ %l0 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
40007e40:	c0 24 20 34 	clr  [ %l0 + 0x34 ]                            
            _Rate_monotonic_Timeout,                                  
            id,                                                       
            NULL                                                      
          );                                                          
                                                                      
          the_period->next_length = length;                           
40007e44:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40007e48:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40007e4c:	11 10 00 7c 	sethi  %hi(0x4001f000), %o0                    
40007e50:	92 04 20 10 	add  %l0, 0x10, %o1                            
40007e54:	40 00 0f f9 	call  4000be38 <_Watchdog_Insert>              
40007e58:	90 12 21 7c 	or  %o0, 0x17c, %o0                            
40007e5c:	30 80 00 19 	b,a   40007ec0 <rtems_rate_monotonic_period+0x164>
        case RATE_MONOTONIC_ACTIVE:                                   
                                                                      
          /*                                                          
           *  Update statistics from the concluding period.           
           */                                                         
          _Rate_monotonic_Update_statistics( the_period );            
40007e60:	7f ff ff 81 	call  40007c64 <_Rate_monotonic_Update_statistics>
40007e64:	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;       
40007e68:	82 10 20 01 	mov  1, %g1                                    
          the_period->next_length = length;                           
40007e6c:	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;       
40007e70:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
          the_period->next_length = length;                           
                                                                      
          _ISR_Enable( level );                                       
40007e74:	7f ff eb 79 	call  40002c58 <sparc_enable_interrupts>       
40007e78:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
          _Thread_Executing->Wait.id = the_period->Object.id;         
40007e7c:	d0 04 a0 0c 	ld  [ %l2 + 0xc ], %o0                         
40007e80:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40007e84:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
40007e88:	40 00 0d 39 	call  4000b36c <_Thread_Set_state>             
40007e8c:	c2 22 20 20 	st  %g1, [ %o0 + 0x20 ]                        
                                                                      
          /*                                                          
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?                                                  
           */                                                         
          _ISR_Disable( level );                                      
40007e90:	7f ff eb 6e 	call  40002c48 <sparc_disable_interrupts>      
40007e94:	01 00 00 00 	nop                                            
            local_state = the_period->state;                          
40007e98:	e6 04 20 38 	ld  [ %l0 + 0x38 ], %l3                        
            the_period->state = RATE_MONOTONIC_ACTIVE;                
40007e9c:	e2 24 20 38 	st  %l1, [ %l0 + 0x38 ]                        
          _ISR_Enable( level );                                       
40007ea0:	7f ff eb 6e 	call  40002c58 <sparc_enable_interrupts>       
40007ea4:	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 ) 
40007ea8:	80 a4 e0 03 	cmp  %l3, 3                                    
40007eac:	12 80 00 05 	bne  40007ec0 <rtems_rate_monotonic_period+0x164>
40007eb0:	01 00 00 00 	nop                                            
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40007eb4:	d0 04 a0 0c 	ld  [ %l2 + 0xc ], %o0                         
40007eb8:	40 00 09 fc 	call  4000a6a8 <_Thread_Clear_state>           
40007ebc:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
                                                                      
          _Thread_Enable_dispatch();                                  
40007ec0:	40 00 0a e5 	call  4000aa54 <_Thread_Enable_dispatch>       
40007ec4:	b0 10 20 00 	clr  %i0                                       
          return RTEMS_SUCCESSFUL;                                    
40007ec8:	81 c7 e0 08 	ret                                            
40007ecc:	81 e8 00 00 	restore                                        
        case RATE_MONOTONIC_EXPIRED:                                  
                                                                      
          /*                                                          
           *  Update statistics from the concluding period            
           */                                                         
          _Rate_monotonic_Update_statistics( the_period );            
40007ed0:	7f ff ff 65 	call  40007c64 <_Rate_monotonic_Update_statistics>
40007ed4:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
          _ISR_Enable( level );                                       
40007ed8:	7f ff eb 60 	call  40002c58 <sparc_enable_interrupts>       
40007edc:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
40007ee0:	82 10 20 02 	mov  2, %g1                                    
40007ee4:	92 04 20 10 	add  %l0, 0x10, %o1                            
40007ee8:	11 10 00 7c 	sethi  %hi(0x4001f000), %o0                    
40007eec:	90 12 21 7c 	or  %o0, 0x17c, %o0	! 4001f17c <_Watchdog_Ticks_chain>
40007ef0:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
          the_period->next_length = length;                           
40007ef4:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40007ef8:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40007efc:	40 00 0f cf 	call  4000be38 <_Watchdog_Insert>              
40007f00:	b0 10 20 06 	mov  6, %i0                                    
                                                                      
          _Watchdog_Insert_ticks( &the_period->Timer, length );       
          _Thread_Enable_dispatch();                                  
40007f04:	40 00 0a d4 	call  4000aa54 <_Thread_Enable_dispatch>       
40007f08:	01 00 00 00 	nop                                            
          return RTEMS_TIMEOUT;                                       
40007f0c:	81 c7 e0 08 	ret                                            
40007f10:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
40007f14:	81 c7 e0 08 	ret                                            
40007f18:	91 e8 20 04 	restore  %g0, 4, %o0                           
}                                                                     
40007f1c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40007f20:	91 e8 20 04 	restore  %g0, 4, %o0                           <== NOT EXECUTED
                                                                      
===============================================================================
40007f24 <rtems_rate_monotonic_report_statistics_with_plugin>:        
 */                                                                   
void rtems_rate_monotonic_report_statistics_with_plugin(              
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
40007f24:	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 )                                                       
40007f28:	80 a6 60 00 	cmp  %i1, 0                                    
40007f2c:	02 80 00 79 	be  40008110 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== NEVER TAKEN
40007f30:	90 10 00 18 	mov  %i0, %o0                                  
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
40007f34:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
40007f38:	9f c6 40 00 	call  %i1                                      
40007f3c:	92 12 61 a8 	or  %o1, 0x1a8, %o1	! 4001d1a8 <CSWTCH.2+0x14> 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
40007f40:	90 10 00 18 	mov  %i0, %o0                                  
40007f44:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
40007f48:	9f c6 40 00 	call  %i1                                      
40007f4c:	92 12 61 c8 	or  %o1, 0x1c8, %o1	! 4001d1c8 <CSWTCH.2+0x34> 
    (*print)( context, "--- Wall times are in seconds ---\n" );       
40007f50:	90 10 00 18 	mov  %i0, %o0                                  
40007f54:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
40007f58:	9f c6 40 00 	call  %i1                                      
40007f5c:	92 12 61 f0 	or  %o1, 0x1f0, %o1	! 4001d1f0 <CSWTCH.2+0x5c> 
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
40007f60:	90 10 00 18 	mov  %i0, %o0                                  
40007f64:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
40007f68:	9f c6 40 00 	call  %i1                                      
40007f6c:	92 12 62 18 	or  %o1, 0x218, %o1	! 4001d218 <CSWTCH.2+0x84> 
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
40007f70:	90 10 00 18 	mov  %i0, %o0                                  
40007f74:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
40007f78:	9f c6 40 00 	call  %i1                                      
40007f7c:	92 12 62 68 	or  %o1, 0x268, %o1	! 4001d268 <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 ;                   
40007f80:	3b 10 00 7b 	sethi  %hi(0x4001ec00), %i5                    
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
40007f84:	2b 10 00 74 	sethi  %hi(0x4001d000), %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 ;                   
40007f88:	82 17 63 44 	or  %i5, 0x344, %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,                                              
40007f8c:	27 10 00 74 	sethi  %hi(0x4001d000), %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,                                              
40007f90:	35 10 00 74 	sethi  %hi(0x4001d000), %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 ;                   
40007f94:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
40007f98:	ae 07 bf a0 	add  %fp, -96, %l7                             
    if ( status != RTEMS_SUCCESSFUL )                                 
      continue;                                                       
                                                                      
    /* If the above passed, so should this but check it anyway */     
    status = rtems_rate_monotonic_get_status( id, &the_status );      
40007f9c:	ac 07 bf d8 	add  %fp, -40, %l6                             
    #if defined(RTEMS_DEBUG)                                          
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
40007fa0:	a4 07 bf f8 	add  %fp, -8, %l2                              
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
40007fa4:	aa 15 62 b8 	or  %l5, 0x2b8, %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;         
40007fa8:	a8 07 bf b8 	add  %fp, -72, %l4                             
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
40007fac:	a2 07 bf f0 	add  %fp, -16, %l1                             
      (*print)( context,                                              
40007fb0:	a6 14 e2 d0 	or  %l3, 0x2d0, %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;       
40007fb4:	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 ;                   
40007fb8:	10 80 00 52 	b  40008100 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc>
40007fbc:	b4 16 a2 f0 	or  %i2, 0x2f0, %i2                            
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
40007fc0:	40 00 17 a7 	call  4000de5c <rtems_rate_monotonic_get_statistics>
40007fc4:	92 10 00 17 	mov  %l7, %o1                                  
    if ( status != RTEMS_SUCCESSFUL )                                 
40007fc8:	80 a2 20 00 	cmp  %o0, 0                                    
40007fcc:	32 80 00 4c 	bne,a   400080fc <rtems_rate_monotonic_report_statistics_with_plugin+0x1d8>
40007fd0:	a0 04 20 01 	inc  %l0                                       
      continue;                                                       
                                                                      
    /* If the above passed, so should this but check it anyway */     
    status = rtems_rate_monotonic_get_status( id, &the_status );      
40007fd4:	92 10 00 16 	mov  %l6, %o1                                  
40007fd8:	40 00 17 ce 	call  4000df10 <rtems_rate_monotonic_get_status>
40007fdc:	90 10 00 10 	mov  %l0, %o0                                  
    #if defined(RTEMS_DEBUG)                                          
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
40007fe0:	d0 07 bf d8 	ld  [ %fp + -40 ], %o0                         
40007fe4:	92 10 20 05 	mov  5, %o1                                    
40007fe8:	40 00 00 ae 	call  400082a0 <rtems_object_get_name>         
40007fec:	94 10 00 12 	mov  %l2, %o2                                  
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
40007ff0:	d8 1f bf a0 	ldd  [ %fp + -96 ], %o4                        
40007ff4:	92 10 00 15 	mov  %l5, %o1                                  
40007ff8:	90 10 00 18 	mov  %i0, %o0                                  
40007ffc:	94 10 00 10 	mov  %l0, %o2                                  
40008000:	9f c6 40 00 	call  %i1                                      
40008004:	96 10 00 12 	mov  %l2, %o3                                  
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
40008008:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         
4000800c:	80 a2 60 00 	cmp  %o1, 0                                    
40008010:	12 80 00 08 	bne  40008030 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c>
40008014:	94 10 00 11 	mov  %l1, %o2                                  
      (*print)( context, "\n" );                                      
40008018:	90 10 00 18 	mov  %i0, %o0                                  
4000801c:	13 10 00 71 	sethi  %hi(0x4001c400), %o1                    
40008020:	9f c6 40 00 	call  %i1                                      
40008024:	92 12 60 88 	or  %o1, 0x88, %o1	! 4001c488 <_rodata_start+0x158>
      continue;                                                       
40008028:	10 80 00 35 	b  400080fc <rtems_rate_monotonic_report_statistics_with_plugin+0x1d8>
4000802c:	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 );
40008030:	40 00 0e 5f 	call  4000b9ac <_Timespec_Divide_by_integer>   
40008034:	90 10 00 14 	mov  %l4, %o0                                  
      (*print)( context,                                              
40008038:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
4000803c:	40 00 44 1a 	call  400190a4 <.div>                          
40008040:	92 10 23 e8 	mov  0x3e8, %o1                                
40008044:	96 10 00 08 	mov  %o0, %o3                                  
40008048:	d0 07 bf b4 	ld  [ %fp + -76 ], %o0                         
4000804c:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        
40008050:	40 00 44 15 	call  400190a4 <.div>                          
40008054:	92 10 23 e8 	mov  0x3e8, %o1                                
40008058:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
4000805c:	b6 10 00 08 	mov  %o0, %i3                                  
40008060:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
40008064:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40008068:	40 00 44 0f 	call  400190a4 <.div>                          
4000806c:	92 10 23 e8 	mov  0x3e8, %o1                                
40008070:	d8 07 bf b0 	ld  [ %fp + -80 ], %o4                         
40008074:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        
40008078:	d4 07 bf a8 	ld  [ %fp + -88 ], %o2                         
4000807c:	9a 10 00 1b 	mov  %i3, %o5                                  
40008080:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
40008084:	92 10 00 13 	mov  %l3, %o1                                  
40008088:	9f c6 40 00 	call  %i1                                      
4000808c:	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);
40008090:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         
40008094:	94 10 00 11 	mov  %l1, %o2                                  
40008098:	40 00 0e 45 	call  4000b9ac <_Timespec_Divide_by_integer>   
4000809c:	90 10 00 1c 	mov  %i4, %o0                                  
      (*print)( context,                                              
400080a0:	d0 07 bf c4 	ld  [ %fp + -60 ], %o0                         
400080a4:	40 00 44 00 	call  400190a4 <.div>                          
400080a8:	92 10 23 e8 	mov  0x3e8, %o1                                
400080ac:	96 10 00 08 	mov  %o0, %o3                                  
400080b0:	d0 07 bf cc 	ld  [ %fp + -52 ], %o0                         
400080b4:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        
400080b8:	40 00 43 fb 	call  400190a4 <.div>                          
400080bc:	92 10 23 e8 	mov  0x3e8, %o1                                
400080c0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
400080c4:	b6 10 00 08 	mov  %o0, %i3                                  
400080c8:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
400080cc:	92 10 23 e8 	mov  0x3e8, %o1                                
400080d0:	40 00 43 f5 	call  400190a4 <.div>                          
400080d4:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
400080d8:	d4 07 bf c0 	ld  [ %fp + -64 ], %o2                         
400080dc:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        
400080e0:	d8 07 bf c8 	ld  [ %fp + -56 ], %o4                         
400080e4:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
400080e8:	92 10 00 1a 	mov  %i2, %o1                                  
400080ec:	90 10 00 18 	mov  %i0, %o0                                  
400080f0:	9f c6 40 00 	call  %i1                                      
400080f4:	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++ ) {                                                      
400080f8:	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 ;                
400080fc:	82 17 63 44 	or  %i5, 0x344, %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 ;                   
40008100:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40008104:	80 a4 00 01 	cmp  %l0, %g1                                  
40008108:	08 bf ff ae 	bleu  40007fc0 <rtems_rate_monotonic_report_statistics_with_plugin+0x9c>
4000810c:	90 10 00 10 	mov  %l0, %o0                                  
40008110:	81 c7 e0 08 	ret                                            
40008114:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
400162d4 <rtems_signal_send>:                                         
                                                                      
rtems_status_code rtems_signal_send(                                  
  rtems_id          id,                                               
  rtems_signal_set  signal_set                                        
)                                                                     
{                                                                     
400162d4:	9d e3 bf 98 	save  %sp, -104, %sp                           
400162d8:	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 )                                                  
400162dc:	80 a6 60 00 	cmp  %i1, 0                                    
400162e0:	02 80 00 2e 	be  40016398 <rtems_signal_send+0xc4>          
400162e4:	b0 10 20 0a 	mov  0xa, %i0                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
400162e8:	40 00 10 9c 	call  4001a558 <_Thread_Get>                   
400162ec:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
400162f0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
400162f4:	a2 10 00 08 	mov  %o0, %l1                                  
  switch ( location ) {                                               
400162f8:	80 a0 60 00 	cmp  %g1, 0                                    
400162fc:	12 80 00 27 	bne  40016398 <rtems_signal_send+0xc4>         
40016300:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
40016304:	e0 02 21 5c 	ld  [ %o0 + 0x15c ], %l0                       
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
40016308:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
4001630c:	80 a0 60 00 	cmp  %g1, 0                                    
40016310:	02 80 00 24 	be  400163a0 <rtems_signal_send+0xcc>          
40016314:	01 00 00 00 	nop                                            
        if ( asr->is_enabled ) {                                      
40016318:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
4001631c:	80 a0 60 00 	cmp  %g1, 0                                    
40016320:	02 80 00 15 	be  40016374 <rtems_signal_send+0xa0>          
40016324:	01 00 00 00 	nop                                            
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
40016328:	7f ff e4 62 	call  4000f4b0 <sparc_disable_interrupts>      
4001632c:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
40016330:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
40016334:	b2 10 40 19 	or  %g1, %i1, %i1                              
40016338:	f2 24 20 14 	st  %i1, [ %l0 + 0x14 ]                        
  _ISR_Enable( _level );                                              
4001633c:	7f ff e4 61 	call  4000f4c0 <sparc_enable_interrupts>       
40016340:	01 00 00 00 	nop                                            
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40016344:	03 10 00 f7 	sethi  %hi(0x4003dc00), %g1                    
40016348:	82 10 60 64 	or  %g1, 0x64, %g1	! 4003dc64 <_Per_CPU_Information>
4001634c:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
40016350:	80 a0 a0 00 	cmp  %g2, 0                                    
40016354:	02 80 00 0f 	be  40016390 <rtems_signal_send+0xbc>          
40016358:	01 00 00 00 	nop                                            
4001635c:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40016360:	80 a4 40 02 	cmp  %l1, %g2                                  
40016364:	12 80 00 0b 	bne  40016390 <rtems_signal_send+0xbc>         <== NEVER TAKEN
40016368:	84 10 20 01 	mov  1, %g2                                    
            _Context_Switch_necessary = true;                         
4001636c:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
40016370:	30 80 00 08 	b,a   40016390 <rtems_signal_send+0xbc>        
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
40016374:	7f ff e4 4f 	call  4000f4b0 <sparc_disable_interrupts>      
40016378:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
4001637c:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
40016380:	b2 10 40 19 	or  %g1, %i1, %i1                              
40016384:	f2 24 20 18 	st  %i1, [ %l0 + 0x18 ]                        
  _ISR_Enable( _level );                                              
40016388:	7f ff e4 4e 	call  4000f4c0 <sparc_enable_interrupts>       
4001638c:	01 00 00 00 	nop                                            
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
40016390:	40 00 10 65 	call  4001a524 <_Thread_Enable_dispatch>       
40016394:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
        return RTEMS_SUCCESSFUL;                                      
40016398:	81 c7 e0 08 	ret                                            
4001639c:	81 e8 00 00 	restore                                        
      }                                                               
      _Thread_Enable_dispatch();                                      
400163a0:	40 00 10 61 	call  4001a524 <_Thread_Enable_dispatch>       
400163a4:	b0 10 20 0b 	mov  0xb, %i0                                  
      return RTEMS_NOT_DEFINED;                                       
400163a8:	81 c7 e0 08 	ret                                            
400163ac:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
4000dcf4 <rtems_task_mode>:                                           
rtems_status_code rtems_task_mode(                                    
  rtems_mode  mode_set,                                               
  rtems_mode  mask,                                                   
  rtems_mode *previous_mode_set                                       
)                                                                     
{                                                                     
4000dcf4:	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 )                                           
4000dcf8:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dcfc:	02 80 00 5f 	be  4000de78 <rtems_task_mode+0x184>           
4000dd00:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
4000dd04:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
4000dd08:	e2 00 61 d8 	ld  [ %g1 + 0x1d8 ], %l1	! 400155d8 <_Per_CPU_Information+0xc>
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000dd0c:	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 ];                
4000dd10:	e0 04 61 5c 	ld  [ %l1 + 0x15c ], %l0                       
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000dd14:	80 a0 00 01 	cmp  %g0, %g1                                  
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000dd18:	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;
4000dd1c:	a4 60 3f ff 	subx  %g0, -1, %l2                             
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000dd20:	80 a0 60 00 	cmp  %g1, 0                                    
4000dd24:	02 80 00 03 	be  4000dd30 <rtems_task_mode+0x3c>            
4000dd28:	a5 2c a0 08 	sll  %l2, 8, %l2                               
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
4000dd2c:	a4 14 a2 00 	or  %l2, 0x200, %l2                            
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
4000dd30:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
4000dd34:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
4000dd38:	7f ff f1 f8 	call  4000a518 <_CPU_ISR_Get_level>            
4000dd3c:	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;           
4000dd40:	a7 2c e0 0a 	sll  %l3, 0xa, %l3                             
4000dd44:	a6 14 c0 08 	or  %l3, %o0, %l3                              
  old_mode |= _ISR_Get_level();                                       
4000dd48:	a4 14 c0 12 	or  %l3, %l2, %l2                              
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
                                                                      
  if ( mask & RTEMS_PREEMPT_MASK )                                    
4000dd4c:	80 8e 61 00 	btst  0x100, %i1                               
4000dd50:	02 80 00 06 	be  4000dd68 <rtems_task_mode+0x74>            
4000dd54:	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;           
4000dd58:	82 0e 21 00 	and  %i0, 0x100, %g1                           
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4000dd5c:	80 a0 00 01 	cmp  %g0, %g1                                  
4000dd60:	82 60 3f ff 	subx  %g0, -1, %g1                             
4000dd64:	c2 2c 60 74 	stb  %g1, [ %l1 + 0x74 ]                       
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
4000dd68:	80 8e 62 00 	btst  0x200, %i1                               
4000dd6c:	02 80 00 0b 	be  4000dd98 <rtems_task_mode+0xa4>            
4000dd70:	80 8e 60 0f 	btst  0xf, %i1                                 
    if ( _Modes_Is_timeslice(mode_set) ) {                            
4000dd74:	80 8e 22 00 	btst  0x200, %i0                               
4000dd78:	22 80 00 07 	be,a   4000dd94 <rtems_task_mode+0xa0>         
4000dd7c:	c0 24 60 7c 	clr  [ %l1 + 0x7c ]                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000dd80:	82 10 20 01 	mov  1, %g1                                    
4000dd84:	c2 24 60 7c 	st  %g1, [ %l1 + 0x7c ]                        
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
4000dd88:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
4000dd8c:	c2 00 62 c8 	ld  [ %g1 + 0x2c8 ], %g1	! 400152c8 <_Thread_Ticks_per_timeslice>
4000dd90:	c2 24 60 78 	st  %g1, [ %l1 + 0x78 ]                        
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
                                                                      
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
4000dd94:	80 8e 60 0f 	btst  0xf, %i1                                 
4000dd98:	02 80 00 06 	be  4000ddb0 <rtems_task_mode+0xbc>            
4000dd9c:	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 );                         
4000dda0:	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 ) );           
4000dda4:	7f ff cf e8 	call  40001d44 <sparc_enable_interrupts>       
4000dda8:	91 2a 20 08 	sll  %o0, 8, %o0                               
   */                                                                 
                                                                      
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
4000ddac:	80 8e 64 00 	btst  0x400, %i1                               
4000ddb0:	02 80 00 14 	be  4000de00 <rtems_task_mode+0x10c>           
4000ddb4:	84 10 20 00 	clr  %g2                                       
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
4000ddb8:	c6 0c 20 08 	ldub  [ %l0 + 8 ], %g3                         
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Modes_Is_asr_disabled (                    
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
   return (mode_set & RTEMS_ASR_MASK) == RTEMS_NO_ASR;                
4000ddbc:	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(                                    
4000ddc0:	80 a0 00 18 	cmp  %g0, %i0                                  
4000ddc4:	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 ) {                        
4000ddc8:	80 a0 40 03 	cmp  %g1, %g3                                  
4000ddcc:	22 80 00 0e 	be,a   4000de04 <rtems_task_mode+0x110>        
4000ddd0:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
)                                                                     
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
4000ddd4:	7f ff cf d8 	call  40001d34 <sparc_disable_interrupts>      
4000ddd8:	c2 2c 20 08 	stb  %g1, [ %l0 + 8 ]                          
    _signals                     = information->signals_pending;      
4000dddc:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
    information->signals_pending = information->signals_posted;       
4000dde0:	c4 04 20 14 	ld  [ %l0 + 0x14 ], %g2                        
    information->signals_posted  = _signals;                          
4000dde4:	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;       
4000dde8:	c4 24 20 18 	st  %g2, [ %l0 + 0x18 ]                        
    information->signals_posted  = _signals;                          
  _ISR_Enable( _level );                                              
4000ddec:	7f ff cf d6 	call  40001d44 <sparc_enable_interrupts>       
4000ddf0:	01 00 00 00 	nop                                            
      asr->is_enabled = is_asr_enabled;                               
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
4000ddf4:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
  /*                                                                  
   *  This is specific to the RTEMS API                               
   */                                                                 
                                                                      
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
4000ddf8:	80 a0 00 01 	cmp  %g0, %g1                                  
4000ddfc:	84 40 20 00 	addx  %g0, 0, %g2                              
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) )                   
4000de00:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
4000de04:	c6 00 60 ec 	ld  [ %g1 + 0xec ], %g3	! 400154ec <_System_state_Current>
4000de08:	80 a0 e0 03 	cmp  %g3, 3                                    
4000de0c:	12 80 00 1b 	bne  4000de78 <rtems_task_mode+0x184>          <== NEVER TAKEN
4000de10:	82 10 20 00 	clr  %g1                                       
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Thread_Evaluate_mode( void )               
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
4000de14:	07 10 00 55 	sethi  %hi(0x40015400), %g3                    
4000de18:	86 10 e1 cc 	or  %g3, 0x1cc, %g3	! 400155cc <_Per_CPU_Information>
4000de1c:	c2 00 e0 0c 	ld  [ %g3 + 0xc ], %g1                         
                                                                      
  if ( !_States_Is_ready( executing->current_state ) ||               
4000de20:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
4000de24:	80 a1 20 00 	cmp  %g4, 0                                    
4000de28:	32 80 00 0b 	bne,a   4000de54 <rtems_task_mode+0x160>       <== NEVER TAKEN
4000de2c:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
4000de30:	c6 00 e0 10 	ld  [ %g3 + 0x10 ], %g3                        
4000de34:	80 a0 40 03 	cmp  %g1, %g3                                  
4000de38:	02 80 00 0b 	be  4000de64 <rtems_task_mode+0x170>           
4000de3c:	80 88 a0 ff 	btst  0xff, %g2                                
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
4000de40:	c2 08 60 74 	ldub  [ %g1 + 0x74 ], %g1                      
4000de44:	80 a0 60 00 	cmp  %g1, 0                                    
4000de48:	02 80 00 07 	be  4000de64 <rtems_task_mode+0x170>           <== NEVER TAKEN
4000de4c:	80 88 a0 ff 	btst  0xff, %g2                                
    _Context_Switch_necessary = true;                                 
4000de50:	84 10 20 01 	mov  1, %g2                                    
4000de54:	03 10 00 55 	sethi  %hi(0x40015400), %g1                    
4000de58:	82 10 61 cc 	or  %g1, 0x1cc, %g1	! 400155cc <_Per_CPU_Information>
4000de5c:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
4000de60:	30 80 00 03 	b,a   4000de6c <rtems_task_mode+0x178>         
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )           
4000de64:	02 80 00 05 	be  4000de78 <rtems_task_mode+0x184>           
4000de68:	82 10 20 00 	clr  %g1                                       
      _Thread_Dispatch();                                             
4000de6c:	7f ff eb 4f 	call  40008ba8 <_Thread_Dispatch>              
4000de70:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000de74:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
}                                                                     
4000de78:	81 c7 e0 08 	ret                                            
4000de7c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
===============================================================================
4000b57c <rtems_task_set_priority>:                                   
rtems_status_code rtems_task_set_priority(                            
  rtems_id             id,                                            
  rtems_task_priority  new_priority,                                  
  rtems_task_priority *old_priority                                   
)                                                                     
{                                                                     
4000b57c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
4000b580:	80 a6 60 00 	cmp  %i1, 0                                    
4000b584:	02 80 00 07 	be  4000b5a0 <rtems_task_set_priority+0x24>    
4000b588:	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 ) );             
4000b58c:	03 10 00 64 	sethi  %hi(0x40019000), %g1                    
4000b590:	c2 08 62 94 	ldub  [ %g1 + 0x294 ], %g1	! 40019294 <rtems_maximum_priority>
4000b594:	80 a6 40 01 	cmp  %i1, %g1                                  
4000b598:	18 80 00 1c 	bgu  4000b608 <rtems_task_set_priority+0x8c>   
4000b59c:	b0 10 20 13 	mov  0x13, %i0                                 
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
4000b5a0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000b5a4:	02 80 00 19 	be  4000b608 <rtems_task_set_priority+0x8c>    
4000b5a8:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000b5ac:	40 00 07 fb 	call  4000d598 <_Thread_Get>                   
4000b5b0:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000b5b4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000b5b8:	80 a0 60 00 	cmp  %g1, 0                                    
4000b5bc:	12 80 00 13 	bne  4000b608 <rtems_task_set_priority+0x8c>   
4000b5c0:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
4000b5c4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
4000b5c8:	80 a6 60 00 	cmp  %i1, 0                                    
4000b5cc:	02 80 00 0d 	be  4000b600 <rtems_task_set_priority+0x84>    
4000b5d0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
4000b5d4:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
4000b5d8:	80 a0 60 00 	cmp  %g1, 0                                    
4000b5dc:	02 80 00 06 	be  4000b5f4 <rtems_task_set_priority+0x78>    
4000b5e0:	f2 22 20 18 	st  %i1, [ %o0 + 0x18 ]                        
4000b5e4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000b5e8:	80 a0 40 19 	cmp  %g1, %i1                                  
4000b5ec:	08 80 00 05 	bleu  4000b600 <rtems_task_set_priority+0x84>  <== ALWAYS TAKEN
4000b5f0:	01 00 00 00 	nop                                            
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
4000b5f4:	92 10 00 19 	mov  %i1, %o1                                  
4000b5f8:	40 00 06 77 	call  4000cfd4 <_Thread_Change_priority>       
4000b5fc:	94 10 20 00 	clr  %o2                                       
      }                                                               
      _Thread_Enable_dispatch();                                      
4000b600:	40 00 07 d9 	call  4000d564 <_Thread_Enable_dispatch>       
4000b604:	b0 10 20 00 	clr  %i0                                       
      return RTEMS_SUCCESSFUL;                                        
4000b608:	81 c7 e0 08 	ret                                            
4000b60c:	81 e8 00 00 	restore                                        
                                                                      
===============================================================================
40016cec <rtems_timer_cancel>:                                        
 */                                                                   
                                                                      
rtems_status_code rtems_timer_cancel(                                 
  rtems_id id                                                         
)                                                                     
{                                                                     
40016cec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
    _Objects_Get( &_Timer_Information, id, location );                
40016cf0:	11 10 00 f7 	sethi  %hi(0x4003dc00), %o0                    
40016cf4:	92 10 00 18 	mov  %i0, %o1                                  
40016cf8:	90 12 20 c4 	or  %o0, 0xc4, %o0                             
40016cfc:	40 00 0b be 	call  40019bf4 <_Objects_Get>                  
40016d00:	94 07 bf fc 	add  %fp, -4, %o2                              
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40016d04:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40016d08:	80 a0 60 00 	cmp  %g1, 0                                    
40016d0c:	12 80 00 0c 	bne  40016d3c <rtems_timer_cancel+0x50>        
40016d10:	01 00 00 00 	nop                                            
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
40016d14:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40016d18:	80 a0 60 04 	cmp  %g1, 4                                    
40016d1c:	02 80 00 04 	be  40016d2c <rtems_timer_cancel+0x40>         <== NEVER TAKEN
40016d20:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &the_timer->Ticker );                
40016d24:	40 00 13 d2 	call  4001bc6c <_Watchdog_Remove>              
40016d28:	90 02 20 10 	add  %o0, 0x10, %o0                            
      _Thread_Enable_dispatch();                                      
40016d2c:	40 00 0d fe 	call  4001a524 <_Thread_Enable_dispatch>       
40016d30:	b0 10 20 00 	clr  %i0                                       
      return RTEMS_SUCCESSFUL;                                        
40016d34:	81 c7 e0 08 	ret                                            
40016d38:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40016d3c:	81 c7 e0 08 	ret                                            
40016d40:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      
===============================================================================
400171d4 <rtems_timer_server_fire_when>:                              
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
400171d4:	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;                 
400171d8:	03 10 00 f7 	sethi  %hi(0x4003dc00), %g1                    
400171dc:	e2 00 61 04 	ld  [ %g1 + 0x104 ], %l1	! 4003dd04 <_Timer_server>
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
400171e0:	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 )                                                
400171e4:	80 a4 60 00 	cmp  %l1, 0                                    
400171e8:	02 80 00 33 	be  400172b4 <rtems_timer_server_fire_when+0xe0>
400171ec:	b0 10 20 0e 	mov  0xe, %i0                                  
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
400171f0:	03 10 00 f6 	sethi  %hi(0x4003d800), %g1                    
400171f4:	c2 08 62 08 	ldub  [ %g1 + 0x208 ], %g1	! 4003da08 <_TOD_Is_set>
400171f8:	80 a0 60 00 	cmp  %g1, 0                                    
400171fc:	02 80 00 2e 	be  400172b4 <rtems_timer_server_fire_when+0xe0><== NEVER TAKEN
40017200:	b0 10 20 0b 	mov  0xb, %i0                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
40017204:	80 a6 a0 00 	cmp  %i2, 0                                    
40017208:	02 80 00 2b 	be  400172b4 <rtems_timer_server_fire_when+0xe0>
4001720c:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
40017210:	90 10 00 19 	mov  %i1, %o0                                  
40017214:	7f ff f4 01 	call  40014218 <_TOD_Validate>                 
40017218:	b0 10 20 14 	mov  0x14, %i0                                 
4001721c:	80 8a 20 ff 	btst  0xff, %o0                                
40017220:	02 80 00 27 	be  400172bc <rtems_timer_server_fire_when+0xe8>
40017224:	01 00 00 00 	nop                                            
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
40017228:	7f ff f3 c8 	call  40014148 <_TOD_To_seconds>               
4001722c:	90 10 00 19 	mov  %i1, %o0                                  
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
40017230:	27 10 00 f6 	sethi  %hi(0x4003d800), %l3                    
40017234:	c2 04 e2 80 	ld  [ %l3 + 0x280 ], %g1	! 4003da80 <_TOD_Now> 
40017238:	80 a2 00 01 	cmp  %o0, %g1                                  
4001723c:	08 80 00 1e 	bleu  400172b4 <rtems_timer_server_fire_when+0xe0>
40017240:	a4 10 00 08 	mov  %o0, %l2                                  
40017244:	11 10 00 f7 	sethi  %hi(0x4003dc00), %o0                    
40017248:	92 10 00 10 	mov  %l0, %o1                                  
4001724c:	90 12 20 c4 	or  %o0, 0xc4, %o0                             
40017250:	40 00 0a 69 	call  40019bf4 <_Objects_Get>                  
40017254:	94 07 bf fc 	add  %fp, -4, %o2                              
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40017258:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001725c:	b2 10 00 08 	mov  %o0, %i1                                  
40017260:	80 a0 60 00 	cmp  %g1, 0                                    
40017264:	12 80 00 14 	bne  400172b4 <rtems_timer_server_fire_when+0xe0>
40017268:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
4001726c:	40 00 12 80 	call  4001bc6c <_Watchdog_Remove>              
40017270:	90 02 20 10 	add  %o0, 0x10, %o0                            
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
40017274:	82 10 20 03 	mov  3, %g1                                    
40017278:	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();
4001727c:	c2 04 e2 80 	ld  [ %l3 + 0x280 ], %g1                       
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
40017280:	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();
40017284:	a4 24 80 01 	sub  %l2, %g1, %l2                             
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
40017288:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
4001728c:	92 10 00 19 	mov  %i1, %o1                                  
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40017290:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
40017294:	f4 26 60 2c 	st  %i2, [ %i1 + 0x2c ]                        
  the_watchdog->id        = id;                                       
40017298:	e0 26 60 30 	st  %l0, [ %i1 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
4001729c:	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();
400172a0:	e4 26 60 1c 	st  %l2, [ %i1 + 0x1c ]                        
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
400172a4:	9f c0 40 00 	call  %g1                                      
400172a8:	b0 10 20 00 	clr  %i0                                       
                                                                      
      _Thread_Enable_dispatch();                                      
400172ac:	40 00 0c 9e 	call  4001a524 <_Thread_Enable_dispatch>       
400172b0:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
400172b4:	81 c7 e0 08 	ret                                            
400172b8:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400172bc:	81 c7 e0 08 	ret                                            
400172c0:	81 e8 00 00 	restore