RTEMS 4.11
Annotated Report
Fri Mar 11 18:36:48 2011

40007a68 <_API_extensions_Run_postdriver>:                            
 *                                                                    
 *  _API_extensions_Run_postdriver                                    
 */                                                                   
                                                                      
void _API_extensions_Run_postdriver( void )                           
{                                                                     
40007a68:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    (*the_extension->postswitch_hook)( _Thread_Executing );           
  }                                                                   
}                                                                     
40007a6c:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
40007a70:	e0 04 61 f4 	ld  [ %l1 + 0x1f4 ], %l0	! 400165f4 <_API_extensions_List>
40007a74:	a2 14 61 f4 	or  %l1, 0x1f4, %l1                            
void _API_extensions_Run_postdriver( void )                           
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40007a78:	a2 04 60 04 	add  %l1, 4, %l1                               
40007a7c:	80 a4 00 11 	cmp  %l0, %l1                                  
40007a80:	02 80 00 09 	be  40007aa4 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
40007a84:	01 00 00 00 	nop                                            
     *  Currently all APIs configure this hook so it is always non-NULL.
     */                                                               
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)              
    if ( the_extension->postdriver_hook )                             
#endif                                                                
      (*the_extension->postdriver_hook)();                            
40007a88:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
40007a8c:	9f c0 40 00 	call  %g1                                      
40007a90:	01 00 00 00 	nop                                            
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
40007a94:	e0 04 00 00 	ld  [ %l0 ], %l0                               
void _API_extensions_Run_postdriver( void )                           
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40007a98:	80 a4 00 11 	cmp  %l0, %l1                                  
40007a9c:	32 bf ff fc 	bne,a   40007a8c <_API_extensions_Run_postdriver+0x24><== NEVER TAKEN
40007aa0:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           <== NOT EXECUTED
40007aa4:	81 c7 e0 08 	ret                                            
40007aa8:	81 e8 00 00 	restore                                        
                                                                      

40007aac <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) {
40007aac:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    (*the_extension->postswitch_hook)( _Thread_Executing );           
  }                                                                   
}                                                                     
40007ab0:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
40007ab4:	e0 04 61 f4 	ld  [ %l1 + 0x1f4 ], %l0	! 400165f4 <_API_extensions_List>
40007ab8:	a2 14 61 f4 	or  %l1, 0x1f4, %l1                            
void _API_extensions_Run_postswitch( void )                           
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40007abc:	a2 04 60 04 	add  %l1, 4, %l1                               
40007ac0:	80 a4 00 11 	cmp  %l0, %l1                                  
40007ac4:	02 80 00 0a 	be  40007aec <_API_extensions_Run_postswitch+0x40><== NEVER TAKEN
40007ac8:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
40007acc:	a4 14 a2 2c 	or  %l2, 0x22c, %l2	! 4001662c <_Per_CPU_Information>
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (API_extensions_Control *) the_node;              
                                                                      
    (*the_extension->postswitch_hook)( _Thread_Executing );           
40007ad0:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
40007ad4:	9f c0 40 00 	call  %g1                                      
40007ad8:	d0 04 a0 0c 	ld  [ %l2 + 0xc ], %o0                         
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
40007adc:	e0 04 00 00 	ld  [ %l0 ], %l0                               
void _API_extensions_Run_postswitch( void )                           
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40007ae0:	80 a4 00 11 	cmp  %l0, %l1                                  
40007ae4:	32 bf ff fc 	bne,a   40007ad4 <_API_extensions_Run_postswitch+0x28><== NEVER TAKEN
40007ae8:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         <== NOT EXECUTED
40007aec:	81 c7 e0 08 	ret                                            
40007af0:	81 e8 00 00 	restore                                        
                                                                      

400119d8 <_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 ) {
400119d8:	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;
  the_message_queue->number_of_pending_messages = 0;                  
400119dc:	c0 26 20 48 	clr  [ %i0 + 0x48 ]                            
)                                                                     
{                                                                     
  size_t message_buffering_required;                                  
  size_t allocated_message_size;                                      
                                                                      
  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
400119e0:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
  the_message_queue->number_of_pending_messages = 0;                  
  the_message_queue->maximum_message_size       = maximum_message_size;
400119e4:	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                 
)                                                                     
{                                                                     
400119e8:	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)) {              
400119ec:	80 8e e0 03 	btst  3, %i3                                   
400119f0:	02 80 00 07 	be  40011a0c <_CORE_message_queue_Initialize+0x34>
400119f4:	a4 10 00 1b 	mov  %i3, %l2                                  
    allocated_message_size += sizeof(uint32_t);                       
400119f8:	a4 06 e0 04 	add  %i3, 4, %l2                               
    allocated_message_size &= ~(sizeof(uint32_t) - 1);                
400119fc:	a4 0c bf fc 	and  %l2, -4, %l2                              
  }                                                                   
                                                                      
  if (allocated_message_size < maximum_message_size)                  
40011a00:	80 a6 c0 12 	cmp  %i3, %l2                                  
40011a04:	18 80 00 22 	bgu  40011a8c <_CORE_message_queue_Initialize+0xb4><== NEVER TAKEN
40011a08:	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));
40011a0c:	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 *    
40011a10:	92 10 00 1a 	mov  %i2, %o1                                  
40011a14:	90 10 00 11 	mov  %l1, %o0                                  
40011a18:	40 00 40 8e 	call  40021c50 <.umul>                         
40011a1c:	b0 10 20 00 	clr  %i0                                       
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
                                                                      
  if (message_buffering_required < allocated_message_size)            
40011a20:	80 a2 00 12 	cmp  %o0, %l2                                  
40011a24:	0a 80 00 1a 	bcs  40011a8c <_CORE_message_queue_Initialize+0xb4><== NEVER TAKEN
40011a28:	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 );               
40011a2c:	40 00 0c a9 	call  40014cd0 <_Workspace_Allocate>           
40011a30:	01 00 00 00 	nop                                            
    return false;                                                     
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
40011a34:	d0 24 20 5c 	st  %o0, [ %l0 + 0x5c ]                        
     _Workspace_Allocate( message_buffering_required );               
                                                                      
  if (the_message_queue->message_buffers == 0)                        
40011a38:	80 a2 20 00 	cmp  %o0, 0                                    
40011a3c:	02 80 00 14 	be  40011a8c <_CORE_message_queue_Initialize+0xb4>
40011a40:	92 10 00 08 	mov  %o0, %o1                                  
                                                                      
  /*                                                                  
   *  Initialize the pool of inactive messages, pending messages,     
   *  and set of waiting threads.                                     
   */                                                                 
  _Chain_Initialize (                                                 
40011a44:	90 04 20 60 	add  %l0, 0x60, %o0                            
40011a48:	94 10 00 1a 	mov  %i2, %o2                                  
40011a4c:	40 00 15 3a 	call  40016f34 <_Chain_Initialize>             
40011a50:	96 10 00 11 	mov  %l1, %o3                                  
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
40011a54:	82 04 20 50 	add  %l0, 0x50, %g1                            
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40011a58:	c0 24 20 54 	clr  [ %l0 + 0x54 ]                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40011a5c:	84 04 20 54 	add  %l0, 0x54, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
40011a60:	c2 24 20 58 	st  %g1, [ %l0 + 0x58 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40011a64:	c4 24 20 50 	st  %g2, [ %l0 + 0x50 ]                        
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );                                                                  
                                                                      
  _Chain_Initialize_empty( &the_message_queue->Pending_messages );    
                                                                      
  _Thread_queue_Initialize(                                           
40011a68:	c2 06 40 00 	ld  [ %i1 ], %g1                               
       THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
40011a6c:	b0 10 20 01 	mov  1, %i0                                    
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );                                                                  
                                                                      
  _Chain_Initialize_empty( &the_message_queue->Pending_messages );    
                                                                      
  _Thread_queue_Initialize(                                           
40011a70:	82 18 60 01 	xor  %g1, 1, %g1                               
40011a74:	80 a0 00 01 	cmp  %g0, %g1                                  
40011a78:	90 10 00 10 	mov  %l0, %o0                                  
40011a7c:	94 10 20 80 	mov  0x80, %o2                                 
40011a80:	92 60 3f ff 	subx  %g0, -1, %o1                             
40011a84:	40 00 09 df 	call  40014200 <_Thread_queue_Initialize>      
40011a88:	96 10 20 06 	mov  6, %o3                                    
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
}                                                                     
40011a8c:	81 c7 e0 08 	ret                                            
40011a90:	81 e8 00 00 	restore                                        
                                                                      

40007df8 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) {
40007df8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
40007dfc:	21 10 00 59 	sethi  %hi(0x40016400), %l0                    
40007e00:	c2 04 20 00 	ld  [ %l0 ], %g1                               
40007e04:	80 a0 60 00 	cmp  %g1, 0                                    
40007e08:	02 80 00 05 	be  40007e1c <_CORE_mutex_Seize+0x24>          
40007e0c:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40007e10:	80 8e a0 ff 	btst  0xff, %i2                                
40007e14:	12 80 00 1a 	bne  40007e7c <_CORE_mutex_Seize+0x84>         <== ALWAYS TAKEN
40007e18:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40007e1c:	90 10 00 18 	mov  %i0, %o0                                  
40007e20:	40 00 14 5a 	call  4000cf88 <_CORE_mutex_Seize_interrupt_trylock>
40007e24:	92 07 a0 54 	add  %fp, 0x54, %o1                            
40007e28:	80 a2 20 00 	cmp  %o0, 0                                    
40007e2c:	02 80 00 12 	be  40007e74 <_CORE_mutex_Seize+0x7c>          
40007e30:	80 8e a0 ff 	btst  0xff, %i2                                
40007e34:	02 80 00 1a 	be  40007e9c <_CORE_mutex_Seize+0xa4>          
40007e38:	01 00 00 00 	nop                                            
40007e3c:	c4 04 20 00 	ld  [ %l0 ], %g2                               
40007e40:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40007e44:	c2 00 62 38 	ld  [ %g1 + 0x238 ], %g1	! 40016638 <_Per_CPU_Information+0xc>
                                                                      
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;
40007e48:	86 10 20 01 	mov  1, %g3                                    
40007e4c:	c6 26 20 30 	st  %g3, [ %i0 + 0x30 ]                        
40007e50:	f0 20 60 44 	st  %i0, [ %g1 + 0x44 ]                        
40007e54:	f2 20 60 20 	st  %i1, [ %g1 + 0x20 ]                        
40007e58:	82 00 a0 01 	add  %g2, 1, %g1                               
40007e5c:	c2 24 20 00 	st  %g1, [ %l0 ]                               
40007e60:	7f ff e8 00 	call  40001e60 <sparc_enable_interrupts>       
40007e64:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
40007e68:	90 10 00 18 	mov  %i0, %o0                                  
40007e6c:	7f ff ff c0 	call  40007d6c <_CORE_mutex_Seize_interrupt_blocking>
40007e70:	92 10 00 1b 	mov  %i3, %o1                                  
40007e74:	81 c7 e0 08 	ret                                            
40007e78:	81 e8 00 00 	restore                                        
40007e7c:	c2 00 61 58 	ld  [ %g1 + 0x158 ], %g1                       
40007e80:	80 a0 60 01 	cmp  %g1, 1                                    
40007e84:	28 bf ff e7 	bleu,a   40007e20 <_CORE_mutex_Seize+0x28>     
40007e88:	90 10 00 18 	mov  %i0, %o0                                  
40007e8c:	90 10 20 00 	clr  %o0                                       
40007e90:	92 10 20 00 	clr  %o1                                       
40007e94:	40 00 01 d8 	call  400085f4 <_Internal_error_Occurred>      
40007e98:	94 10 20 12 	mov  0x12, %o2                                 
40007e9c:	7f ff e7 f1 	call  40001e60 <sparc_enable_interrupts>       
40007ea0:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
40007ea4:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40007ea8:	c2 00 62 38 	ld  [ %g1 + 0x238 ], %g1	! 40016638 <_Per_CPU_Information+0xc>
40007eac:	84 10 20 01 	mov  1, %g2                                    
40007eb0:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
40007eb4:	81 c7 e0 08 	ret                                            
40007eb8:	81 e8 00 00 	restore                                        
                                                                      

40008038 <_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 ) {
40008038:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000803c:	a0 10 00 18 	mov  %i0, %l0                                  
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
40008040:	b0 10 20 00 	clr  %i0                                       
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
40008044:	40 00 07 45 	call  40009d58 <_Thread_queue_Dequeue>         
40008048:	90 10 00 10 	mov  %l0, %o0                                  
4000804c:	80 a2 20 00 	cmp  %o0, 0                                    
40008050:	02 80 00 04 	be  40008060 <_CORE_semaphore_Surrender+0x28>  
40008054:	01 00 00 00 	nop                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
40008058:	81 c7 e0 08 	ret                                            
4000805c:	81 e8 00 00 	restore                                        
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_semaphore_mp_support) ( the_thread, id );                 
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
40008060:	7f ff e7 7c 	call  40001e50 <sparc_disable_interrupts>      
40008064:	01 00 00 00 	nop                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
40008068:	c2 04 20 48 	ld  [ %l0 + 0x48 ], %g1                        
4000806c:	c4 04 20 40 	ld  [ %l0 + 0x40 ], %g2                        
40008070:	80 a0 40 02 	cmp  %g1, %g2                                  
40008074:	1a 80 00 05 	bcc  40008088 <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN
40008078:	b0 10 20 04 	mov  4, %i0                                    
        the_semaphore->count += 1;                                    
4000807c:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
40008080:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;                                    
40008084:	c2 24 20 48 	st  %g1, [ %l0 + 0x48 ]                        
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
40008088:	7f ff e7 76 	call  40001e60 <sparc_enable_interrupts>       
4000808c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
40008090:	81 c7 e0 08 	ret                                            
40008094:	81 e8 00 00 	restore                                        
                                                                      

4000cf20 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) {
4000cf20:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
4000cf24:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
  size_t         node_size                                            
)                                                                     
{                                                                     
  size_t count = number_nodes;                                        
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4000cf28:	a0 06 20 04 	add  %i0, 4, %l0                               
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
4000cf2c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000cf30:	02 80 00 12 	be  4000cf78 <_Chain_Initialize+0x58>          <== NEVER TAKEN
4000cf34:	90 10 00 18 	mov  %i0, %o0                                  
4000cf38:	b4 06 bf ff 	add  %i2, -1, %i2                              
{                                                                     
  size_t count = number_nodes;                                        
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
4000cf3c:	82 10 00 19 	mov  %i1, %g1                                  
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
4000cf40:	92 10 00 1a 	mov  %i2, %o1                                  
)                                                                     
{                                                                     
  size_t count = number_nodes;                                        
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *current = head;                                         
4000cf44:	10 80 00 05 	b  4000cf58 <_Chain_Initialize+0x38>           
4000cf48:	84 10 00 18 	mov  %i0, %g2                                  
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
4000cf4c:	84 10 00 01 	mov  %g1, %g2                                  
4000cf50:	b4 06 bf ff 	add  %i2, -1, %i2                              
    current->next  = next;                                            
    next->previous = current;                                         
    current        = next;                                            
    next           = (Chain_Node *)                                   
4000cf54:	82 10 00 03 	mov  %g3, %g1                                  
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
    current->next  = next;                                            
4000cf58:	c2 20 80 00 	st  %g1, [ %g2 ]                               
    next->previous = current;                                         
4000cf5c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
4000cf60:	80 a6 a0 00 	cmp  %i2, 0                                    
4000cf64:	12 bf ff fa 	bne  4000cf4c <_Chain_Initialize+0x2c>         
4000cf68:	86 00 40 1b 	add  %g1, %i3, %g3                             
 *    node_size        - size of node in bytes                        
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Chain_Initialize(                                               
4000cf6c:	40 00 16 80 	call  4001296c <.umul>                         
4000cf70:	90 10 00 1b 	mov  %i3, %o0                                  
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
4000cf74:	90 06 40 08 	add  %i1, %o0, %o0                             
    current        = next;                                            
    next           = (Chain_Node *)                                   
                        _Addresses_Add_offset( (void *) next, node_size );
  }                                                                   
                                                                      
  current->next = tail;                                               
4000cf78:	e0 22 00 00 	st  %l0, [ %o0 ]                               
  tail->previous = current;                                           
4000cf7c:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
}                                                                     
4000cf80:	81 c7 e0 08 	ret                                            
4000cf84:	81 e8 00 00 	restore                                        
                                                                      

40006cf8 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) {
40006cf8:	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 ];               
40006cfc:	e0 06 21 4c 	ld  [ %i0 + 0x14c ], %l0                       
                                                                      
  option_set = (rtems_option) the_thread->Wait.option;                
                                                                      
  _ISR_Disable( level );                                              
40006d00:	7f ff ec 54 	call  40001e50 <sparc_disable_interrupts>      
40006d04:	e4 06 20 30 	ld  [ %i0 + 0x30 ], %l2                        
40006d08:	a2 10 00 08 	mov  %o0, %l1                                  
  pending_events  = api->pending_events;                              
40006d0c:	c4 04 00 00 	ld  [ %l0 ], %g2                               
  event_condition = (rtems_event_set) the_thread->Wait.count;         
40006d10:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
  seized_events = _Event_sets_Get( pending_events, event_condition ); 
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
40006d14:	86 88 40 02 	andcc  %g1, %g2, %g3                           
40006d18:	02 80 00 3e 	be  40006e10 <_Event_Surrender+0x118>          
40006d1c:	09 10 00 59 	sethi  %hi(0x40016400), %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() &&                                       
40006d20:	88 11 22 2c 	or  %g4, 0x22c, %g4	! 4001662c <_Per_CPU_Information>
40006d24:	da 01 20 08 	ld  [ %g4 + 8 ], %o5                           
40006d28:	80 a3 60 00 	cmp  %o5, 0                                    
40006d2c:	32 80 00 1d 	bne,a   40006da0 <_Event_Surrender+0xa8>       
40006d30:	c8 01 20 0c 	ld  [ %g4 + 0xc ], %g4                         
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (              
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_FOR_EVENT);                    
40006d34:	c8 06 20 10 	ld  [ %i0 + 0x10 ], %g4                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
40006d38:	80 89 21 00 	btst  0x100, %g4                               
40006d3c:	02 80 00 33 	be  40006e08 <_Event_Surrender+0x110>          
40006d40:	80 a0 40 03 	cmp  %g1, %g3                                  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40006d44:	02 80 00 04 	be  40006d54 <_Event_Surrender+0x5c>           
40006d48:	80 8c a0 02 	btst  2, %l2                                   
40006d4c:	02 80 00 2f 	be  40006e08 <_Event_Surrender+0x110>          <== NEVER TAKEN
40006d50:	01 00 00 00 	nop                                            
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006d54:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
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) );                            
40006d58:	84 28 80 03 	andn  %g2, %g3, %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 );
40006d5c:	c4 24 00 00 	st  %g2, [ %l0 ]                               
      the_thread->Wait.count = 0;                                     
40006d60:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006d64:	c6 20 40 00 	st  %g3, [ %g1 ]                               
                                                                      
      _ISR_Flash( level );                                            
40006d68:	7f ff ec 3e 	call  40001e60 <sparc_enable_interrupts>       
40006d6c:	90 10 00 11 	mov  %l1, %o0                                  
40006d70:	7f ff ec 38 	call  40001e50 <sparc_disable_interrupts>      
40006d74:	01 00 00 00 	nop                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
40006d78:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
40006d7c:	80 a0 60 02 	cmp  %g1, 2                                    
40006d80:	02 80 00 26 	be  40006e18 <_Event_Surrender+0x120>          
40006d84:	82 10 20 03 	mov  3, %g1                                    
        _ISR_Enable( level );                                         
40006d88:	90 10 00 11 	mov  %l1, %o0                                  
40006d8c:	7f ff ec 35 	call  40001e60 <sparc_enable_interrupts>       
40006d90:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40006d94:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1003fff8 <RAM_SIZE+0xfc3fff8>
40006d98:	40 00 0a 50 	call  400096d8 <_Thread_Clear_state>           
40006d9c:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  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() &&                                       
40006da0:	80 a6 00 04 	cmp  %i0, %g4                                  
40006da4:	32 bf ff e5 	bne,a   40006d38 <_Event_Surrender+0x40>       
40006da8:	c8 06 20 10 	ld  [ %i0 + 0x10 ], %g4                        
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
40006dac:	09 10 00 59 	sethi  %hi(0x40016400), %g4                    
40006db0:	da 01 22 80 	ld  [ %g4 + 0x280 ], %o5	! 40016680 <_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 ) &&                          
40006db4:	80 a3 60 02 	cmp  %o5, 2                                    
40006db8:	02 80 00 07 	be  40006dd4 <_Event_Surrender+0xdc>           <== NEVER TAKEN
40006dbc:	80 a0 40 03 	cmp  %g1, %g3                                  
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
40006dc0:	da 01 22 80 	ld  [ %g4 + 0x280 ], %o5                       
   *  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) ||   
40006dc4:	80 a3 60 01 	cmp  %o5, 1                                    
40006dc8:	32 bf ff dc 	bne,a   40006d38 <_Event_Surrender+0x40>       
40006dcc:	c8 06 20 10 	ld  [ %i0 + 0x10 ], %g4                        
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
40006dd0:	80 a0 40 03 	cmp  %g1, %g3                                  
40006dd4:	02 80 00 04 	be  40006de4 <_Event_Surrender+0xec>           
40006dd8:	80 8c a0 02 	btst  2, %l2                                   
40006ddc:	02 80 00 09 	be  40006e00 <_Event_Surrender+0x108>          <== NEVER TAKEN
40006de0:	01 00 00 00 	nop                                            
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006de4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
40006de8:	84 28 80 03 	andn  %g2, %g3, %g2                            
  if ( _ISR_Is_in_progress() &&                                       
       _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 );
40006dec:	c4 24 00 00 	st  %g2, [ %l0 ]                               
      the_thread->Wait.count = 0;                                     
40006df0:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006df4:	c6 20 40 00 	st  %g3, [ %g1 ]                               
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;        
40006df8:	82 10 20 03 	mov  3, %g1                                    
40006dfc:	c2 21 22 80 	st  %g1, [ %g4 + 0x280 ]                       
    }                                                                 
    _ISR_Enable( level );                                             
40006e00:	7f ff ec 18 	call  40001e60 <sparc_enable_interrupts>       
40006e04:	91 e8 00 11 	restore  %g0, %l1, %o0                         
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
40006e08:	7f ff ec 16 	call  40001e60 <sparc_enable_interrupts>       
40006e0c:	91 e8 00 11 	restore  %g0, %l1, %o0                         
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
    _ISR_Enable( level );                                             
40006e10:	7f ff ec 14 	call  40001e60 <sparc_enable_interrupts>       
40006e14:	91 e8 00 08 	restore  %g0, %o0, %o0                         
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
40006e18:	c2 26 20 50 	st  %g1, [ %i0 + 0x50 ]                        
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
        _ISR_Enable( level );                                         
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
40006e1c:	7f ff ec 11 	call  40001e60 <sparc_enable_interrupts>       
40006e20:	90 10 00 11 	mov  %l1, %o0                                  
        (void) _Watchdog_Remove( &the_thread->Timer );                
40006e24:	40 00 0f 30 	call  4000aae4 <_Watchdog_Remove>              
40006e28:	90 06 20 48 	add  %i0, 0x48, %o0                            
40006e2c:	33 04 00 ff 	sethi  %hi(0x1003fc00), %i1                    
40006e30:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1003fff8 <RAM_SIZE+0xfc3fff8>
40006e34:	40 00 0a 29 	call  400096d8 <_Thread_Clear_state>           
40006e38:	81 e8 00 00 	restore                                        
                                                                      

40006e40 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) {
40006e40:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
  ISR_Level          level;                                           
                                                                      
  the_thread = _Thread_Get( id, &location );                          
40006e44:	90 10 00 18 	mov  %i0, %o0                                  
40006e48:	40 00 0b 0d 	call  40009a7c <_Thread_Get>                   
40006e4c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40006e50:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006e54:	80 a0 60 00 	cmp  %g1, 0                                    
40006e58:	12 80 00 15 	bne  40006eac <_Event_Timeout+0x6c>            <== NEVER TAKEN
40006e5c:	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 );                                          
40006e60:	7f ff eb fc 	call  40001e50 <sparc_disable_interrupts>      
40006e64:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
40006e68:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
40006e6c:	c2 00 62 38 	ld  [ %g1 + 0x238 ], %g1	! 40016638 <_Per_CPU_Information+0xc>
40006e70:	80 a4 00 01 	cmp  %l0, %g1                                  
40006e74:	02 80 00 10 	be  40006eb4 <_Event_Timeout+0x74>             
40006e78:	c0 24 20 24 	clr  [ %l0 + 0x24 ]                            
          if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
40006e7c:	82 10 20 06 	mov  6, %g1                                    
40006e80:	c2 24 20 34 	st  %g1, [ %l0 + 0x34 ]                        
      _ISR_Enable( level );                                           
40006e84:	7f ff eb f7 	call  40001e60 <sparc_enable_interrupts>       
40006e88:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40006e8c:	90 10 00 10 	mov  %l0, %o0                                  
40006e90:	13 04 00 ff 	sethi  %hi(0x1003fc00), %o1                    
40006e94:	40 00 0a 11 	call  400096d8 <_Thread_Clear_state>           
40006e98:	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;                                
40006e9c:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40006ea0:	c4 00 60 00 	ld  [ %g1 ], %g2                               
40006ea4:	84 00 bf ff 	add  %g2, -1, %g2                              
40006ea8:	c4 20 60 00 	st  %g2, [ %g1 ]                               
40006eac:	81 c7 e0 08 	ret                                            
40006eb0:	81 e8 00 00 	restore                                        
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
          if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
40006eb4:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40006eb8:	c4 00 62 80 	ld  [ %g1 + 0x280 ], %g2	! 40016680 <_Event_Sync_state>
40006ebc:	80 a0 a0 01 	cmp  %g2, 1                                    
40006ec0:	32 bf ff f0 	bne,a   40006e80 <_Event_Timeout+0x40>         
40006ec4:	82 10 20 06 	mov  6, %g1                                    
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
40006ec8:	84 10 20 02 	mov  2, %g2                                    
40006ecc:	c4 20 62 80 	st  %g2, [ %g1 + 0x280 ]                       
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
40006ed0:	10 bf ff ec 	b  40006e80 <_Event_Timeout+0x40>              
40006ed4:	82 10 20 06 	mov  6, %g1                                    
                                                                      

4000d158 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) {
4000d158:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000d15c:	a0 10 00 18 	mov  %i0, %l0                                  
  Heap_Statistics *const stats = &heap->stats;                        
  uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
4000d160:	a4 06 60 04 	add  %i1, 4, %l2                               
    - HEAP_ALLOC_BONUS;                                               
  uintptr_t const page_size = heap->page_size;                        
4000d164:	fa 06 20 10 	ld  [ %i0 + 0x10 ], %i5                        
  Heap_Block *block = NULL;                                           
  uintptr_t alloc_begin = 0;                                          
  uint32_t search_count = 0;                                          
  bool search_again = false;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
4000d168:	80 a6 40 12 	cmp  %i1, %l2                                  
4000d16c:	18 80 00 6e 	bgu  4000d324 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d170:	b0 10 20 00 	clr  %i0                                       
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
4000d174:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d178:	12 80 00 75 	bne  4000d34c <_Heap_Allocate_aligned_with_boundary+0x1f4>
4000d17c:	80 a6 40 1b 	cmp  %i1, %i3                                  
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000d180:	e8 04 20 08 	ld  [ %l0 + 8 ], %l4                           
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d184:	80 a4 00 14 	cmp  %l0, %l4                                  
4000d188:	02 80 00 67 	be  4000d324 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d18c:	b0 10 20 00 	clr  %i0                                       
  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    
4000d190:	82 07 60 07 	add  %i5, 7, %g1                               
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
4000d194:	b8 10 20 04 	mov  4, %i4                                    
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d198:	a2 10 20 01 	mov  1, %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    
4000d19c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
4000d1a0:	b8 27 00 19 	sub  %i4, %i1, %i4                             
      /*                                                              
       * 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 ) {                
4000d1a4:	e6 05 20 04 	ld  [ %l4 + 4 ], %l3                           
4000d1a8:	80 a4 80 13 	cmp  %l2, %l3                                  
4000d1ac:	3a 80 00 4b 	bcc,a   4000d2d8 <_Heap_Allocate_aligned_with_boundary+0x180>
4000d1b0:	e8 05 20 08 	ld  [ %l4 + 8 ], %l4                           
        if ( alignment == 0 ) {                                       
4000d1b4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000d1b8:	02 80 00 44 	be  4000d2c8 <_Heap_Allocate_aligned_with_boundary+0x170>
4000d1bc:	b0 05 20 08 	add  %l4, 8, %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;                         
4000d1c0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000d1c4:	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;                
4000d1c8:	a6 0c ff fe 	and  %l3, -2, %l3                              
  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;                         
4000d1cc:	82 20 80 17 	sub  %g2, %l7, %g1                             
  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;               
4000d1d0:	a6 05 00 13 	add  %l4, %l3, %l3                             
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d1d4:	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    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
4000d1d8:	b0 07 00 13 	add  %i4, %l3, %i0                             
  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    
4000d1dc:	a6 00 40 13 	add  %g1, %l3, %l3                             
4000d1e0:	40 00 16 c9 	call  40012d04 <.urem>                         
4000d1e4:	90 10 00 18 	mov  %i0, %o0                                  
4000d1e8:	b0 26 00 08 	sub  %i0, %o0, %i0                             
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
                                                                      
  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 ) {                          
4000d1ec:	80 a4 c0 18 	cmp  %l3, %i0                                  
4000d1f0:	1a 80 00 06 	bcc  4000d208 <_Heap_Allocate_aligned_with_boundary+0xb0>
4000d1f4:	ac 05 20 08 	add  %l4, 8, %l6                               
4000d1f8:	90 10 00 13 	mov  %l3, %o0                                  
4000d1fc:	40 00 16 c2 	call  40012d04 <.urem>                         
4000d200:	92 10 00 1a 	mov  %i2, %o1                                  
4000d204:	b0 24 c0 08 	sub  %l3, %o0, %i0                             
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
4000d208:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d20c:	02 80 00 24 	be  4000d29c <_Heap_Allocate_aligned_with_boundary+0x144>
4000d210:	80 a5 80 18 	cmp  %l6, %i0                                  
  /* 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;                               
4000d214:	a6 06 00 19 	add  %i0, %i1, %l3                             
4000d218:	92 10 00 1b 	mov  %i3, %o1                                  
4000d21c:	40 00 16 ba 	call  40012d04 <.urem>                         
4000d220:	90 10 00 13 	mov  %l3, %o0                                  
4000d224:	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 ) {
4000d228:	80 a2 00 13 	cmp  %o0, %l3                                  
4000d22c:	1a 80 00 1b 	bcc  4000d298 <_Heap_Allocate_aligned_with_boundary+0x140>
4000d230:	80 a6 00 08 	cmp  %i0, %o0                                  
4000d234:	1a 80 00 1a 	bcc  4000d29c <_Heap_Allocate_aligned_with_boundary+0x144>
4000d238:	80 a5 80 18 	cmp  %l6, %i0                                  
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
4000d23c:	aa 05 80 19 	add  %l6, %i1, %l5                             
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
      if ( boundary_line < boundary_floor ) {                         
4000d240:	80 a5 40 08 	cmp  %l5, %o0                                  
4000d244:	28 80 00 09 	bleu,a   4000d268 <_Heap_Allocate_aligned_with_boundary+0x110>
4000d248:	b0 22 00 19 	sub  %o0, %i1, %i0                             
                                                                      
      if ( alloc_begin != 0 ) {                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000d24c:	10 80 00 23 	b  4000d2d8 <_Heap_Allocate_aligned_with_boundary+0x180>
4000d250:	e8 05 20 08 	ld  [ %l4 + 8 ], %l4                           
  /* 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 ) {
4000d254:	1a 80 00 11 	bcc  4000d298 <_Heap_Allocate_aligned_with_boundary+0x140>
4000d258:	80 a5 40 08 	cmp  %l5, %o0                                  
      if ( boundary_line < boundary_floor ) {                         
4000d25c:	38 80 00 1f 	bgu,a   4000d2d8 <_Heap_Allocate_aligned_with_boundary+0x180><== NEVER TAKEN
4000d260:	e8 05 20 08 	ld  [ %l4 + 8 ], %l4                           <== NOT EXECUTED
        return 0;                                                     
      }                                                               
      alloc_begin = boundary_line - alloc_size;                       
4000d264:	b0 22 00 19 	sub  %o0, %i1, %i0                             
4000d268:	92 10 00 1a 	mov  %i2, %o1                                  
4000d26c:	40 00 16 a6 	call  40012d04 <.urem>                         
4000d270:	90 10 00 18 	mov  %i0, %o0                                  
4000d274:	92 10 00 1b 	mov  %i3, %o1                                  
4000d278:	b0 26 00 08 	sub  %i0, %o0, %i0                             
      alloc_begin = _Heap_Align_down( alloc_begin, alignment );       
      alloc_end = alloc_begin + alloc_size;                           
4000d27c:	a6 06 00 19 	add  %i0, %i1, %l3                             
4000d280:	40 00 16 a1 	call  40012d04 <.urem>                         
4000d284:	90 10 00 13 	mov  %l3, %o0                                  
4000d288:	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 ) {
4000d28c:	80 a2 00 13 	cmp  %o0, %l3                                  
4000d290:	0a bf ff f1 	bcs  4000d254 <_Heap_Allocate_aligned_with_boundary+0xfc>
4000d294:	80 a6 00 08 	cmp  %i0, %o0                                  
      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 ) {                           
4000d298:	80 a5 80 18 	cmp  %l6, %i0                                  
4000d29c:	38 80 00 0f 	bgu,a   4000d2d8 <_Heap_Allocate_aligned_with_boundary+0x180>
4000d2a0:	e8 05 20 08 	ld  [ %l4 + 8 ], %l4                           
4000d2a4:	82 10 3f f8 	mov  -8, %g1                                   
4000d2a8:	90 10 00 18 	mov  %i0, %o0                                  
4000d2ac:	a6 20 40 14 	sub  %g1, %l4, %l3                             
4000d2b0:	92 10 00 1d 	mov  %i5, %o1                                  
4000d2b4:	40 00 16 94 	call  40012d04 <.urem>                         
4000d2b8:	a6 04 c0 18 	add  %l3, %i0, %l3                             
    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 ) {            
4000d2bc:	90 a4 c0 08 	subcc  %l3, %o0, %o0                           
4000d2c0:	12 80 00 1b 	bne  4000d32c <_Heap_Allocate_aligned_with_boundary+0x1d4>
4000d2c4:	80 a2 00 17 	cmp  %o0, %l7                                  
      }                                                               
                                                                      
      /* Statistics */                                                
      ++search_count;                                                 
                                                                      
      if ( alloc_begin != 0 ) {                                       
4000d2c8:	80 a6 20 00 	cmp  %i0, 0                                    
4000d2cc:	32 80 00 08 	bne,a   4000d2ec <_Heap_Allocate_aligned_with_boundary+0x194><== ALWAYS TAKEN
4000d2d0:	c4 04 20 48 	ld  [ %l0 + 0x48 ], %g2                        
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000d2d4:	e8 05 20 08 	ld  [ %l4 + 8 ], %l4                           <== NOT EXECUTED
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d2d8:	80 a4 00 14 	cmp  %l0, %l4                                  
4000d2dc:	02 80 00 1a 	be  4000d344 <_Heap_Allocate_aligned_with_boundary+0x1ec>
4000d2e0:	82 04 60 01 	add  %l1, 1, %g1                               
4000d2e4:	10 bf ff b0 	b  4000d1a4 <_Heap_Allocate_aligned_with_boundary+0x4c>
4000d2e8:	a2 10 00 01 	mov  %g1, %l1                                  
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
    stats->searches += search_count;                                  
4000d2ec:	c2 04 20 4c 	ld  [ %l0 + 0x4c ], %g1                        
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
4000d2f0:	84 00 a0 01 	inc  %g2                                       
    stats->searches += search_count;                                  
4000d2f4:	82 00 40 11 	add  %g1, %l1, %g1                             
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
4000d2f8:	c4 24 20 48 	st  %g2, [ %l0 + 0x48 ]                        
    stats->searches += search_count;                                  
4000d2fc:	c2 24 20 4c 	st  %g1, [ %l0 + 0x4c ]                        
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000d300:	90 10 00 10 	mov  %l0, %o0                                  
4000d304:	92 10 00 14 	mov  %l4, %o1                                  
4000d308:	94 10 00 18 	mov  %i0, %o2                                  
4000d30c:	7f ff ec 6e 	call  400084c4 <_Heap_Block_allocate>          
4000d310:	96 10 00 19 	mov  %i1, %o3                                  
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000d314:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
4000d318:	80 a0 40 11 	cmp  %g1, %l1                                  
4000d31c:	2a 80 00 02 	bcs,a   4000d324 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d320:	e2 24 20 44 	st  %l1, [ %l0 + 0x44 ]                        
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000d324:	81 c7 e0 08 	ret                                            
4000d328:	81 e8 00 00 	restore                                        
  if ( alloc_begin >= alloc_begin_floor ) {                           
    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 ) {            
4000d32c:	1a bf ff e8 	bcc  4000d2cc <_Heap_Allocate_aligned_with_boundary+0x174>
4000d330:	80 a6 20 00 	cmp  %i0, 0                                    
                                                                      
      if ( alloc_begin != 0 ) {                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000d334:	e8 05 20 08 	ld  [ %l4 + 8 ], %l4                           
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d338:	80 a4 00 14 	cmp  %l0, %l4                                  
4000d33c:	12 bf ff ea 	bne  4000d2e4 <_Heap_Allocate_aligned_with_boundary+0x18c>
4000d340:	82 04 60 01 	add  %l1, 1, %g1                               
4000d344:	10 bf ff f4 	b  4000d314 <_Heap_Allocate_aligned_with_boundary+0x1bc>
4000d348:	b0 10 20 00 	clr  %i0                                       
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
    if ( boundary < alloc_size ) {                                    
4000d34c:	18 bf ff f6 	bgu  4000d324 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d350:	80 a6 a0 00 	cmp  %i2, 0                                    
      return NULL;                                                    
    }                                                                 
                                                                      
    if ( alignment == 0 ) {                                           
4000d354:	22 bf ff 8b 	be,a   4000d180 <_Heap_Allocate_aligned_with_boundary+0x28>
4000d358:	b4 10 00 1d 	mov  %i5, %i2                                  
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000d35c:	10 bf ff 8a 	b  4000d184 <_Heap_Allocate_aligned_with_boundary+0x2c>
4000d360:	e8 04 20 08 	ld  [ %l0 + 8 ], %l4                           
                                                                      

4000d66c <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) {
4000d66c:	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;                              
4000d670:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  Heap_Block *extend_last_block = NULL;                               
4000d674:	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                                        
)                                                                     
{                                                                     
4000d678:	a0 10 00 18 	mov  %i0, %l0                                  
  Heap_Block *extend_first_block = NULL;                              
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
  uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
  uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
4000d67c:	a2 06 40 1a 	add  %i1, %i2, %l1                             
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const first_block = heap->first_block;                  
4000d680:	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;                        
4000d684:	e6 06 20 10 	ld  [ %i0 + 0x10 ], %l3                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000d688:	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;
  uintptr_t const free_size = stats->free_size;                       
4000d68c:	e8 06 20 30 	ld  [ %i0 + 0x30 ], %l4                        
  uintptr_t extend_first_block_size = 0;                              
  uintptr_t extended_size = 0;                                        
  bool extend_area_ok = false;                                        
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
4000d690:	80 a6 40 11 	cmp  %i1, %l1                                  
4000d694:	18 80 00 86 	bgu  4000d8ac <_Heap_Extend+0x240>             
4000d698:	b0 10 20 00 	clr  %i0                                       
    return false;                                                     
  }                                                                   
                                                                      
  extend_area_ok = _Heap_Get_first_and_last_block(                    
4000d69c:	90 10 00 19 	mov  %i1, %o0                                  
4000d6a0:	92 10 00 1a 	mov  %i2, %o1                                  
4000d6a4:	94 10 00 13 	mov  %l3, %o2                                  
4000d6a8:	98 07 bf fc 	add  %fp, -4, %o4                              
4000d6ac:	7f ff eb e7 	call  40008648 <_Heap_Get_first_and_last_block>
4000d6b0:	9a 07 bf f8 	add  %fp, -8, %o5                              
    page_size,                                                        
    min_block_size,                                                   
    &extend_first_block,                                              
    &extend_last_block                                                
  );                                                                  
  if (!extend_area_ok ) {                                             
4000d6b4:	80 8a 20 ff 	btst  0xff, %o0                                
4000d6b8:	02 80 00 7d 	be  4000d8ac <_Heap_Extend+0x240>              
4000d6bc:	ba 10 20 00 	clr  %i5                                       
4000d6c0:	b0 10 00 12 	mov  %l2, %i0                                  
4000d6c4:	b8 10 20 00 	clr  %i4                                       
4000d6c8:	ac 10 20 00 	clr  %l6                                       
4000d6cc:	10 80 00 14 	b  4000d71c <_Heap_Extend+0xb0>                
4000d6d0:	ae 10 20 00 	clr  %l7                                       
      return false;                                                   
    }                                                                 
                                                                      
    if ( extend_area_end == sub_area_begin ) {                        
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
4000d6d4:	2a 80 00 02 	bcs,a   4000d6dc <_Heap_Extend+0x70>           
4000d6d8:	b8 10 00 18 	mov  %i0, %i4                                  
4000d6dc:	90 10 00 15 	mov  %l5, %o0                                  
4000d6e0:	40 00 16 dc 	call  40013250 <.urem>                         
4000d6e4:	92 10 00 13 	mov  %l3, %o1                                  
4000d6e8:	82 05 7f f8 	add  %l5, -8, %g1                              
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
4000d6ec:	80 a5 40 19 	cmp  %l5, %i1                                  
4000d6f0:	02 80 00 1c 	be  4000d760 <_Heap_Extend+0xf4>               
4000d6f4:	82 20 40 08 	sub  %g1, %o0, %g1                             
      start_block->prev_size = extend_area_end;                       
                                                                      
      merge_above_block = end_block;                                  
    } else if ( sub_area_end < extend_area_begin ) {                  
4000d6f8:	80 a6 40 15 	cmp  %i1, %l5                                  
4000d6fc:	38 80 00 02 	bgu,a   4000d704 <_Heap_Extend+0x98>           
4000d700:	ba 10 00 01 	mov  %g1, %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;                
4000d704:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
4000d708:	b0 0e 3f fe 	and  %i0, -2, %i0                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d70c:	b0 00 40 18 	add  %g1, %i0, %i0                             
      link_above_block = end_block;                                   
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
4000d710:	80 a4 80 18 	cmp  %l2, %i0                                  
4000d714:	22 80 00 1b 	be,a   4000d780 <_Heap_Extend+0x114>           
4000d718:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
    return false;                                                     
  }                                                                   
                                                                      
  do {                                                                
    uintptr_t const sub_area_begin = (start_block != first_block) ?   
      (uintptr_t) start_block : heap->area_begin;                     
4000d71c:	80 a6 00 12 	cmp  %i0, %l2                                  
4000d720:	02 80 00 65 	be  4000d8b4 <_Heap_Extend+0x248>              
4000d724:	82 10 00 18 	mov  %i0, %g1                                  
    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 (                                                              
4000d728:	80 a0 40 11 	cmp  %g1, %l1                                  
4000d72c:	0a 80 00 6f 	bcs  4000d8e8 <_Heap_Extend+0x27c>             
4000d730:	ea 06 00 00 	ld  [ %i0 ], %l5                               
      sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
    ) {                                                               
      return false;                                                   
    }                                                                 
                                                                      
    if ( extend_area_end == sub_area_begin ) {                        
4000d734:	80 a0 40 11 	cmp  %g1, %l1                                  
4000d738:	12 bf ff e7 	bne  4000d6d4 <_Heap_Extend+0x68>              
4000d73c:	80 a4 40 15 	cmp  %l1, %l5                                  
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d740:	90 10 00 15 	mov  %l5, %o0                                  
4000d744:	40 00 16 c3 	call  40013250 <.urem>                         
4000d748:	92 10 00 13 	mov  %l3, %o1                                  
4000d74c:	82 05 7f f8 	add  %l5, -8, %g1                              
4000d750:	ae 10 00 18 	mov  %i0, %l7                                  
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
4000d754:	80 a5 40 19 	cmp  %l5, %i1                                  
4000d758:	12 bf ff e8 	bne  4000d6f8 <_Heap_Extend+0x8c>              <== ALWAYS TAKEN
4000d75c:	82 20 40 08 	sub  %g1, %o0, %g1                             
      start_block->prev_size = extend_area_end;                       
4000d760:	e2 26 00 00 	st  %l1, [ %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;                
4000d764:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
4000d768:	b0 0e 3f fe 	and  %i0, -2, %i0                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d76c:	b0 00 40 18 	add  %g1, %i0, %i0                             
    } else if ( sub_area_end < extend_area_begin ) {                  
      link_above_block = end_block;                                   
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
4000d770:	80 a4 80 18 	cmp  %l2, %i0                                  
4000d774:	12 bf ff ea 	bne  4000d71c <_Heap_Extend+0xb0>              <== NEVER TAKEN
4000d778:	ac 10 00 01 	mov  %g1, %l6                                  
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
4000d77c:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
4000d780:	80 a6 40 01 	cmp  %i1, %g1                                  
4000d784:	3a 80 00 54 	bcc,a   4000d8d4 <_Heap_Extend+0x268>          
4000d788:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
    heap->area_begin = extend_area_begin;                             
4000d78c:	f2 24 20 18 	st  %i1, [ %l0 + 0x18 ]                        
  } else if ( heap->area_end < extend_area_end ) {                    
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
4000d790:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000d794:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000d798:	c8 04 20 20 	ld  [ %l0 + 0x20 ], %g4                        
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
4000d79c:	86 20 80 01 	sub  %g2, %g1, %g3                             
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
4000d7a0:	e2 20 40 00 	st  %l1, [ %g1 ]                               
  extend_first_block->size_and_flag =                                 
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
4000d7a4:	9a 10 e0 01 	or  %g3, 1, %o5                                
                                                                      
  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 =                                 
4000d7a8:	da 20 60 04 	st  %o5, [ %g1 + 4 ]                           
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
  _Heap_Protection_block_initialize( heap, extend_first_block );      
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
4000d7ac:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000d7b0:	80 a1 00 01 	cmp  %g4, %g1                                  
4000d7b4:	08 80 00 42 	bleu  4000d8bc <_Heap_Extend+0x250>            
4000d7b8:	c0 20 a0 04 	clr  [ %g2 + 4 ]                               
    heap->first_block = extend_first_block;                           
4000d7bc:	c2 24 20 20 	st  %g1, [ %l0 + 0x20 ]                        
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
4000d7c0:	80 a5 e0 00 	cmp  %l7, 0                                    
4000d7c4:	02 80 00 62 	be  4000d94c <_Heap_Extend+0x2e0>              
4000d7c8:	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;                        
4000d7cc:	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;                            
4000d7d0:	92 10 00 12 	mov  %l2, %o1                                  
4000d7d4:	40 00 16 9f 	call  40013250 <.urem>                         
4000d7d8:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( remainder != 0 ) {                                             
4000d7dc:	80 a2 20 00 	cmp  %o0, 0                                    
4000d7e0:	02 80 00 04 	be  4000d7f0 <_Heap_Extend+0x184>              
4000d7e4:	c4 05 c0 00 	ld  [ %l7 ], %g2                               
    return value - remainder + alignment;                             
4000d7e8:	b2 06 40 12 	add  %i1, %l2, %i1                             
4000d7ec:	b2 26 40 08 	sub  %i1, %o0, %i1                             
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
4000d7f0:	82 06 7f f8 	add  %i1, -8, %g1                              
  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;                
4000d7f4:	c4 26 7f f8 	st  %g2, [ %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 =                              
4000d7f8:	84 25 c0 01 	sub  %l7, %g1, %g2                             
    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;
4000d7fc:	84 10 a0 01 	or  %g2, 1, %g2                                
                                                                      
  _Heap_Free_block( heap, new_first_block );                          
4000d800:	90 10 00 10 	mov  %l0, %o0                                  
4000d804:	92 10 00 01 	mov  %g1, %o1                                  
4000d808:	7f ff ff 8e 	call  4000d640 <_Heap_Free_block>              
4000d80c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
4000d810:	80 a5 a0 00 	cmp  %l6, 0                                    
4000d814:	02 80 00 3a 	be  4000d8fc <_Heap_Extend+0x290>              
4000d818:	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);                                 
4000d81c:	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(             
4000d820:	a2 24 40 16 	sub  %l1, %l6, %l1                             
4000d824:	40 00 16 8b 	call  40013250 <.urem>                         
4000d828:	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)                 
4000d82c:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
4000d830:	a2 24 40 08 	sub  %l1, %o0, %l1                             
4000d834:	82 20 40 11 	sub  %g1, %l1, %g1                             
      | HEAP_PREV_BLOCK_USED;                                         
4000d838:	82 10 60 01 	or  %g1, 1, %g1                                
    page_size                                                         
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
4000d83c:	84 04 40 16 	add  %l1, %l6, %g2                             
4000d840:	c2 20 a0 04 	st  %g1, [ %g2 + 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;       
4000d844:	c2 05 a0 04 	ld  [ %l6 + 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 );                               
4000d848:	90 10 00 10 	mov  %l0, %o0                                  
4000d84c:	82 08 60 01 	and  %g1, 1, %g1                               
4000d850:	92 10 00 16 	mov  %l6, %o1                                  
                                                                      
  block->size_and_flag = size | flag;                                 
4000d854:	a2 14 40 01 	or  %l1, %g1, %l1                              
4000d858:	7f ff ff 7a 	call  4000d640 <_Heap_Free_block>              
4000d85c:	e2 25 a0 04 	st  %l1, [ %l6 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000d860:	80 a5 a0 00 	cmp  %l6, 0                                    
4000d864:	02 80 00 33 	be  4000d930 <_Heap_Extend+0x2c4>              
4000d868:	80 a5 e0 00 	cmp  %l7, 0                                    
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
}                                                                     
4000d86c:	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(                                               
4000d870:	da 04 20 20 	ld  [ %l0 + 0x20 ], %o5                        
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;       
4000d874:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
4000d878:	c4 04 20 2c 	ld  [ %l0 + 0x2c ], %g2                        
    _Heap_Free_block( heap, extend_first_block );                     
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
4000d87c:	c6 04 20 30 	ld  [ %l0 + 0x30 ], %g3                        
 * 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(                                               
4000d880:	9a 23 40 01 	sub  %o5, %g1, %o5                             
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;       
4000d884:	88 09 20 01 	and  %g4, 1, %g4                               
                                                                      
  block->size_and_flag = size | flag;                                 
4000d888:	88 13 40 04 	or  %o5, %g4, %g4                              
4000d88c:	c8 20 60 04 	st  %g4, [ %g1 + 4 ]                           
4000d890:	a8 20 c0 14 	sub  %g3, %l4, %l4                             
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
4000d894:	82 00 80 14 	add  %g2, %l4, %g1                             
4000d898:	c2 24 20 2c 	st  %g1, [ %l0 + 0x2c ]                        
                                                                      
  if ( extended_size_ptr != NULL )                                    
4000d89c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d8a0:	02 80 00 03 	be  4000d8ac <_Heap_Extend+0x240>              <== NEVER TAKEN
4000d8a4:	b0 10 20 01 	mov  1, %i0                                    
    *extended_size_ptr = extended_size;                               
4000d8a8:	e8 26 c0 00 	st  %l4, [ %i3 ]                               
4000d8ac:	81 c7 e0 08 	ret                                            
4000d8b0:	81 e8 00 00 	restore                                        
    return false;                                                     
  }                                                                   
                                                                      
  do {                                                                
    uintptr_t const sub_area_begin = (start_block != first_block) ?   
      (uintptr_t) start_block : heap->area_begin;                     
4000d8b4:	10 bf ff 9d 	b  4000d728 <_Heap_Extend+0xbc>                
4000d8b8:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
    heap->first_block = extend_first_block;                           
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4000d8bc:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
4000d8c0:	80 a0 40 02 	cmp  %g1, %g2                                  
4000d8c4:	2a bf ff bf 	bcs,a   4000d7c0 <_Heap_Extend+0x154>          
4000d8c8:	c4 24 20 24 	st  %g2, [ %l0 + 0x24 ]                        
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
4000d8cc:	10 bf ff be 	b  4000d7c4 <_Heap_Extend+0x158>               
4000d8d0:	80 a5 e0 00 	cmp  %l7, 0                                    
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
4000d8d4:	80 a4 40 01 	cmp  %l1, %g1                                  
4000d8d8:	38 bf ff ae 	bgu,a   4000d790 <_Heap_Extend+0x124>          
4000d8dc:	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;   
4000d8e0:	10 bf ff ad 	b  4000d794 <_Heap_Extend+0x128>               
4000d8e4:	c2 07 bf fc 	ld  [ %fp + -4 ], %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 (                                                              
4000d8e8:	80 a6 40 15 	cmp  %i1, %l5                                  
4000d8ec:	1a bf ff 93 	bcc  4000d738 <_Heap_Extend+0xcc>              
4000d8f0:	80 a0 40 11 	cmp  %g1, %l1                                  
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
}                                                                     
4000d8f4:	81 c7 e0 08 	ret                                            
4000d8f8:	91 e8 20 00 	restore  %g0, 0, %o0                           
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
    _Heap_Merge_above( heap, merge_above_block, extend_area_end );    
  } else if ( link_above_block != NULL ) {                            
4000d8fc:	80 a7 60 00 	cmp  %i5, 0                                    
4000d900:	02 bf ff d8 	be  4000d860 <_Heap_Extend+0x1f4>              
4000d904:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
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;       
4000d908:	c6 07 60 04 	ld  [ %i5 + 4 ], %g3                           
    _Heap_Link_above(                                                 
4000d90c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000d910:	86 08 e0 01 	and  %g3, 1, %g3                               
)                                                                     
{                                                                     
  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 );       
4000d914:	84 20 80 1d 	sub  %g2, %i5, %g2                             
                                                                      
  block->size_and_flag = size | flag;                                 
4000d918:	84 10 80 03 	or  %g2, %g3, %g2                              
4000d91c:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
                                                                      
  last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                  
4000d920:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000d924:	84 10 a0 01 	or  %g2, 1, %g2                                
4000d928:	10 bf ff ce 	b  4000d860 <_Heap_Extend+0x1f4>               
4000d92c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000d930:	32 bf ff d0 	bne,a   4000d870 <_Heap_Extend+0x204>          
4000d934:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
    _Heap_Free_block( heap, extend_first_block );                     
4000d938:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
4000d93c:	7f ff ff 41 	call  4000d640 <_Heap_Free_block>              
4000d940:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
}                                                                     
4000d944:	10 bf ff cb 	b  4000d870 <_Heap_Extend+0x204>               
4000d948:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
    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 ) {                            
4000d94c:	80 a7 20 00 	cmp  %i4, 0                                    
4000d950:	02 bf ff b1 	be  4000d814 <_Heap_Extend+0x1a8>              
4000d954:	80 a5 a0 00 	cmp  %l6, 0                                    
{                                                                     
  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;           
4000d958:	b8 27 00 02 	sub  %i4, %g2, %i4                             
4000d95c:	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 =                                         
4000d960:	10 bf ff ad 	b  4000d814 <_Heap_Extend+0x1a8>               
4000d964:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
                                                                      

4000d364 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) {
4000d364:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000d368:	a0 10 00 18 	mov  %i0, %l0                                  
  /*                                                                  
   * If NULL return true so a free on NULL is considered a valid release. This
   * is a special case that could be handled by the in heap check how-ever that
   * would result in false being returned which is wrong.             
   */                                                                 
  if ( alloc_begin_ptr == NULL ) {                                    
4000d36c:	80 a6 60 00 	cmp  %i1, 0                                    
4000d370:	02 80 00 56 	be  4000d4c8 <_Heap_Free+0x164>                
4000d374:	b0 10 20 01 	mov  1, %i0                                    
4000d378:	d2 04 20 10 	ld  [ %l0 + 0x10 ], %o1                        
4000d37c:	40 00 16 62 	call  40012d04 <.urem>                         
4000d380:	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           
4000d384:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %g1                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d388:	a2 06 7f f8 	add  %i1, -8, %l1                              
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
4000d38c:	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;             
4000d390:	80 a2 00 01 	cmp  %o0, %g1                                  
4000d394:	0a 80 00 4d 	bcs  4000d4c8 <_Heap_Free+0x164>               
4000d398:	b0 10 20 00 	clr  %i0                                       
4000d39c:	c6 04 20 24 	ld  [ %l0 + 0x24 ], %g3                        
4000d3a0:	80 a2 00 03 	cmp  %o0, %g3                                  
4000d3a4:	18 80 00 49 	bgu  4000d4c8 <_Heap_Free+0x164>               
4000d3a8:	01 00 00 00 	nop                                            
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000d3ac:	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;                
4000d3b0:	88 0b 7f fe 	and  %o5, -2, %g4                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d3b4:	84 02 00 04 	add  %o0, %g4, %g2                             
  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;             
4000d3b8:	80 a0 40 02 	cmp  %g1, %g2                                  
4000d3bc:	18 80 00 43 	bgu  4000d4c8 <_Heap_Free+0x164>               <== NEVER TAKEN
4000d3c0:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000d3c4:	0a 80 00 41 	bcs  4000d4c8 <_Heap_Free+0x164>               <== NEVER TAKEN
4000d3c8:	01 00 00 00 	nop                                            
4000d3cc:	d8 00 a0 04 	ld  [ %g2 + 4 ], %o4                           
    return false;                                                     
  }                                                                   
                                                                      
  _Heap_Protection_block_check( heap, next_block );                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
4000d3d0:	80 8b 20 01 	btst  1, %o4                                   
4000d3d4:	02 80 00 3d 	be  4000d4c8 <_Heap_Free+0x164>                <== NEVER TAKEN
4000d3d8:	96 0b 3f fe 	and  %o4, -2, %o3                              
    return true;                                                      
  }                                                                   
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000d3dc:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000d3e0:	02 80 00 06 	be  4000d3f8 <_Heap_Free+0x94>                 
4000d3e4:	98 10 20 00 	clr  %o4                                       
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000d3e8:	98 00 80 0b 	add  %g2, %o3, %o4                             
  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;                 
4000d3ec:	d8 03 20 04 	ld  [ %o4 + 4 ], %o4                           
4000d3f0:	98 0b 20 01 	and  %o4, 1, %o4                               
                                                                      
    return do_free;                                                   
  }                                                                   
#endif                                                                
                                                                      
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )          
4000d3f4:	98 1b 20 01 	xor  %o4, 1, %o4                               
                                                                      
  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 ));
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
4000d3f8:	80 8b 60 01 	btst  1, %o5                                   
4000d3fc:	12 80 00 1d 	bne  4000d470 <_Heap_Free+0x10c>               
4000d400:	80 8b 20 ff 	btst  0xff, %o4                                
    uintptr_t const prev_size = block->prev_size;                     
4000d404:	d4 02 00 00 	ld  [ %o0 ], %o2                               
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d408:	9a 22 00 0a 	sub  %o0, %o2, %o5                             
  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;             
4000d40c:	80 a0 40 0d 	cmp  %g1, %o5                                  
4000d410:	18 80 00 2e 	bgu  4000d4c8 <_Heap_Free+0x164>               <== NEVER TAKEN
4000d414:	b0 10 20 00 	clr  %i0                                       
4000d418:	80 a0 c0 0d 	cmp  %g3, %o5                                  
4000d41c:	0a 80 00 2b 	bcs  4000d4c8 <_Heap_Free+0x164>               <== NEVER TAKEN
4000d420:	01 00 00 00 	nop                                            
  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;                 
4000d424:	c2 03 60 04 	ld  [ %o5 + 4 ], %g1                           
      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) ) {                        
4000d428:	80 88 60 01 	btst  1, %g1                                   
4000d42c:	02 80 00 27 	be  4000d4c8 <_Heap_Free+0x164>                <== NEVER TAKEN
4000d430:	80 8b 20 ff 	btst  0xff, %o4                                
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
4000d434:	22 80 00 39 	be,a   4000d518 <_Heap_Free+0x1b4>             
4000d438:	94 01 00 0a 	add  %g4, %o2, %o2                             
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000d43c:	c2 00 a0 08 	ld  [ %g2 + 8 ], %g1                           
4000d440:	c4 00 a0 0c 	ld  [ %g2 + 0xc ], %g2                         
    }                                                                 
                                                                      
    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;                                        
4000d444:	c6 04 20 38 	ld  [ %l0 + 0x38 ], %g3                        
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
  Heap_Block *prev = block->prev;                                     
                                                                      
  prev->next = next;                                                  
4000d448:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
  next->prev = prev;                                                  
4000d44c:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
4000d450:	82 00 ff ff 	add  %g3, -1, %g1                              
4000d454:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
4000d458:	96 01 00 0b 	add  %g4, %o3, %o3                             
4000d45c:	94 02 c0 0a 	add  %o3, %o2, %o2                             
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
4000d460:	82 12 a0 01 	or  %o2, 1, %g1                                
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
4000d464:	d4 23 40 0a 	st  %o2, [ %o5 + %o2 ]                         
                                                                      
    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;        
4000d468:	10 80 00 0e 	b  4000d4a0 <_Heap_Free+0x13c>                 
4000d46c:	c2 23 60 04 	st  %g1, [ %o5 + 4 ]                           
      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;             
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
4000d470:	22 80 00 18 	be,a   4000d4d0 <_Heap_Free+0x16c>             
4000d474:	c6 04 20 08 	ld  [ %l0 + 8 ], %g3                           
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
4000d478:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
4000d47c:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1                         
)                                                                     
{                                                                     
  Heap_Block *next = old_block->next;                                 
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
4000d480:	c6 22 20 08 	st  %g3, [ %o0 + 8 ]                           
  new_block->prev = prev;                                             
4000d484:	c2 22 20 0c 	st  %g1, [ %o0 + 0xc ]                         
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
    uintptr_t const size = block_size + next_block_size;              
4000d488:	96 02 c0 04 	add  %o3, %g4, %o3                             
                                                                      
  next->prev = new_block;                                             
4000d48c:	d0 20 e0 0c 	st  %o0, [ %g3 + 0xc ]                         
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
4000d490:	84 12 e0 01 	or  %o3, 1, %g2                                
  prev->next = new_block;                                             
4000d494:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
4000d498:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
4000d49c:	d6 22 00 0b 	st  %o3, [ %o0 + %o3 ]                         
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000d4a0:	c4 04 20 40 	ld  [ %l0 + 0x40 ], %g2                        
  ++stats->frees;                                                     
4000d4a4:	c2 04 20 50 	ld  [ %l0 + 0x50 ], %g1                        
  stats->free_size += block_size;                                     
4000d4a8:	c6 04 20 30 	ld  [ %l0 + 0x30 ], %g3                        
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000d4ac:	84 00 bf ff 	add  %g2, -1, %g2                              
  ++stats->frees;                                                     
4000d4b0:	82 00 60 01 	inc  %g1                                       
  stats->free_size += block_size;                                     
4000d4b4:	88 00 c0 04 	add  %g3, %g4, %g4                             
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000d4b8:	c4 24 20 40 	st  %g2, [ %l0 + 0x40 ]                        
  ++stats->frees;                                                     
4000d4bc:	c2 24 20 50 	st  %g1, [ %l0 + 0x50 ]                        
  stats->free_size += block_size;                                     
4000d4c0:	c8 24 20 30 	st  %g4, [ %l0 + 0x30 ]                        
                                                                      
  return( true );                                                     
4000d4c4:	b0 10 20 01 	mov  1, %i0                                    
}                                                                     
4000d4c8:	81 c7 e0 08 	ret                                            
4000d4cc:	81 e8 00 00 	restore                                        
    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;         
4000d4d0:	82 11 20 01 	or  %g4, 1, %g1                                
4000d4d4:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
4000d4d8:	da 00 a0 04 	ld  [ %g2 + 4 ], %o5                           
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
4000d4dc:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
4000d4e0:	e0 22 20 0c 	st  %l0, [ %o0 + 0xc ]                         
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
4000d4e4:	c6 22 20 08 	st  %g3, [ %o0 + 8 ]                           
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
4000d4e8:	d0 20 e0 0c 	st  %o0, [ %g3 + 0xc ]                         
    /* 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;               
    next_block->prev_size = block_size;                               
4000d4ec:	c8 22 00 04 	st  %g4, [ %o0 + %g4 ]                         
  } 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;               
4000d4f0:	86 0b 7f fe 	and  %o5, -2, %g3                              
4000d4f4:	c6 20 a0 04 	st  %g3, [ %g2 + 4 ]                           
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000d4f8:	c4 04 20 3c 	ld  [ %l0 + 0x3c ], %g2                        
    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;                                             
4000d4fc:	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;                                     
4000d500:	d0 24 20 08 	st  %o0, [ %l0 + 8 ]                           
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000d504:	80 a0 40 02 	cmp  %g1, %g2                                  
4000d508:	08 bf ff e6 	bleu  4000d4a0 <_Heap_Free+0x13c>              
4000d50c:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
4000d510:	10 bf ff e4 	b  4000d4a0 <_Heap_Free+0x13c>                 
4000d514:	c2 24 20 3c 	st  %g1, [ %l0 + 0x3c ]                        
      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;        
4000d518:	82 12 a0 01 	or  %o2, 1, %g1                                
4000d51c:	c2 23 60 04 	st  %g1, [ %o5 + 4 ]                           
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
4000d520:	c2 00 a0 04 	ld  [ %g2 + 4 ], %g1                           
      next_block->prev_size = size;                                   
4000d524:	d4 22 00 04 	st  %o2, [ %o0 + %g4 ]                         
      _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;             
4000d528:	82 08 7f fe 	and  %g1, -2, %g1                              
4000d52c:	10 bf ff dd 	b  4000d4a0 <_Heap_Free+0x13c>                 
4000d530:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
                                                                      

4000e094 <_Heap_Get_information>: void _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) {
4000e094:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Block *the_block = the_heap->first_block;                      
4000e098:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
  Heap_Block *const end = the_heap->last_block;                       
4000e09c:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
                                                                      
  memset(the_info, 0, sizeof(*the_info));                             
4000e0a0:	c0 26 40 00 	clr  [ %i1 ]                                   
4000e0a4:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
4000e0a8:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
4000e0ac:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
4000e0b0:	c0 26 60 10 	clr  [ %i1 + 0x10 ]                            
                                                                      
  while ( the_block != end ) {                                        
4000e0b4:	80 a0 40 02 	cmp  %g1, %g2                                  
4000e0b8:	02 80 00 17 	be  4000e114 <_Heap_Get_information+0x80>      <== NEVER TAKEN
4000e0bc:	c0 26 60 14 	clr  [ %i1 + 0x14 ]                            
4000e0c0:	da 00 60 04 	ld  [ %g1 + 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;                
4000e0c4:	88 0b 7f fe 	and  %o5, -2, %g4                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000e0c8:	82 00 40 04 	add  %g1, %g4, %g1                             
    if ( info->largest < the_size )                                   
      info->largest = the_size;                                       
                                                                      
    the_block = next_block;                                           
  }                                                                   
}                                                                     
4000e0cc:	da 00 60 04 	ld  [ %g1 + 4 ], %o5                           
  while ( the_block != end ) {                                        
    uintptr_t const     the_size = _Heap_Block_size(the_block);       
    Heap_Block *const  next_block = _Heap_Block_at(the_block, the_size);
    Heap_Information  *info;                                          
                                                                      
    if ( _Heap_Is_prev_used(next_block) )                             
4000e0d0:	80 8b 60 01 	btst  1, %o5                                   
4000e0d4:	02 80 00 03 	be  4000e0e0 <_Heap_Get_information+0x4c>      
4000e0d8:	86 10 00 19 	mov  %i1, %g3                                  
      info = &the_info->Used;                                         
4000e0dc:	86 06 60 0c 	add  %i1, 0xc, %g3                             
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
4000e0e0:	d4 00 c0 00 	ld  [ %g3 ], %o2                               
    info->total += the_size;                                          
4000e0e4:	d6 00 e0 08 	ld  [ %g3 + 8 ], %o3                           
    if ( info->largest < the_size )                                   
4000e0e8:	d8 00 e0 04 	ld  [ %g3 + 4 ], %o4                           
    if ( _Heap_Is_prev_used(next_block) )                             
      info = &the_info->Used;                                         
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
4000e0ec:	94 02 a0 01 	inc  %o2                                       
    info->total += the_size;                                          
4000e0f0:	96 02 c0 04 	add  %o3, %g4, %o3                             
    if ( _Heap_Is_prev_used(next_block) )                             
      info = &the_info->Used;                                         
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
4000e0f4:	d4 20 c0 00 	st  %o2, [ %g3 ]                               
    info->total += the_size;                                          
    if ( info->largest < the_size )                                   
4000e0f8:	80 a3 00 04 	cmp  %o4, %g4                                  
4000e0fc:	1a 80 00 03 	bcc  4000e108 <_Heap_Get_information+0x74>     
4000e100:	d6 20 e0 08 	st  %o3, [ %g3 + 8 ]                           
      info->largest = the_size;                                       
4000e104:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
  Heap_Block *the_block = the_heap->first_block;                      
  Heap_Block *const end = the_heap->last_block;                       
                                                                      
  memset(the_info, 0, sizeof(*the_info));                             
                                                                      
  while ( the_block != end ) {                                        
4000e108:	80 a0 80 01 	cmp  %g2, %g1                                  
4000e10c:	12 bf ff ef 	bne  4000e0c8 <_Heap_Get_information+0x34>     
4000e110:	88 0b 7f fe 	and  %o5, -2, %g4                              
4000e114:	81 c7 e0 08 	ret                                            
4000e118:	81 e8 00 00 	restore                                        
                                                                      

400146e4 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) {
400146e4:	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);                                 
400146e8:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
400146ec:	7f ff f9 86 	call  40012d04 <.urem>                         
400146f0:	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           
400146f4:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
400146f8:	a0 10 00 18 	mov  %i0, %l0                                  
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
400146fc:	84 06 7f f8 	add  %i1, -8, %g2                              
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
40014700:	84 20 80 08 	sub  %g2, %o0, %g2                             
  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;             
40014704:	80 a0 80 01 	cmp  %g2, %g1                                  
40014708:	0a 80 00 15 	bcs  4001475c <_Heap_Size_of_alloc_area+0x78>  
4001470c:	b0 10 20 00 	clr  %i0                                       
40014710:	c6 04 20 24 	ld  [ %l0 + 0x24 ], %g3                        
40014714:	80 a0 80 03 	cmp  %g2, %g3                                  
40014718:	18 80 00 11 	bgu  4001475c <_Heap_Size_of_alloc_area+0x78>  <== NEVER TAKEN
4001471c:	01 00 00 00 	nop                                            
    - 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;                
40014720:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
40014724:	88 09 3f fe 	and  %g4, -2, %g4                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
40014728:	84 00 80 04 	add  %g2, %g4, %g2                             
  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;             
4001472c:	80 a0 40 02 	cmp  %g1, %g2                                  
40014730:	18 80 00 0b 	bgu  4001475c <_Heap_Size_of_alloc_area+0x78>  <== NEVER TAKEN
40014734:	80 a0 c0 02 	cmp  %g3, %g2                                  
40014738:	0a 80 00 09 	bcs  4001475c <_Heap_Size_of_alloc_area+0x78>  <== NEVER TAKEN
4001473c:	01 00 00 00 	nop                                            
  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;                 
40014740:	c2 00 a0 04 	ld  [ %g2 + 4 ], %g1                           
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if (                                                                
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
40014744:	80 88 60 01 	btst  1, %g1                                   
40014748:	02 80 00 05 	be  4001475c <_Heap_Size_of_alloc_area+0x78>   <== NEVER TAKEN
4001474c:	84 20 80 19 	sub  %g2, %i1, %g2                             
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
                                                                      
  return true;                                                        
40014750:	b0 10 20 01 	mov  1, %i0                                    
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
40014754:	84 00 a0 04 	add  %g2, 4, %g2                               
40014758:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  return true;                                                        
}                                                                     
4001475c:	81 c7 e0 08 	ret                                            
40014760:	81 e8 00 00 	restore                                        
                                                                      

400094c8 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) {
400094c8:	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;                      
400094cc:	23 10 00 25 	sethi  %hi(0x40009400), %l1                    
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
400094d0:	a0 10 00 18 	mov  %i0, %l0                                  
  uintptr_t const page_size = heap->page_size;                        
400094d4:	e8 06 20 10 	ld  [ %i0 + 0x10 ], %l4                        
  uintptr_t const min_block_size = heap->min_block_size;              
400094d8:	e6 06 20 14 	ld  [ %i0 + 0x14 ], %l3                        
  Heap_Block *const first_block = heap->first_block;                  
400094dc:	e4 06 20 20 	ld  [ %i0 + 0x20 ], %l2                        
  Heap_Block *const last_block = heap->last_block;                    
400094e0:	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;                      
400094e4:	80 8e a0 ff 	btst  0xff, %i2                                
400094e8:	02 80 00 04 	be  400094f8 <_Heap_Walk+0x30>                 
400094ec:	a2 14 60 5c 	or  %l1, 0x5c, %l1                             
400094f0:	23 10 00 25 	sethi  %hi(0x40009400), %l1                    
400094f4:	a2 14 60 64 	or  %l1, 0x64, %l1	! 40009464 <_Heap_Walk_print>
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
400094f8:	03 10 00 63 	sethi  %hi(0x40018c00), %g1                    
400094fc:	c2 00 61 88 	ld  [ %g1 + 0x188 ], %g1	! 40018d88 <_System_state_Current>
40009500:	80 a0 60 03 	cmp  %g1, 3                                    
40009504:	12 80 00 33 	bne  400095d0 <_Heap_Walk+0x108>               
40009508:	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)(                                                         
4000950c:	da 04 20 18 	ld  [ %l0 + 0x18 ], %o5                        
40009510:	c6 04 20 1c 	ld  [ %l0 + 0x1c ], %g3                        
40009514:	c4 04 20 08 	ld  [ %l0 + 8 ], %g2                           
40009518:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
4000951c:	90 10 00 19 	mov  %i1, %o0                                  
40009520:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
40009524:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
40009528:	ea 23 a0 64 	st  %l5, [ %sp + 0x64 ]                        
4000952c:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
40009530:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
40009534:	92 10 20 00 	clr  %o1                                       
40009538:	96 10 00 14 	mov  %l4, %o3                                  
4000953c:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009540:	98 10 00 13 	mov  %l3, %o4                                  
40009544:	9f c4 40 00 	call  %l1                                      
40009548:	94 12 a1 28 	or  %o2, 0x128, %o2                            
    heap->area_begin, heap->area_end,                                 
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
4000954c:	80 a5 20 00 	cmp  %l4, 0                                    
40009550:	02 80 00 2a 	be  400095f8 <_Heap_Walk+0x130>                
40009554:	80 8d 20 07 	btst  7, %l4                                   
    (*printer)( source, true, "page size is zero\n" );                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
40009558:	12 80 00 30 	bne  40009618 <_Heap_Walk+0x150>               
4000955c:	90 10 00 13 	mov  %l3, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40009560:	7f ff e1 61 	call  40001ae4 <.urem>                         
40009564:	92 10 00 14 	mov  %l4, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
40009568:	80 a2 20 00 	cmp  %o0, 0                                    
4000956c:	12 80 00 34 	bne  4000963c <_Heap_Walk+0x174>               
40009570:	90 04 a0 08 	add  %l2, 8, %o0                               
40009574:	7f ff e1 5c 	call  40001ae4 <.urem>                         
40009578:	92 10 00 14 	mov  %l4, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
4000957c:	80 a2 20 00 	cmp  %o0, 0                                    
40009580:	32 80 00 38 	bne,a   40009660 <_Heap_Walk+0x198>            
40009584:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40009588:	f8 04 a0 04 	ld  [ %l2 + 4 ], %i4                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
4000958c:	80 8f 20 01 	btst  1, %i4                                   
40009590:	22 80 00 4d 	be,a   400096c4 <_Heap_Walk+0x1fc>             
40009594:	90 10 00 19 	mov  %i1, %o0                                  
    - 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;                
40009598:	c2 05 60 04 	ld  [ %l5 + 4 ], %g1                           
4000959c:	82 08 7f fe 	and  %g1, -2, %g1                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
400095a0:	82 05 40 01 	add  %l5, %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;                 
400095a4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
400095a8:	80 88 a0 01 	btst  1, %g2                                   
400095ac:	02 80 00 0b 	be  400095d8 <_Heap_Walk+0x110>                
400095b0:	80 a4 80 01 	cmp  %l2, %g1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
400095b4:	02 80 00 33 	be  40009680 <_Heap_Walk+0x1b8>                
400095b8:	90 10 00 19 	mov  %i1, %o0                                  
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
400095bc:	92 10 20 01 	mov  1, %o1                                    
400095c0:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400095c4:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (                                                                
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
400095c8:	9f c4 40 00 	call  %l1                                      
400095cc:	94 12 a2 a0 	or  %o2, 0x2a0, %o2                            
400095d0:	81 c7 e0 08 	ret                                            
400095d4:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
    (*printer)(                                                       
400095d8:	90 10 00 19 	mov  %i1, %o0                                  
400095dc:	92 10 20 01 	mov  1, %o1                                    
400095e0:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400095e4:	b0 10 20 00 	clr  %i0                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
    (*printer)(                                                       
400095e8:	9f c4 40 00 	call  %l1                                      
400095ec:	94 12 a2 88 	or  %o2, 0x288, %o2                            
400095f0:	81 c7 e0 08 	ret                                            
400095f4:	81 e8 00 00 	restore                                        
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
    (*printer)( source, true, "page size is zero\n" );                
400095f8:	90 10 00 19 	mov  %i1, %o0                                  
400095fc:	92 10 20 01 	mov  1, %o1                                    
40009600:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009604:	b0 10 20 00 	clr  %i0                                       
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
    (*printer)( source, true, "page size is zero\n" );                
40009608:	9f c4 40 00 	call  %l1                                      
4000960c:	94 12 a1 c0 	or  %o2, 0x1c0, %o2                            
40009610:	81 c7 e0 08 	ret                                            
40009614:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
    (*printer)(                                                       
40009618:	90 10 00 19 	mov  %i1, %o0                                  
4000961c:	92 10 20 01 	mov  1, %o1                                    
40009620:	96 10 00 14 	mov  %l4, %o3                                  
40009624:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009628:	b0 10 20 00 	clr  %i0                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
    (*printer)(                                                       
4000962c:	9f c4 40 00 	call  %l1                                      
40009630:	94 12 a1 d8 	or  %o2, 0x1d8, %o2                            
40009634:	81 c7 e0 08 	ret                                            
40009638:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
    (*printer)(                                                       
4000963c:	90 10 00 19 	mov  %i1, %o0                                  
40009640:	92 10 20 01 	mov  1, %o1                                    
40009644:	96 10 00 13 	mov  %l3, %o3                                  
40009648:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000964c:	b0 10 20 00 	clr  %i0                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
    (*printer)(                                                       
40009650:	9f c4 40 00 	call  %l1                                      
40009654:	94 12 a1 f8 	or  %o2, 0x1f8, %o2                            
40009658:	81 c7 e0 08 	ret                                            
4000965c:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  if (                                                                
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
40009660:	92 10 20 01 	mov  1, %o1                                    
40009664:	96 10 00 12 	mov  %l2, %o3                                  
40009668:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000966c:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (                                                                
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
40009670:	9f c4 40 00 	call  %l1                                      
40009674:	94 12 a2 20 	or  %o2, 0x220, %o2                            
40009678:	81 c7 e0 08 	ret                                            
4000967c:	81 e8 00 00 	restore                                        
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40009680:	ee 04 20 08 	ld  [ %l0 + 8 ], %l7                           
  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 ) {                            
40009684:	80 a4 00 17 	cmp  %l0, %l7                                  
40009688:	02 80 01 18 	be  40009ae8 <_Heap_Walk+0x620>                
4000968c:	f6 04 20 10 	ld  [ %l0 + 0x10 ], %i3                        
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40009690:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %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;             
40009694:	80 a0 40 17 	cmp  %g1, %l7                                  
40009698:	08 80 00 12 	bleu  400096e0 <_Heap_Walk+0x218>              <== ALWAYS TAKEN
4000969c:	ac 10 00 17 	mov  %l7, %l6                                  
  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 ) ) {              
      (*printer)(                                                     
400096a0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
400096a4:	92 10 20 01 	mov  1, %o1                                    
400096a8:	96 10 00 16 	mov  %l6, %o3                                  
400096ac:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400096b0:	b0 10 20 00 	clr  %i0                                       
  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 ) ) {              
      (*printer)(                                                     
400096b4:	9f c4 40 00 	call  %l1                                      
400096b8:	94 12 a2 d0 	or  %o2, 0x2d0, %o2                            
400096bc:	81 c7 e0 08 	ret                                            
400096c0:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
    (*printer)(                                                       
400096c4:	92 10 20 01 	mov  1, %o1                                    
400096c8:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400096cc:	b0 10 20 00 	clr  %i0                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
    (*printer)(                                                       
400096d0:	9f c4 40 00 	call  %l1                                      
400096d4:	94 12 a2 58 	or  %o2, 0x258, %o2                            
400096d8:	81 c7 e0 08 	ret                                            
400096dc:	81 e8 00 00 	restore                                        
400096e0:	fa 04 20 24 	ld  [ %l0 + 0x24 ], %i5                        
400096e4:	80 a7 40 17 	cmp  %i5, %l7                                  
400096e8:	0a bf ff ef 	bcs  400096a4 <_Heap_Walk+0x1dc>               <== NEVER TAKEN
400096ec:	90 10 00 19 	mov  %i1, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
400096f0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
400096f4:	90 05 e0 08 	add  %l7, 8, %o0                               
400096f8:	7f ff e0 fb 	call  40001ae4 <.urem>                         
400096fc:	92 10 00 1b 	mov  %i3, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
40009700:	80 a2 20 00 	cmp  %o0, 0                                    
40009704:	12 80 00 2d 	bne  400097b8 <_Heap_Walk+0x2f0>               <== NEVER TAKEN
40009708:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    - 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;                
4000970c:	c4 05 e0 04 	ld  [ %l7 + 4 ], %g2                           
40009710:	84 08 bf fe 	and  %g2, -2, %g2                              
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40009714:	84 05 c0 02 	add  %l7, %g2, %g2                             
  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;                 
40009718:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
4000971c:	80 88 a0 01 	btst  1, %g2                                   
40009720:	12 80 00 2f 	bne  400097dc <_Heap_Walk+0x314>               <== NEVER TAKEN
40009724:	84 10 00 10 	mov  %l0, %g2                                  
40009728:	10 80 00 17 	b  40009784 <_Heap_Walk+0x2bc>                 
4000972c:	b4 10 00 01 	mov  %g1, %i2                                  
  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 ) {                            
40009730:	80 a4 00 16 	cmp  %l0, %l6                                  
40009734:	02 80 00 33 	be  40009800 <_Heap_Walk+0x338>                
40009738:	80 a6 80 16 	cmp  %i2, %l6                                  
  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;             
4000973c:	18 bf ff da 	bgu  400096a4 <_Heap_Walk+0x1dc>               
40009740:	90 10 00 19 	mov  %i1, %o0                                  
40009744:	80 a5 80 1d 	cmp  %l6, %i5                                  
40009748:	18 bf ff d8 	bgu  400096a8 <_Heap_Walk+0x1e0>               <== NEVER TAKEN
4000974c:	92 10 20 01 	mov  1, %o1                                    
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40009750:	90 05 a0 08 	add  %l6, 8, %o0                               
40009754:	7f ff e0 e4 	call  40001ae4 <.urem>                         
40009758:	92 10 00 1b 	mov  %i3, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
4000975c:	80 a2 20 00 	cmp  %o0, 0                                    
40009760:	12 80 00 16 	bne  400097b8 <_Heap_Walk+0x2f0>               
40009764:	84 10 00 17 	mov  %l7, %g2                                  
    - 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;                
40009768:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
4000976c:	82 08 7f fe 	and  %g1, -2, %g1                              
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40009770:	82 00 40 16 	add  %g1, %l6, %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;                 
40009774:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
40009778:	80 88 60 01 	btst  1, %g1                                   
4000977c:	12 80 00 18 	bne  400097dc <_Heap_Walk+0x314>               
40009780:	ae 10 00 16 	mov  %l6, %l7                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
40009784:	d8 05 e0 0c 	ld  [ %l7 + 0xc ], %o4                         
40009788:	80 a3 00 02 	cmp  %o4, %g2                                  
4000978c:	22 bf ff e9 	be,a   40009730 <_Heap_Walk+0x268>             
40009790:	ec 05 e0 08 	ld  [ %l7 + 8 ], %l6                           
      (*printer)(                                                     
40009794:	90 10 00 19 	mov  %i1, %o0                                  
40009798:	92 10 20 01 	mov  1, %o1                                    
4000979c:	96 10 00 17 	mov  %l7, %o3                                  
400097a0:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400097a4:	b0 10 20 00 	clr  %i0                                       
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
      (*printer)(                                                     
400097a8:	9f c4 40 00 	call  %l1                                      
400097ac:	94 12 a3 40 	or  %o2, 0x340, %o2                            
400097b0:	81 c7 e0 08 	ret                                            
400097b4:	81 e8 00 00 	restore                                        
    }                                                                 
                                                                      
    if (                                                              
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
400097b8:	90 10 00 19 	mov  %i1, %o0                                  
400097bc:	92 10 20 01 	mov  1, %o1                                    
400097c0:	96 10 00 16 	mov  %l6, %o3                                  
400097c4:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400097c8:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
                                                                      
    if (                                                              
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
400097cc:	9f c4 40 00 	call  %l1                                      
400097d0:	94 12 a2 f0 	or  %o2, 0x2f0, %o2                            
400097d4:	81 c7 e0 08 	ret                                            
400097d8:	81 e8 00 00 	restore                                        
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
      (*printer)(                                                     
400097dc:	90 10 00 19 	mov  %i1, %o0                                  
400097e0:	92 10 20 01 	mov  1, %o1                                    
400097e4:	96 10 00 16 	mov  %l6, %o3                                  
400097e8:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400097ec:	b0 10 20 00 	clr  %i0                                       
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
      (*printer)(                                                     
400097f0:	9f c4 40 00 	call  %l1                                      
400097f4:	94 12 a3 20 	or  %o2, 0x320, %o2                            
400097f8:	81 c7 e0 08 	ret                                            
400097fc:	81 e8 00 00 	restore                                        
40009800:	82 10 00 1a 	mov  %i2, %g1                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
40009804:	35 10 00 5a 	sethi  %hi(0x40016800), %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)(                                                     
40009808:	31 10 00 5a 	sethi  %hi(0x40016800), %i0                    
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
4000980c:	ae 10 00 12 	mov  %l2, %l7                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
40009810:	b4 16 a1 00 	or  %i2, 0x100, %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)(                                                     
40009814:	b0 16 20 e8 	or  %i0, 0xe8, %i0                             
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
40009818:	37 10 00 5a 	sethi  %hi(0x40016800), %i3                    
    - 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;                
4000981c:	ba 0f 3f fe 	and  %i4, -2, %i5                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
40009820:	ac 07 40 17 	add  %i5, %l7, %l6                             
  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;             
40009824:	80 a0 40 16 	cmp  %g1, %l6                                  
40009828:	28 80 00 0c 	bleu,a   40009858 <_Heap_Walk+0x390>           <== ALWAYS TAKEN
4000982c:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
    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 ) ) {              
      (*printer)(                                                     
40009830:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40009834:	92 10 20 01 	mov  1, %o1                                    
40009838:	96 10 00 17 	mov  %l7, %o3                                  
4000983c:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009840:	98 10 00 16 	mov  %l6, %o4                                  
40009844:	94 12 a3 78 	or  %o2, 0x378, %o2                            
40009848:	9f c4 40 00 	call  %l1                                      
4000984c:	b0 10 20 00 	clr  %i0                                       
        "block 0x%08x: next block 0x%08x not in heap\n",              
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
40009850:	81 c7 e0 08 	ret                                            
40009854:	81 e8 00 00 	restore                                        
40009858:	80 a0 40 16 	cmp  %g1, %l6                                  
4000985c:	0a bf ff f6 	bcs  40009834 <_Heap_Walk+0x36c>               
40009860:	90 10 00 19 	mov  %i1, %o0                                  
    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;               
40009864:	82 1d c0 15 	xor  %l7, %l5, %g1                             
40009868:	80 a0 00 01 	cmp  %g0, %g1                                  
4000986c:	82 40 20 00 	addx  %g0, 0, %g1                              
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40009870:	90 10 00 1d 	mov  %i5, %o0                                  
40009874:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
40009878:	7f ff e0 9b 	call  40001ae4 <.urem>                         
4000987c:	92 10 00 14 	mov  %l4, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40009880:	80 a2 20 00 	cmp  %o0, 0                                    
40009884:	02 80 00 05 	be  40009898 <_Heap_Walk+0x3d0>                
40009888:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000988c:	80 88 60 ff 	btst  0xff, %g1                                
40009890:	12 80 00 79 	bne  40009a74 <_Heap_Walk+0x5ac>               
40009894:	90 10 00 19 	mov  %i1, %o0                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
40009898:	80 a4 c0 1d 	cmp  %l3, %i5                                  
4000989c:	08 80 00 05 	bleu  400098b0 <_Heap_Walk+0x3e8>              
400098a0:	80 a5 c0 16 	cmp  %l7, %l6                                  
400098a4:	80 88 60 ff 	btst  0xff, %g1                                
400098a8:	12 80 00 7c 	bne  40009a98 <_Heap_Walk+0x5d0>               <== ALWAYS TAKEN
400098ac:	80 a5 c0 16 	cmp  %l7, %l6                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
400098b0:	2a 80 00 06 	bcs,a   400098c8 <_Heap_Walk+0x400>            
400098b4:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
400098b8:	80 88 60 ff 	btst  0xff, %g1                                
400098bc:	12 80 00 82 	bne  40009ac4 <_Heap_Walk+0x5fc>               
400098c0:	90 10 00 19 	mov  %i1, %o0                                  
  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;                 
400098c4:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
400098c8:	80 88 60 01 	btst  1, %g1                                   
400098cc:	02 80 00 19 	be  40009930 <_Heap_Walk+0x468>                
400098d0:	b8 0f 20 01 	and  %i4, 1, %i4                               
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
400098d4:	80 a7 20 00 	cmp  %i4, 0                                    
400098d8:	22 80 00 0e 	be,a   40009910 <_Heap_Walk+0x448>             
400098dc:	da 05 c0 00 	ld  [ %l7 ], %o5                               
      (*printer)(                                                     
400098e0:	90 10 00 19 	mov  %i1, %o0                                  
400098e4:	92 10 20 00 	clr  %o1                                       
400098e8:	94 10 00 18 	mov  %i0, %o2                                  
400098ec:	96 10 00 17 	mov  %l7, %o3                                  
400098f0:	9f c4 40 00 	call  %l1                                      
400098f4:	98 10 00 1d 	mov  %i5, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
400098f8:	80 a4 80 16 	cmp  %l2, %l6                                  
400098fc:	02 80 00 43 	be  40009a08 <_Heap_Walk+0x540>                
40009900:	ae 10 00 16 	mov  %l6, %l7                                  
40009904:	f8 05 a0 04 	ld  [ %l6 + 4 ], %i4                           
40009908:	10 bf ff c5 	b  4000981c <_Heap_Walk+0x354>                 
4000990c:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %g1                        
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
40009910:	96 10 00 17 	mov  %l7, %o3                                  
40009914:	90 10 00 19 	mov  %i1, %o0                                  
40009918:	92 10 20 00 	clr  %o1                                       
4000991c:	94 10 00 1a 	mov  %i2, %o2                                  
40009920:	9f c4 40 00 	call  %l1                                      
40009924:	98 10 00 1d 	mov  %i5, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
40009928:	10 bf ff f5 	b  400098fc <_Heap_Walk+0x434>                 
4000992c:	80 a4 80 16 	cmp  %l2, %l6                                  
    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 ?                                 
40009930:	da 05 e0 0c 	ld  [ %l7 + 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)(                                                         
40009934:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
40009938:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
4000993c:	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)(                                                         
40009940:	80 a0 40 0d 	cmp  %g1, %o5                                  
40009944:	02 80 00 05 	be  40009958 <_Heap_Walk+0x490>                
40009948:	86 10 a0 e8 	or  %g2, 0xe8, %g3                             
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
4000994c:	80 a4 00 0d 	cmp  %l0, %o5                                  
40009950:	02 80 00 3e 	be  40009a48 <_Heap_Walk+0x580>                
40009954:	86 16 e0 b0 	or  %i3, 0xb0, %g3                             
    block->next,                                                      
    block->next == last_free_block ?                                  
40009958:	c2 05 e0 08 	ld  [ %l7 + 8 ], %g1                           
  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)(                                                         
4000995c:	19 10 00 59 	sethi  %hi(0x40016400), %o4                    
40009960:	80 a1 00 01 	cmp  %g4, %g1                                  
40009964:	02 80 00 05 	be  40009978 <_Heap_Walk+0x4b0>                
40009968:	84 13 21 08 	or  %o4, 0x108, %g2                            
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
4000996c:	80 a4 00 01 	cmp  %l0, %g1                                  
40009970:	02 80 00 33 	be  40009a3c <_Heap_Walk+0x574>                
40009974:	84 16 e0 b0 	or  %i3, 0xb0, %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)(                                                         
40009978:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
4000997c:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
40009980:	c4 23 a0 64 	st  %g2, [ %sp + 0x64 ]                        
40009984:	90 10 00 19 	mov  %i1, %o0                                  
40009988:	92 10 20 00 	clr  %o1                                       
4000998c:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009990:	96 10 00 17 	mov  %l7, %o3                                  
40009994:	94 12 a0 40 	or  %o2, 0x40, %o2                             
40009998:	9f c4 40 00 	call  %l1                                      
4000999c:	98 10 00 1d 	mov  %i5, %o4                                  
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
400099a0:	da 05 80 00 	ld  [ %l6 ], %o5                               
400099a4:	80 a7 40 0d 	cmp  %i5, %o5                                  
400099a8:	12 80 00 1a 	bne  40009a10 <_Heap_Walk+0x548>               
400099ac:	80 a7 20 00 	cmp  %i4, 0                                    
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
400099b0:	02 80 00 29 	be  40009a54 <_Heap_Walk+0x58c>                
400099b4:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
400099b8:	c2 04 20 08 	ld  [ %l0 + 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 ) {                            
400099bc:	80 a4 00 01 	cmp  %l0, %g1                                  
400099c0:	02 80 00 0b 	be  400099ec <_Heap_Walk+0x524>                <== NEVER TAKEN
400099c4:	92 10 20 01 	mov  1, %o1                                    
    if ( free_block == block ) {                                      
400099c8:	80 a5 c0 01 	cmp  %l7, %g1                                  
400099cc:	02 bf ff cc 	be  400098fc <_Heap_Walk+0x434>                
400099d0:	80 a4 80 16 	cmp  %l2, %l6                                  
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
400099d4:	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 ) {                            
400099d8:	80 a4 00 01 	cmp  %l0, %g1                                  
400099dc:	12 bf ff fc 	bne  400099cc <_Heap_Walk+0x504>               
400099e0:	80 a5 c0 01 	cmp  %l7, %g1                                  
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
400099e4:	90 10 00 19 	mov  %i1, %o0                                  
400099e8:	92 10 20 01 	mov  1, %o1                                    
400099ec:	96 10 00 17 	mov  %l7, %o3                                  
400099f0:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
400099f4:	b0 10 20 00 	clr  %i0                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
400099f8:	9f c4 40 00 	call  %l1                                      
400099fc:	94 12 a1 28 	or  %o2, 0x128, %o2                            
40009a00:	81 c7 e0 08 	ret                                            
40009a04:	81 e8 00 00 	restore                                        
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
40009a08:	81 c7 e0 08 	ret                                            
40009a0c:	91 e8 20 01 	restore  %g0, 1, %o0                           
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
    (*printer)(                                                       
40009a10:	ec 23 a0 5c 	st  %l6, [ %sp + 0x5c ]                        
40009a14:	90 10 00 19 	mov  %i1, %o0                                  
40009a18:	92 10 20 01 	mov  1, %o1                                    
40009a1c:	96 10 00 17 	mov  %l7, %o3                                  
40009a20:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009a24:	98 10 00 1d 	mov  %i5, %o4                                  
40009a28:	94 12 a0 78 	or  %o2, 0x78, %o2                             
40009a2c:	9f c4 40 00 	call  %l1                                      
40009a30:	b0 10 20 00 	clr  %i0                                       
40009a34:	81 c7 e0 08 	ret                                            
40009a38:	81 e8 00 00 	restore                                        
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
40009a3c:	09 10 00 59 	sethi  %hi(0x40016400), %g4                    
40009a40:	10 bf ff ce 	b  40009978 <_Heap_Walk+0x4b0>                 
40009a44:	84 11 21 18 	or  %g4, 0x118, %g2	! 40016518 <_Status_Object_name_errors_to_status+0x68>
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
40009a48:	19 10 00 59 	sethi  %hi(0x40016400), %o4                    
40009a4c:	10 bf ff c3 	b  40009958 <_Heap_Walk+0x490>                 
40009a50:	86 13 20 f8 	or  %o4, 0xf8, %g3	! 400164f8 <_Status_Object_name_errors_to_status+0x48>
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
    (*printer)(                                                       
40009a54:	92 10 20 01 	mov  1, %o1                                    
40009a58:	96 10 00 17 	mov  %l7, %o3                                  
40009a5c:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
40009a60:	b0 10 20 00 	clr  %i0                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
    (*printer)(                                                       
40009a64:	9f c4 40 00 	call  %l1                                      
40009a68:	94 12 a0 b8 	or  %o2, 0xb8, %o2                             
40009a6c:	81 c7 e0 08 	ret                                            
40009a70:	81 e8 00 00 	restore                                        
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
      (*printer)(                                                     
40009a74:	92 10 20 01 	mov  1, %o1                                    
40009a78:	96 10 00 17 	mov  %l7, %o3                                  
40009a7c:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009a80:	98 10 00 1d 	mov  %i5, %o4                                  
40009a84:	94 12 a3 a8 	or  %o2, 0x3a8, %o2                            
40009a88:	9f c4 40 00 	call  %l1                                      
40009a8c:	b0 10 20 00 	clr  %i0                                       
        "block 0x%08x: block size %u not page aligned\n",             
        block,                                                        
        block_size                                                    
      );                                                              
                                                                      
      return false;                                                   
40009a90:	81 c7 e0 08 	ret                                            
40009a94:	81 e8 00 00 	restore                                        
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
      (*printer)(                                                     
40009a98:	90 10 00 19 	mov  %i1, %o0                                  
40009a9c:	92 10 20 01 	mov  1, %o1                                    
40009aa0:	96 10 00 17 	mov  %l7, %o3                                  
40009aa4:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009aa8:	98 10 00 1d 	mov  %i5, %o4                                  
40009aac:	94 12 a3 d8 	or  %o2, 0x3d8, %o2                            
40009ab0:	9a 10 00 13 	mov  %l3, %o5                                  
40009ab4:	9f c4 40 00 	call  %l1                                      
40009ab8:	b0 10 20 00 	clr  %i0                                       
        block,                                                        
        block_size,                                                   
        min_block_size                                                
      );                                                              
                                                                      
      return false;                                                   
40009abc:	81 c7 e0 08 	ret                                            
40009ac0:	81 e8 00 00 	restore                                        
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
      (*printer)(                                                     
40009ac4:	92 10 20 01 	mov  1, %o1                                    
40009ac8:	96 10 00 17 	mov  %l7, %o3                                  
40009acc:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009ad0:	98 10 00 16 	mov  %l6, %o4                                  
40009ad4:	94 12 a0 08 	or  %o2, 8, %o2                                
40009ad8:	9f c4 40 00 	call  %l1                                      
40009adc:	b0 10 20 00 	clr  %i0                                       
        "block 0x%08x: next block 0x%08x is not a successor\n",       
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
40009ae0:	81 c7 e0 08 	ret                                            
40009ae4:	81 e8 00 00 	restore                                        
  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 ) {                            
40009ae8:	10 bf ff 47 	b  40009804 <_Heap_Walk+0x33c>                 
40009aec:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %g1                        
                                                                      

4000797c <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) {
4000797c:	9d e3 bf a0 	save  %sp, -96, %sp                            
   rtems_device_major_number major;                                   
                                                                      
   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )         
40007980:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
40007984:	c2 04 62 c4 	ld  [ %l1 + 0x2c4 ], %g1	! 400166c4 <_IO_Number_of_drivers>
40007988:	80 a0 60 00 	cmp  %g1, 0                                    
4000798c:	02 80 00 0c 	be  400079bc <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
40007990:	a0 10 20 00 	clr  %l0                                       
40007994:	a2 14 62 c4 	or  %l1, 0x2c4, %l1                            
     (void) rtems_io_initialize( major, 0, NULL );                    
40007998:	90 10 00 10 	mov  %l0, %o0                                  
4000799c:	92 10 20 00 	clr  %o1                                       
400079a0:	40 00 15 49 	call  4000cec4 <rtems_io_initialize>           
400079a4:	94 10 20 00 	clr  %o2                                       
                                                                      
void _IO_Initialize_all_drivers( void )                               
{                                                                     
   rtems_device_major_number major;                                   
                                                                      
   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )         
400079a8:	c2 04 40 00 	ld  [ %l1 ], %g1                               
400079ac:	a0 04 20 01 	inc  %l0                                       
400079b0:	80 a0 40 10 	cmp  %g1, %l0                                  
400079b4:	18 bf ff fa 	bgu  4000799c <_IO_Initialize_all_drivers+0x20>
400079b8:	90 10 00 10 	mov  %l0, %o0                                  
400079bc:	81 c7 e0 08 	ret                                            
400079c0:	81 e8 00 00 	restore                                        
                                                                      

400078b0 <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) {
400078b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t                    index;                                  
  rtems_driver_address_table *driver_table;                           
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = Configuration.Device_driver_table;              
400078b4:	03 10 00 56 	sethi  %hi(0x40015800), %g1                    
400078b8:	82 10 61 98 	or  %g1, 0x198, %g1	! 40015998 <Configuration> 
  drivers_in_table  = Configuration.number_of_device_drivers;         
400078bc:	e2 00 60 30 	ld  [ %g1 + 0x30 ], %l1                        
  number_of_drivers = Configuration.maximum_drivers;                  
400078c0:	e8 00 60 2c 	ld  [ %g1 + 0x2c ], %l4                        
                                                                      
  /*                                                                  
   *  If the user claims there are less drivers than are actually in  
   *  the table, then let's just go with the table's count.           
   */                                                                 
  if ( number_of_drivers <= drivers_in_table )                        
400078c4:	80 a4 40 14 	cmp  %l1, %l4                                  
400078c8:	0a 80 00 08 	bcs  400078e8 <_IO_Manager_initialization+0x38>
400078cc:	e0 00 60 34 	ld  [ %g1 + 0x34 ], %l0                        
   *  If the maximum number of driver is the same as the number in the
   *  table, then we do not have to copy the driver table.  They can't
   *  register any dynamically.                                       
   */                                                                 
  if ( number_of_drivers == drivers_in_table ) {                      
    _IO_Driver_address_table = driver_table;                          
400078d0:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400078d4:	e0 20 62 c8 	st  %l0, [ %g1 + 0x2c8 ]	! 400166c8 <_IO_Driver_address_table>
    _IO_Number_of_drivers = number_of_drivers;                        
400078d8:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400078dc:	e2 20 62 c4 	st  %l1, [ %g1 + 0x2c4 ]	! 400166c4 <_IO_Number_of_drivers>
    return;                                                           
400078e0:	81 c7 e0 08 	ret                                            
400078e4:	81 e8 00 00 	restore                                        
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
400078e8:	83 2d 20 03 	sll  %l4, 3, %g1                               
400078ec:	a7 2d 20 05 	sll  %l4, 5, %l3                               
400078f0:	a6 24 c0 01 	sub  %l3, %g1, %l3                             
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
      _Workspace_Allocate_or_fatal_error(                             
400078f4:	40 00 0d 08 	call  4000ad14 <_Workspace_Allocate_or_fatal_error>
400078f8:	90 10 00 13 	mov  %l3, %o0                                  
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
400078fc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
  /*                                                                  
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
40007900:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
40007904:	e8 20 62 c4 	st  %l4, [ %g1 + 0x2c4 ]                       
  /*                                                                  
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
40007908:	d0 24 a2 c8 	st  %o0, [ %l2 + 0x2c8 ]                       
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
                                                                      
  memset(                                                             
4000790c:	92 10 20 00 	clr  %o1                                       
40007910:	40 00 20 98 	call  4000fb70 <memset>                        
40007914:	94 10 00 13 	mov  %l3, %o2                                  
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007918:	80 a4 60 00 	cmp  %l1, 0                                    
4000791c:	02 bf ff f1 	be  400078e0 <_IO_Manager_initialization+0x30> <== NEVER TAKEN
40007920:	da 04 a2 c8 	ld  [ %l2 + 0x2c8 ], %o5                       
40007924:	82 10 20 00 	clr  %g1                                       
40007928:	88 10 20 00 	clr  %g4                                       
    _IO_Driver_address_table[index] = driver_table[index];            
4000792c:	c4 04 00 01 	ld  [ %l0 + %g1 ], %g2                         
40007930:	86 04 00 01 	add  %l0, %g1, %g3                             
40007934:	c4 23 40 01 	st  %g2, [ %o5 + %g1 ]                         
40007938:	d8 00 e0 04 	ld  [ %g3 + 4 ], %o4                           
4000793c:	84 03 40 01 	add  %o5, %g1, %g2                             
40007940:	d8 20 a0 04 	st  %o4, [ %g2 + 4 ]                           
40007944:	d8 00 e0 08 	ld  [ %g3 + 8 ], %o4                           
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007948:	88 01 20 01 	inc  %g4                                       
    _IO_Driver_address_table[index] = driver_table[index];            
4000794c:	d8 20 a0 08 	st  %o4, [ %g2 + 8 ]                           
40007950:	d8 00 e0 0c 	ld  [ %g3 + 0xc ], %o4                         
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007954:	82 00 60 18 	add  %g1, 0x18, %g1                            
    _IO_Driver_address_table[index] = driver_table[index];            
40007958:	d8 20 a0 0c 	st  %o4, [ %g2 + 0xc ]                         
4000795c:	d8 00 e0 10 	ld  [ %g3 + 0x10 ], %o4                        
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007960:	80 a4 40 04 	cmp  %l1, %g4                                  
    _IO_Driver_address_table[index] = driver_table[index];            
40007964:	d8 20 a0 10 	st  %o4, [ %g2 + 0x10 ]                        
40007968:	c6 00 e0 14 	ld  [ %g3 + 0x14 ], %g3                        
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
4000796c:	18 bf ff f0 	bgu  4000792c <_IO_Manager_initialization+0x7c>
40007970:	c6 20 a0 14 	st  %g3, [ %g2 + 0x14 ]                        
40007974:	81 c7 e0 08 	ret                                            
40007978:	81 e8 00 00 	restore                                        
                                                                      

400085f4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) {
400085f4:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
400085f8:	1b 10 00 59 	sethi  %hi(0x40016400), %o5                    
400085fc:	86 13 60 94 	or  %o5, 0x94, %g3	! 40016494 <_Internal_errors_What_happened>
  _Internal_errors_What_happened.is_internal = is_internal;           
  _Internal_errors_What_happened.the_error   = the_error;             
                                                                      
  _User_extensions_Fatal( the_source, is_internal, the_error );       
40008600:	90 10 00 18 	mov  %i0, %o0                                  
40008604:	92 0e 60 ff 	and  %i1, 0xff, %o1                            
40008608:	94 10 00 1a 	mov  %i2, %o2                                  
  bool                    is_internal,                                
  Internal_errors_t       the_error                                   
)                                                                     
{                                                                     
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
4000860c:	f0 23 60 94 	st  %i0, [ %o5 + 0x94 ]                        
  _Internal_errors_What_happened.is_internal = is_internal;           
40008610:	f2 28 e0 04 	stb  %i1, [ %g3 + 4 ]                          
  _Internal_errors_What_happened.the_error   = the_error;             
                                                                      
  _User_extensions_Fatal( the_source, is_internal, the_error );       
40008614:	40 00 08 5e 	call  4000a78c <_User_extensions_Fatal>        
40008618:	f4 20 e0 08 	st  %i2, [ %g3 + 8 ]                           
                                                                      
RTEMS_INLINE_ROUTINE void _System_state_Set (                         
  System_state_Codes state                                            
)                                                                     
{                                                                     
  _System_state_Current = state;                                      
4000861c:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
40008620:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    <== NOT EXECUTED
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
40008624:	7f ff e6 0b 	call  40001e50 <sparc_disable_interrupts>      <== NOT EXECUTED
40008628:	c4 20 61 58 	st  %g2, [ %g1 + 0x158 ]	! 40016558 <_System_state_Current><== NOT EXECUTED
4000862c:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
40008630:	30 80 00 00 	b,a   40008630 <_Internal_error_Occurred+0x3c> <== NOT EXECUTED
                                                                      

400086a8 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) {
400086a8:	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 )                                       
400086ac:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 */                                                                   
                                                                      
Objects_Control *_Objects_Allocate(                                   
  Objects_Information *information                                    
)                                                                     
{                                                                     
400086b0:	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 )                                       
400086b4:	80 a0 60 00 	cmp  %g1, 0                                    
400086b8:	02 80 00 19 	be  4000871c <_Objects_Allocate+0x74>          <== NEVER TAKEN
400086bc:	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 );
400086c0:	a2 04 20 20 	add  %l0, 0x20, %l1                            
400086c4:	7f ff fd 5c 	call  40007c34 <_Chain_Get>                    
400086c8:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
  if ( information->auto_extend ) {                                   
400086cc:	c2 0c 20 12 	ldub  [ %l0 + 0x12 ], %g1                      
400086d0:	80 a0 60 00 	cmp  %g1, 0                                    
400086d4:	02 80 00 12 	be  4000871c <_Objects_Allocate+0x74>          
400086d8:	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 ) {                                              
400086dc:	80 a2 20 00 	cmp  %o0, 0                                    
400086e0:	02 80 00 11 	be  40008724 <_Objects_Allocate+0x7c>          
400086e4:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    if ( the_object ) {                                               
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
400086e8:	c2 14 20 0a 	lduh  [ %l0 + 0xa ], %g1                       
400086ec:	d0 16 20 0a 	lduh  [ %i0 + 0xa ], %o0                       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
400086f0:	d2 14 20 14 	lduh  [ %l0 + 0x14 ], %o1                      
400086f4:	40 00 28 d8 	call  40012a54 <.udiv>                         
400086f8:	90 22 00 01 	sub  %o0, %g1, %o0                             
                                                                      
      information->inactive_per_block[ block ]--;                     
400086fc:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
40008700:	91 2a 20 02 	sll  %o0, 2, %o0                               
40008704:	c6 00 40 08 	ld  [ %g1 + %o0 ], %g3                         
      information->inactive--;                                        
40008708:	c4 14 20 2c 	lduh  [ %l0 + 0x2c ], %g2                      
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
                                                                      
      information->inactive_per_block[ block ]--;                     
4000870c:	86 00 ff ff 	add  %g3, -1, %g3                              
40008710:	c6 20 40 08 	st  %g3, [ %g1 + %o0 ]                         
      information->inactive--;                                        
40008714:	82 00 bf ff 	add  %g2, -1, %g1                              
40008718:	c2 34 20 2c 	sth  %g1, [ %l0 + 0x2c ]                       
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
4000871c:	81 c7 e0 08 	ret                                            
40008720:	81 e8 00 00 	restore                                        
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
      _Objects_Extend_information( information );                     
40008724:	40 00 00 11 	call  40008768 <_Objects_Extend_information>   
40008728:	90 10 00 10 	mov  %l0, %o0                                  
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
4000872c:	7f ff fd 42 	call  40007c34 <_Chain_Get>                    
40008730:	90 10 00 11 	mov  %l1, %o0                                  
    }                                                                 
                                                                      
    if ( the_object ) {                                               
40008734:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40008738:	32 bf ff ed 	bne,a   400086ec <_Objects_Allocate+0x44>      
4000873c:	c2 14 20 0a 	lduh  [ %l0 + 0xa ], %g1                       
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
40008740:	81 c7 e0 08 	ret                                            
40008744:	81 e8 00 00 	restore                                        
                                                                      

40008768 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) {
40008768:	9d e3 bf 90 	save  %sp, -112, %sp                           
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
4000876c:	e8 06 20 34 	ld  [ %i0 + 0x34 ], %l4                        
40008770:	80 a5 20 00 	cmp  %l4, 0                                    
40008774:	02 80 00 a6 	be  40008a0c <_Objects_Extend_information+0x2a4>
40008778:	e4 16 20 0a 	lduh  [ %i0 + 0xa ], %l2                       
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
4000877c:	ea 16 20 10 	lduh  [ %i0 + 0x10 ], %l5                      
40008780:	e6 16 20 14 	lduh  [ %i0 + 0x14 ], %l3                      
40008784:	ab 2d 60 10 	sll  %l5, 0x10, %l5                            
40008788:	92 10 00 13 	mov  %l3, %o1                                  
4000878c:	40 00 28 b2 	call  40012a54 <.udiv>                         
40008790:	91 35 60 10 	srl  %l5, 0x10, %o0                            
40008794:	bb 2a 20 10 	sll  %o0, 0x10, %i5                            
40008798:	bb 37 60 10 	srl  %i5, 0x10, %i5                            
                                                                      
    for ( ; block < block_count; block++ ) {                          
4000879c:	80 a7 60 00 	cmp  %i5, 0                                    
400087a0:	02 80 00 a3 	be  40008a2c <_Objects_Extend_information+0x2c4><== NEVER TAKEN
400087a4:	90 10 00 13 	mov  %l3, %o0                                  
      if ( information->object_blocks[ block ] == NULL ) {            
400087a8:	c2 05 00 00 	ld  [ %l4 ], %g1                               
400087ac:	80 a0 60 00 	cmp  %g1, 0                                    
400087b0:	02 80 00 a3 	be  40008a3c <_Objects_Extend_information+0x2d4><== NEVER TAKEN
400087b4:	a2 10 00 12 	mov  %l2, %l1                                  
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
400087b8:	10 80 00 06 	b  400087d0 <_Objects_Extend_information+0x68> 
400087bc:	a0 10 20 00 	clr  %l0                                       
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL ) {            
400087c0:	c2 05 00 01 	ld  [ %l4 + %g1 ], %g1                         
400087c4:	80 a0 60 00 	cmp  %g1, 0                                    
400087c8:	22 80 00 08 	be,a   400087e8 <_Objects_Extend_information+0x80>
400087cc:	a8 10 20 00 	clr  %l4                                       
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
400087d0:	a0 04 20 01 	inc  %l0                                       
      if ( information->object_blocks[ block ] == NULL ) {            
        do_extend = false;                                            
        break;                                                        
      } else                                                          
        index_base += information->allocation_size;                   
400087d4:	a2 04 40 13 	add  %l1, %l3, %l1                             
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
400087d8:	80 a7 40 10 	cmp  %i5, %l0                                  
400087dc:	18 bf ff f9 	bgu  400087c0 <_Objects_Extend_information+0x58>
400087e0:	83 2c 20 02 	sll  %l0, 2, %g1                               
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
400087e4:	a8 10 20 01 	mov  1, %l4                                    
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
400087e8:	ab 35 60 10 	srl  %l5, 0x10, %l5                            
  /*                                                                  
   *  We need to limit the number of objects to the maximum number    
   *  representable in the index portion of the object Id.  In the    
   *  case of 16-bit Ids, this is only 256 object instances.          
   */                                                                 
  if ( maximum > OBJECTS_ID_FINAL_INDEX ) {                           
400087ec:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
400087f0:	aa 05 40 08 	add  %l5, %o0, %l5                             
  /*                                                                  
   *  We need to limit the number of objects to the maximum number    
   *  representable in the index portion of the object Id.  In the    
   *  case of 16-bit Ids, this is only 256 object instances.          
   */                                                                 
  if ( maximum > OBJECTS_ID_FINAL_INDEX ) {                           
400087f4:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
400087f8:	80 a5 40 01 	cmp  %l5, %g1                                  
400087fc:	18 80 00 95 	bgu  40008a50 <_Objects_Extend_information+0x2e8>
40008800:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
40008804:	40 00 28 5a 	call  4001296c <.umul>                         
40008808:	d2 06 20 18 	ld  [ %i0 + 0x18 ], %o1                        
  if ( information->auto_extend ) {                                   
4000880c:	c2 0e 20 12 	ldub  [ %i0 + 0x12 ], %g1                      
40008810:	80 a0 60 00 	cmp  %g1, 0                                    
40008814:	02 80 00 6a 	be  400089bc <_Objects_Extend_information+0x254>
40008818:	01 00 00 00 	nop                                            
    new_object_block = _Workspace_Allocate( block_size );             
4000881c:	40 00 09 2e 	call  4000acd4 <_Workspace_Allocate>           
40008820:	01 00 00 00 	nop                                            
    if ( !new_object_block )                                          
40008824:	a6 92 20 00 	orcc  %o0, 0, %l3                              
40008828:	02 80 00 8a 	be  40008a50 <_Objects_Extend_information+0x2e8>
4000882c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Do we need to grow the tables?                                  
   */                                                                 
  if ( do_extend ) {                                                  
40008830:	80 8d 20 ff 	btst  0xff, %l4                                
40008834:	22 80 00 3f 	be,a   40008930 <_Objects_Extend_information+0x1c8>
40008838:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
     */                                                               
                                                                      
    /*                                                                
     *  Up the block count and maximum                                
     */                                                               
    block_count++;                                                    
4000883c:	a8 07 60 01 	add  %i5, 1, %l4                               
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
40008840:	91 2d 20 01 	sll  %l4, 1, %o0                               
40008844:	90 02 00 14 	add  %o0, %l4, %o0                             
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
40008848:	90 05 40 08 	add  %l5, %o0, %o0                             
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
4000884c:	90 02 00 12 	add  %o0, %l2, %o0                             
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    object_blocks = (void**) _Workspace_Allocate( block_size );       
40008850:	40 00 09 21 	call  4000acd4 <_Workspace_Allocate>           
40008854:	91 2a 20 02 	sll  %o0, 2, %o0                               
                                                                      
    if ( !object_blocks ) {                                           
40008858:	ac 92 20 00 	orcc  %o0, 0, %l6                              
4000885c:	02 80 00 7b 	be  40008a48 <_Objects_Extend_information+0x2e0>
40008860:	a9 2d 20 02 	sll  %l4, 2, %l4                               
     *  Take the block count down. Saves all the (block_count - 1)    
     *  in the copies.                                                
     */                                                               
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
40008864:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
40008868:	80 a4 80 01 	cmp  %l2, %g1                                  
4000886c:	ae 05 80 14 	add  %l6, %l4, %l7                             
40008870:	0a 80 00 57 	bcs  400089cc <_Objects_Extend_information+0x264>
40008874:	a8 05 c0 14 	add  %l7, %l4, %l4                             
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
40008878:	80 a4 a0 00 	cmp  %l2, 0                                    
4000887c:	02 80 00 07 	be  40008898 <_Objects_Extend_information+0x130><== NEVER TAKEN
40008880:	82 10 20 00 	clr  %g1                                       
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
40008884:	85 28 60 02 	sll  %g1, 2, %g2                               
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
40008888:	82 00 60 01 	inc  %g1                                       
4000888c:	80 a4 80 01 	cmp  %l2, %g1                                  
40008890:	18 bf ff fd 	bgu  40008884 <_Objects_Extend_information+0x11c><== NEVER TAKEN
40008894:	c0 20 80 14 	clr  [ %g2 + %l4 ]                             
40008898:	bb 2f 60 02 	sll  %i5, 2, %i5                               
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
4000889c:	c6 16 20 14 	lduh  [ %i0 + 0x14 ], %g3                      
    }                                                                 
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
400088a0:	c0 25 80 1d 	clr  [ %l6 + %i5 ]                             
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
400088a4:	86 04 40 03 	add  %l1, %g3, %g3                             
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
400088a8:	80 a4 40 03 	cmp  %l1, %g3                                  
400088ac:	1a 80 00 0a 	bcc  400088d4 <_Objects_Extend_information+0x16c><== NEVER TAKEN
400088b0:	c0 25 c0 1d 	clr  [ %l7 + %i5 ]                             
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
400088b4:	83 2c 60 02 	sll  %l1, 2, %g1                               
400088b8:	84 10 00 11 	mov  %l1, %g2                                  
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
400088bc:	82 05 00 01 	add  %l4, %g1, %g1                             
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
400088c0:	c0 20 40 00 	clr  [ %g1 ]                                   
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
400088c4:	84 00 a0 01 	inc  %g2                                       
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
400088c8:	80 a0 80 03 	cmp  %g2, %g3                                  
400088cc:	0a bf ff fd 	bcs  400088c0 <_Objects_Extend_information+0x158>
400088d0:	82 00 60 04 	add  %g1, 4, %g1                               
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
400088d4:	7f ff e5 5f 	call  40001e50 <sparc_disable_interrupts>      
400088d8:	01 00 00 00 	nop                                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
400088dc:	c6 06 00 00 	ld  [ %i0 ], %g3                               
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
400088e0:	c4 16 20 04 	lduh  [ %i0 + 4 ], %g2                         
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
400088e4:	e4 06 20 34 	ld  [ %i0 + 0x34 ], %l2                        
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
400088e8:	ea 36 20 10 	sth  %l5, [ %i0 + 0x10 ]                       
400088ec:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
400088f0:	85 28 a0 1b 	sll  %g2, 0x1b, %g2                            
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
400088f4:	ec 26 20 34 	st  %l6, [ %i0 + 0x34 ]                        
    information->inactive_per_block = inactive_per_block;             
400088f8:	ee 26 20 30 	st  %l7, [ %i0 + 0x30 ]                        
    information->local_table = local_table;                           
400088fc:	e8 26 20 1c 	st  %l4, [ %i0 + 0x1c ]                        
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
40008900:	ab 2d 60 10 	sll  %l5, 0x10, %l5                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008904:	03 00 00 40 	sethi  %hi(0x10000), %g1                       
40008908:	ab 35 60 10 	srl  %l5, 0x10, %l5                            
4000890c:	82 10 c0 01 	or  %g3, %g1, %g1                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008910:	82 10 40 02 	or  %g1, %g2, %g1                              
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008914:	82 10 40 15 	or  %g1, %l5, %g1                              
40008918:	c2 26 20 0c 	st  %g1, [ %i0 + 0xc ]                         
        information->the_class,                                       
        _Objects_Local_node,                                          
        information->maximum                                          
      );                                                              
                                                                      
    _ISR_Enable( level );                                             
4000891c:	7f ff e5 51 	call  40001e60 <sparc_enable_interrupts>       
40008920:	01 00 00 00 	nop                                            
                                                                      
    _Workspace_Free( old_tables );                                    
40008924:	40 00 08 f5 	call  4000acf8 <_Workspace_Free>               
40008928:	90 10 00 12 	mov  %l2, %o0                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
4000892c:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
40008930:	d4 16 20 14 	lduh  [ %i0 + 0x14 ], %o2                      
40008934:	d6 06 20 18 	ld  [ %i0 + 0x18 ], %o3                        
40008938:	92 10 00 13 	mov  %l3, %o1                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
4000893c:	a1 2c 20 02 	sll  %l0, 2, %l0                               
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
40008940:	a4 07 bf f4 	add  %fp, -12, %l2                             
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
40008944:	e6 20 40 10 	st  %l3, [ %g1 + %l0 ]                         
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
40008948:	90 10 00 12 	mov  %l2, %o0                                  
4000894c:	40 00 11 75 	call  4000cf20 <_Chain_Initialize>             
40008950:	29 00 00 40 	sethi  %hi(0x10000), %l4                       
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
40008954:	10 80 00 0d 	b  40008988 <_Objects_Extend_information+0x220>
40008958:	a6 06 20 20 	add  %i0, 0x20, %l3                            
                                                                      
    the_object->id = _Objects_Build_id(                               
4000895c:	c6 16 20 04 	lduh  [ %i0 + 4 ], %g3                         
40008960:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008964:	87 28 e0 1b 	sll  %g3, 0x1b, %g3                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008968:	84 10 80 14 	or  %g2, %l4, %g2                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
4000896c:	84 10 80 03 	or  %g2, %g3, %g2                              
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008970:	84 10 80 11 	or  %g2, %l1, %g2                              
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
40008974:	90 10 00 13 	mov  %l3, %o0                                  
40008978:	92 10 00 01 	mov  %g1, %o1                                  
                                                                      
    index++;                                                          
4000897c:	a2 04 60 01 	inc  %l1                                       
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
40008980:	7f ff fc 97 	call  40007bdc <_Chain_Append>                 
40008984:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
40008988:	7f ff fc ab 	call  40007c34 <_Chain_Get>                    
4000898c:	90 10 00 12 	mov  %l2, %o0                                  
40008990:	82 92 20 00 	orcc  %o0, 0, %g1                              
40008994:	32 bf ff f2 	bne,a   4000895c <_Objects_Extend_information+0x1f4>
40008998:	c4 06 00 00 	ld  [ %i0 ], %g2                               
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
4000899c:	c8 16 20 14 	lduh  [ %i0 + 0x14 ], %g4                      
400089a0:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
400089a4:	c4 16 20 2c 	lduh  [ %i0 + 0x2c ], %g2                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
400089a8:	c8 20 c0 10 	st  %g4, [ %g3 + %l0 ]                         
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
400089ac:	82 00 80 04 	add  %g2, %g4, %g1                             
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
  information->inactive =                                             
400089b0:	c2 36 20 2c 	sth  %g1, [ %i0 + 0x2c ]                       
400089b4:	81 c7 e0 08 	ret                                            
400089b8:	81 e8 00 00 	restore                                        
  if ( information->auto_extend ) {                                   
    new_object_block = _Workspace_Allocate( block_size );             
    if ( !new_object_block )                                          
      return;                                                         
  } else {                                                            
    new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
400089bc:	40 00 08 d6 	call  4000ad14 <_Workspace_Allocate_or_fatal_error>
400089c0:	01 00 00 00 	nop                                            
400089c4:	10 bf ff 9b 	b  40008830 <_Objects_Extend_information+0xc8> 
400089c8:	a6 10 00 08 	mov  %o0, %l3                                  
      /*                                                              
       *  Copy each section of the table over. This has to be performed as
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
400089cc:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
400089d0:	bb 2f 60 02 	sll  %i5, 2, %i5                               
      /*                                                              
       *  Copy each section of the table over. This has to be performed as
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
400089d4:	40 00 1c 2e 	call  4000fa8c <memcpy>                        
400089d8:	94 10 00 1d 	mov  %i5, %o2                                  
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
400089dc:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1                        
400089e0:	94 10 00 1d 	mov  %i5, %o2                                  
400089e4:	40 00 1c 2a 	call  4000fa8c <memcpy>                        
400089e8:	90 10 00 17 	mov  %l7, %o0                                  
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
400089ec:	d4 16 20 10 	lduh  [ %i0 + 0x10 ], %o2                      
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
400089f0:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
400089f4:	94 04 80 0a 	add  %l2, %o2, %o2                             
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
400089f8:	90 10 00 14 	mov  %l4, %o0                                  
400089fc:	40 00 1c 24 	call  4000fa8c <memcpy>                        
40008a00:	95 2a a0 02 	sll  %o2, 2, %o2                               
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
40008a04:	10 bf ff a7 	b  400088a0 <_Objects_Extend_information+0x138>
40008a08:	c6 16 20 14 	lduh  [ %i0 + 0x14 ], %g3                      
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
40008a0c:	ea 16 20 10 	lduh  [ %i0 + 0x10 ], %l5                      
40008a10:	d0 16 20 14 	lduh  [ %i0 + 0x14 ], %o0                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
40008a14:	a2 10 00 12 	mov  %l2, %l1                                  
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
40008a18:	a8 10 20 01 	mov  1, %l4                                    
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008a1c:	a0 10 20 00 	clr  %l0                                       
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
40008a20:	ba 10 20 00 	clr  %i5                                       
40008a24:	10 bf ff 71 	b  400087e8 <_Objects_Extend_information+0x80> 
40008a28:	ab 2d 60 10 	sll  %l5, 0x10, %l5                            
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
40008a2c:	a2 10 00 12 	mov  %l2, %l1                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
40008a30:	a8 10 20 01 	mov  1, %l4                                    <== NOT EXECUTED
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008a34:	10 bf ff 6d 	b  400087e8 <_Objects_Extend_information+0x80> <== NOT EXECUTED
40008a38:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL ) {            
        do_extend = false;                                            
40008a3c:	a8 10 20 00 	clr  %l4                                       <== NOT EXECUTED
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008a40:	10 bf ff 6a 	b  400087e8 <_Objects_Extend_information+0x80> <== NOT EXECUTED
40008a44:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    object_blocks = (void**) _Workspace_Allocate( block_size );       
                                                                      
    if ( !object_blocks ) {                                           
      _Workspace_Free( new_object_block );                            
40008a48:	40 00 08 ac 	call  4000acf8 <_Workspace_Free>               
40008a4c:	90 10 00 13 	mov  %l3, %o0                                  
      return;                                                         
40008a50:	81 c7 e0 08 	ret                                            
40008a54:	81 e8 00 00 	restore                                        
                                                                      

40008b04 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) {
40008b04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
40008b08:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
40008b0c:	b3 36 60 10 	srl  %i1, 0x10, %i1                            
40008b10:	80 a6 60 00 	cmp  %i1, 0                                    
40008b14:	12 80 00 04 	bne  40008b24 <_Objects_Get_information+0x20>  
40008b18:	a0 10 20 00 	clr  %l0                                       
    if ( info->maximum == 0 )                                         
      return NULL;                                                    
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
40008b1c:	81 c7 e0 08 	ret                                            
40008b20:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      
  /*                                                                  
   *  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 );      
40008b24:	40 00 12 84 	call  4000d534 <_Objects_API_maximum_class>    
40008b28:	90 10 00 18 	mov  %i0, %o0                                  
  if ( the_class_api_maximum == 0 )                                   
40008b2c:	80 a2 20 00 	cmp  %o0, 0                                    
40008b30:	02 bf ff fb 	be  40008b1c <_Objects_Get_information+0x18>   
40008b34:	80 a2 00 19 	cmp  %o0, %i1                                  
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
40008b38:	0a bf ff f9 	bcs  40008b1c <_Objects_Get_information+0x18>  
40008b3c:	03 10 00 58 	sethi  %hi(0x40016000), %g1                    
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
40008b40:	b1 2e 20 02 	sll  %i0, 2, %i0                               
40008b44:	82 10 63 68 	or  %g1, 0x368, %g1                            
40008b48:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
40008b4c:	80 a0 60 00 	cmp  %g1, 0                                    
40008b50:	02 bf ff f3 	be  40008b1c <_Objects_Get_information+0x18>   <== NEVER TAKEN
40008b54:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
40008b58:	e0 00 40 19 	ld  [ %g1 + %i1 ], %l0                         
  if ( !info )                                                        
40008b5c:	80 a4 20 00 	cmp  %l0, 0                                    
40008b60:	02 bf ff ef 	be  40008b1c <_Objects_Get_information+0x18>   <== NEVER TAKEN
40008b64:	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 )                                         
40008b68:	c2 14 20 10 	lduh  [ %l0 + 0x10 ], %g1                      
      return NULL;                                                    
40008b6c:	80 a0 00 01 	cmp  %g0, %g1                                  
40008b70:	82 60 20 00 	subx  %g0, 0, %g1                              
40008b74:	10 bf ff ea 	b  40008b1c <_Objects_Get_information+0x18>    
40008b78:	a0 0c 00 01 	and  %l0, %g1, %l0                             
                                                                      

4000a8ec <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) {
4000a8ec:	9d e3 bf 90 	save  %sp, -112, %sp                           
  char                   lname[5];                                    
  Objects_Control       *the_object;                                  
  Objects_Locations      location;                                    
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
4000a8f0:	80 a6 60 00 	cmp  %i1, 0                                    
4000a8f4:	12 80 00 05 	bne  4000a908 <_Objects_Get_name_as_string+0x1c>
4000a8f8:	80 a6 a0 00 	cmp  %i2, 0                                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:                                              
      /* not supported */                                             
#endif                                                                
    case OBJECTS_ERROR:                                               
      return NULL;                                                    
4000a8fc:	b4 10 20 00 	clr  %i2                                       
                                                                      
      _Thread_Enable_dispatch();                                      
      return name;                                                    
  }                                                                   
  return NULL;                  /* unreachable path */                
}                                                                     
4000a900:	81 c7 e0 08 	ret                                            
4000a904:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
    return NULL;                                                      
                                                                      
  if ( name == NULL )                                                 
4000a908:	02 bf ff fe 	be  4000a900 <_Objects_Get_name_as_string+0x14>
4000a90c:	80 a6 20 00 	cmp  %i0, 0                                    
    return NULL;                                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
4000a910:	12 80 00 04 	bne  4000a920 <_Objects_Get_name_as_string+0x34>
4000a914:	03 10 00 85 	sethi  %hi(0x40021400), %g1                    
4000a918:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1	! 40021408 <_Per_CPU_Information+0xc>
4000a91c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
                                                                      
  information = _Objects_Get_information_id( tmpId );                 
4000a920:	7f ff ff b1 	call  4000a7e4 <_Objects_Get_information_id>   
4000a924:	90 10 00 18 	mov  %i0, %o0                                  
  if ( !information )                                                 
4000a928:	80 a2 20 00 	cmp  %o0, 0                                    
4000a92c:	22 bf ff f5 	be,a   4000a900 <_Objects_Get_name_as_string+0x14>
4000a930:	b4 10 20 00 	clr  %i2                                       
    return NULL;                                                      
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
4000a934:	92 10 00 18 	mov  %i0, %o1                                  
4000a938:	40 00 00 2c 	call  4000a9e8 <_Objects_Get>                  
4000a93c:	94 07 bf fc 	add  %fp, -4, %o2                              
  switch ( location ) {                                               
4000a940:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000a944:	80 a0 60 00 	cmp  %g1, 0                                    
4000a948:	32 bf ff ee 	bne,a   4000a900 <_Objects_Get_name_as_string+0x14>
4000a94c:	b4 10 20 00 	clr  %i2                                       
        if ( information->is_string ) {                               
          s = the_object->name.name_p;                                
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
4000a950:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
        lname[ 4 ] = '\0';                                            
4000a954:	c0 2f bf f4 	clrb  [ %fp + -12 ]                            
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
4000a958:	85 30 60 08 	srl  %g1, 8, %g2                               
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
4000a95c:	87 30 60 18 	srl  %g1, 0x18, %g3                            
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
4000a960:	89 30 60 10 	srl  %g1, 0x10, %g4                            
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
4000a964:	c4 2f bf f2 	stb  %g2, [ %fp + -14 ]                        
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
4000a968:	c6 2f bf f0 	stb  %g3, [ %fp + -16 ]                        
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
4000a96c:	c8 2f bf f1 	stb  %g4, [ %fp + -15 ]                        
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
4000a970:	c2 2f bf f3 	stb  %g1, [ %fp + -13 ]                        
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
4000a974:	b2 86 7f ff 	addcc  %i1, -1, %i1                            
4000a978:	02 80 00 19 	be  4000a9dc <_Objects_Get_name_as_string+0xf0><== NEVER TAKEN
4000a97c:	84 10 00 1a 	mov  %i2, %g2                                  
4000a980:	80 a0 e0 00 	cmp  %g3, 0                                    
4000a984:	02 80 00 16 	be  4000a9dc <_Objects_Get_name_as_string+0xf0>
4000a988:	19 10 00 81 	sethi  %hi(0x40020400), %o4                    
4000a98c:	82 10 20 00 	clr  %g1                                       
4000a990:	10 80 00 06 	b  4000a9a8 <_Objects_Get_name_as_string+0xbc> 
4000a994:	98 13 20 18 	or  %o4, 0x18, %o4                             
4000a998:	da 49 00 01 	ldsb  [ %g4 + %g1 ], %o5                       
4000a99c:	80 a3 60 00 	cmp  %o5, 0                                    
4000a9a0:	02 80 00 0f 	be  4000a9dc <_Objects_Get_name_as_string+0xf0>
4000a9a4:	c6 09 00 01 	ldub  [ %g4 + %g1 ], %g3                       
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
4000a9a8:	da 03 00 00 	ld  [ %o4 ], %o5                               
4000a9ac:	88 08 e0 ff 	and  %g3, 0xff, %g4                            
4000a9b0:	88 03 40 04 	add  %o5, %g4, %g4                             
4000a9b4:	da 49 20 01 	ldsb  [ %g4 + 1 ], %o5                         
4000a9b8:	80 8b 60 97 	btst  0x97, %o5                                
4000a9bc:	12 80 00 03 	bne  4000a9c8 <_Objects_Get_name_as_string+0xdc>
4000a9c0:	88 07 bf f0 	add  %fp, -16, %g4                             
4000a9c4:	86 10 20 2a 	mov  0x2a, %g3                                 
4000a9c8:	c6 28 80 00 	stb  %g3, [ %g2 ]                              
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
4000a9cc:	82 00 60 01 	inc  %g1                                       
4000a9d0:	80 a0 40 19 	cmp  %g1, %i1                                  
4000a9d4:	0a bf ff f1 	bcs  4000a998 <_Objects_Get_name_as_string+0xac>
4000a9d8:	84 00 a0 01 	inc  %g2                                       
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
        }                                                             
      }                                                               
      *d = '\0';                                                      
                                                                      
      _Thread_Enable_dispatch();                                      
4000a9dc:	40 00 03 6c 	call  4000b78c <_Thread_Enable_dispatch>       
4000a9e0:	c0 28 80 00 	clrb  [ %g2 ]                                  
      return name;                                                    
4000a9e4:	30 bf ff c7 	b,a   4000a900 <_Objects_Get_name_as_string+0x14>
                                                                      

40019f40 <_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;
40019f40:	c4 02 20 08 	ld  [ %o0 + 8 ], %g2                           
                                                                      
  if ( information->maximum >= index ) {                              
40019f44:	c2 12 20 10 	lduh  [ %o0 + 0x10 ], %g1                      
                                                                      
  /*                                                                  
   * 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;                           
40019f48:	84 22 40 02 	sub  %o1, %g2, %g2                             
40019f4c:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if ( information->maximum >= index ) {                              
40019f50:	80 a0 80 01 	cmp  %g2, %g1                                  
40019f54:	18 80 00 09 	bgu  40019f78 <_Objects_Get_no_protection+0x38>
40019f58:	85 28 a0 02 	sll  %g2, 2, %g2                               
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
40019f5c:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
40019f60:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
40019f64:	80 a2 20 00 	cmp  %o0, 0                                    
40019f68:	02 80 00 05 	be  40019f7c <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
40019f6c:	82 10 20 01 	mov  1, %g1                                    
      *location = OBJECTS_LOCAL;                                      
      return the_object;                                              
40019f70:	81 c3 e0 08 	retl                                           
40019f74:	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;                                          
40019f78:	82 10 20 01 	mov  1, %g1                                    
  return NULL;                                                        
40019f7c:	90 10 20 00 	clr  %o0                                       
}                                                                     
40019f80:	81 c3 e0 08 	retl                                           
40019f84:	c2 22 80 00 	st  %g1, [ %o2 ]                               
                                                                      

4000a3a8 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) {
4000a3a8:	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;
4000a3ac:	80 a6 20 00 	cmp  %i0, 0                                    
4000a3b0:	12 80 00 06 	bne  4000a3c8 <_Objects_Id_to_name+0x20>       
4000a3b4:	83 36 20 18 	srl  %i0, 0x18, %g1                            
4000a3b8:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000a3bc:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1	! 40020098 <_Per_CPU_Information+0xc>
4000a3c0:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
4000a3c4:	83 36 20 18 	srl  %i0, 0x18, %g1                            
4000a3c8:	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 )                      
4000a3cc:	84 00 7f ff 	add  %g1, -1, %g2                              
4000a3d0:	80 a0 a0 02 	cmp  %g2, 2                                    
4000a3d4:	18 80 00 17 	bgu  4000a430 <_Objects_Id_to_name+0x88>       
4000a3d8:	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 ] )                       
4000a3dc:	83 28 60 02 	sll  %g1, 2, %g1                               
4000a3e0:	05 10 00 7f 	sethi  %hi(0x4001fc00), %g2                    
4000a3e4:	84 10 a1 c8 	or  %g2, 0x1c8, %g2	! 4001fdc8 <_Objects_Information_table>
4000a3e8:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
4000a3ec:	80 a0 60 00 	cmp  %g1, 0                                    
4000a3f0:	02 80 00 10 	be  4000a430 <_Objects_Id_to_name+0x88>        
4000a3f4:	85 36 20 1b 	srl  %i0, 0x1b, %g2                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_class = _Objects_Get_class( tmpId );                            
                                                                      
  information = _Objects_Information_table[ the_api ][ the_class ];   
4000a3f8:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000a3fc:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
  if ( !information )                                                 
4000a400:	80 a2 20 00 	cmp  %o0, 0                                    
4000a404:	02 80 00 0b 	be  4000a430 <_Objects_Id_to_name+0x88>        <== NEVER TAKEN
4000a408:	92 10 00 18 	mov  %i0, %o1                                  
  #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 ); 
4000a40c:	7f ff ff ca 	call  4000a334 <_Objects_Get>                  
4000a410:	94 07 bf fc 	add  %fp, -4, %o2                              
  if ( !the_object )                                                  
4000a414:	80 a2 20 00 	cmp  %o0, 0                                    
4000a418:	02 80 00 06 	be  4000a430 <_Objects_Id_to_name+0x88>        
4000a41c:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
4000a420:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
4000a424:	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();                                          
4000a428:	40 00 03 7c 	call  4000b218 <_Thread_Enable_dispatch>       
4000a42c:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
}                                                                     
4000a430:	81 c7 e0 08 	ret                                            
4000a434:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

40008e04 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) {
40008e04:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
40008e08:	e0 16 20 0a 	lduh  [ %i0 + 0xa ], %l0                       
  block_count = (information->maximum - index_base) /                 
40008e0c:	e2 16 20 14 	lduh  [ %i0 + 0x14 ], %l1                      
40008e10:	d0 16 20 10 	lduh  [ %i0 + 0x10 ], %o0                      
40008e14:	92 10 00 11 	mov  %l1, %o1                                  
40008e18:	40 00 27 0f 	call  40012a54 <.udiv>                         
40008e1c:	90 22 00 10 	sub  %o0, %l0, %o0                             
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
40008e20:	80 a2 20 00 	cmp  %o0, 0                                    
40008e24:	02 80 00 34 	be  40008ef4 <_Objects_Shrink_information+0xf0><== NEVER TAKEN
40008e28:	01 00 00 00 	nop                                            
    if ( information->inactive_per_block[ block ] ==                  
40008e2c:	c8 06 20 30 	ld  [ %i0 + 0x30 ], %g4                        
40008e30:	c2 01 00 00 	ld  [ %g4 ], %g1                               
40008e34:	80 a4 40 01 	cmp  %l1, %g1                                  
40008e38:	02 80 00 0f 	be  40008e74 <_Objects_Shrink_information+0x70><== NEVER TAKEN
40008e3c:	82 10 20 00 	clr  %g1                                       
40008e40:	10 80 00 07 	b  40008e5c <_Objects_Shrink_information+0x58> 
40008e44:	a4 10 20 04 	mov  4, %l2                                    
      information->inactive -= information->allocation_size;          
                                                                      
      return;                                                         
    }                                                                 
                                                                      
    index_base += information->allocation_size;                       
40008e48:	86 04 a0 04 	add  %l2, 4, %g3                               
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
    if ( information->inactive_per_block[ block ] ==                  
40008e4c:	80 a4 40 02 	cmp  %l1, %g2                                  
40008e50:	02 80 00 0a 	be  40008e78 <_Objects_Shrink_information+0x74>
40008e54:	a0 04 00 11 	add  %l0, %l1, %l0                             
40008e58:	a4 10 00 03 	mov  %g3, %l2                                  
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
40008e5c:	82 00 60 01 	inc  %g1                                       
40008e60:	80 a2 00 01 	cmp  %o0, %g1                                  
40008e64:	38 bf ff f9 	bgu,a   40008e48 <_Objects_Shrink_information+0x44>
40008e68:	c4 01 00 12 	ld  [ %g4 + %l2 ], %g2                         
40008e6c:	81 c7 e0 08 	ret                                            
40008e70:	81 e8 00 00 	restore                                        
    if ( information->inactive_per_block[ block ] ==                  
40008e74:	a4 10 20 00 	clr  %l2                                       <== NOT EXECUTED
         information->allocation_size ) {                             
                                                                      
      /*                                                              
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) _Chain_First( &information->Inactive );
40008e78:	10 80 00 06 	b  40008e90 <_Objects_Shrink_information+0x8c> 
40008e7c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
         if ((index >= index_base) &&                                 
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
         }                                                            
       }                                                              
       while ( the_object );                                          
40008e80:	80 a4 60 00 	cmp  %l1, 0                                    
40008e84:	22 80 00 12 	be,a   40008ecc <_Objects_Shrink_information+0xc8>
40008e88:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
         index = _Objects_Get_index( the_object->id );                
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
40008e8c:	90 10 00 11 	mov  %l1, %o0                                  
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) _Chain_First( &information->Inactive );
                                                                      
      do {                                                            
         index = _Objects_Get_index( the_object->id );                
40008e90:	c2 12 20 0a 	lduh  [ %o0 + 0xa ], %g1                       
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
         if ((index >= index_base) &&                                 
40008e94:	80 a0 40 10 	cmp  %g1, %l0                                  
40008e98:	0a bf ff fa 	bcs  40008e80 <_Objects_Shrink_information+0x7c>
40008e9c:	e2 02 00 00 	ld  [ %o0 ], %l1                               
             (index < (index_base + information->allocation_size))) { 
40008ea0:	c4 16 20 14 	lduh  [ %i0 + 0x14 ], %g2                      
40008ea4:	84 04 00 02 	add  %l0, %g2, %g2                             
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
         if ((index >= index_base) &&                                 
40008ea8:	80 a0 40 02 	cmp  %g1, %g2                                  
40008eac:	1a bf ff f6 	bcc  40008e84 <_Objects_Shrink_information+0x80>
40008eb0:	80 a4 60 00 	cmp  %l1, 0                                    
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
40008eb4:	7f ff fb 56 	call  40007c0c <_Chain_Extract>                
40008eb8:	01 00 00 00 	nop                                            
         }                                                            
       }                                                              
       while ( the_object );                                          
40008ebc:	80 a4 60 00 	cmp  %l1, 0                                    
40008ec0:	12 bf ff f4 	bne  40008e90 <_Objects_Shrink_information+0x8c><== ALWAYS TAKEN
40008ec4:	90 10 00 11 	mov  %l1, %o0                                  
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
40008ec8:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        <== NOT EXECUTED
40008ecc:	40 00 07 8b 	call  4000acf8 <_Workspace_Free>               
40008ed0:	d0 00 40 12 	ld  [ %g1 + %l2 ], %o0                         
      information->object_blocks[ block ] = NULL;                     
40008ed4:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
      information->inactive_per_block[ block ] = 0;                   
40008ed8:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
                                                                      
      information->inactive -= information->allocation_size;          
40008edc:	c4 16 20 2c 	lduh  [ %i0 + 0x2c ], %g2                      
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
40008ee0:	c0 20 40 12 	clr  [ %g1 + %l2 ]                             
      information->inactive_per_block[ block ] = 0;                   
                                                                      
      information->inactive -= information->allocation_size;          
40008ee4:	c2 16 20 14 	lduh  [ %i0 + 0x14 ], %g1                      
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
      information->inactive_per_block[ block ] = 0;                   
40008ee8:	c0 20 c0 12 	clr  [ %g3 + %l2 ]                             
                                                                      
      information->inactive -= information->allocation_size;          
40008eec:	82 20 80 01 	sub  %g2, %g1, %g1                             
40008ef0:	c2 36 20 2c 	sth  %g1, [ %i0 + 0x2c ]                       
                                                                      
      return;                                                         
40008ef4:	81 c7 e0 08 	ret                                            
40008ef8:	81 e8 00 00 	restore                                        
                                                                      

400075a8 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) {
400075a8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_initialization_tasks_table *user_tasks;                       
                                                                      
  /*                                                                  
   *  Move information into local variables                           
   */                                                                 
  user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
400075ac:	03 10 00 56 	sethi  %hi(0x40015800), %g1                    
400075b0:	82 10 61 60 	or  %g1, 0x160, %g1	! 40015960 <Configuration_RTEMS_API>
400075b4:	e0 00 60 2c 	ld  [ %g1 + 0x2c ], %l0                        
  maximum    = Configuration_RTEMS_API.number_of_initialization_tasks;
                                                                      
  /*                                                                  
   *  Verify that we have a set of user tasks to iterate              
   */                                                                 
  if ( !user_tasks )                                                  
400075b8:	80 a4 20 00 	cmp  %l0, 0                                    
400075bc:	02 80 00 19 	be  40007620 <_RTEMS_tasks_Initialize_user_tasks_body+0x78>
400075c0:	e4 00 60 28 	ld  [ %g1 + 0x28 ], %l2                        
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
400075c4:	80 a4 a0 00 	cmp  %l2, 0                                    
400075c8:	02 80 00 16 	be  40007620 <_RTEMS_tasks_Initialize_user_tasks_body+0x78><== NEVER TAKEN
400075cc:	a2 10 20 00 	clr  %l1                                       
400075d0:	a6 07 bf fc 	add  %fp, -4, %l3                              
    return_value = rtems_task_create(                                 
400075d4:	d4 04 20 04 	ld  [ %l0 + 4 ], %o2                           
400075d8:	d0 04 00 00 	ld  [ %l0 ], %o0                               
400075dc:	d2 04 20 08 	ld  [ %l0 + 8 ], %o1                           
400075e0:	d6 04 20 14 	ld  [ %l0 + 0x14 ], %o3                        
400075e4:	d8 04 20 0c 	ld  [ %l0 + 0xc ], %o4                         
400075e8:	7f ff ff 6d 	call  4000739c <rtems_task_create>             
400075ec:	9a 10 00 13 	mov  %l3, %o5                                  
      user_tasks[ index ].stack_size,                                 
      user_tasks[ index ].mode_set,                                   
      user_tasks[ index ].attribute_set,                              
      &id                                                             
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
400075f0:	94 92 20 00 	orcc  %o0, 0, %o2                              
400075f4:	12 80 00 0d 	bne  40007628 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
400075f8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
                                                                      
    return_value = rtems_task_start(                                  
400075fc:	d4 04 20 18 	ld  [ %l0 + 0x18 ], %o2                        
40007600:	40 00 00 0e 	call  40007638 <rtems_task_start>              
40007604:	d2 04 20 10 	ld  [ %l0 + 0x10 ], %o1                        
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
40007608:	94 92 20 00 	orcc  %o0, 0, %o2                              
4000760c:	12 80 00 07 	bne  40007628 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
40007610:	a2 04 60 01 	inc  %l1                                       
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
40007614:	80 a4 80 11 	cmp  %l2, %l1                                  
40007618:	18 bf ff ef 	bgu  400075d4 <_RTEMS_tasks_Initialize_user_tasks_body+0x2c><== NEVER TAKEN
4000761c:	a0 04 20 1c 	add  %l0, 0x1c, %l0                            
40007620:	81 c7 e0 08 	ret                                            
40007624:	81 e8 00 00 	restore                                        
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
40007628:	90 10 20 01 	mov  1, %o0                                    
4000762c:	40 00 03 f2 	call  400085f4 <_Internal_error_Occurred>      
40007630:	92 10 20 01 	mov  1, %o1                                    
                                                                      

4000cc80 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) {
4000cc80:	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 ];                
4000cc84:	e0 06 21 4c 	ld  [ %i0 + 0x14c ], %l0                       
  if ( !api )                                                         
4000cc88:	80 a4 20 00 	cmp  %l0, 0                                    
4000cc8c:	02 80 00 1f 	be  4000cd08 <_RTEMS_tasks_Post_switch_extension+0x88><== NEVER TAKEN
4000cc90:	01 00 00 00 	nop                                            
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
4000cc94:	7f ff d4 6f 	call  40001e50 <sparc_disable_interrupts>      
4000cc98:	01 00 00 00 	nop                                            
    signal_set = asr->signals_posted;                                 
4000cc9c:	e2 04 20 14 	ld  [ %l0 + 0x14 ], %l1                        
    asr->signals_posted = 0;                                          
4000cca0:	c0 24 20 14 	clr  [ %l0 + 0x14 ]                            
  _ISR_Enable( level );                                               
4000cca4:	7f ff d4 6f 	call  40001e60 <sparc_enable_interrupts>       
4000cca8:	01 00 00 00 	nop                                            
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
4000ccac:	80 a4 60 00 	cmp  %l1, 0                                    
4000ccb0:	32 80 00 04 	bne,a   4000ccc0 <_RTEMS_tasks_Post_switch_extension+0x40>
4000ccb4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
4000ccb8:	81 c7 e0 08 	ret                                            
4000ccbc:	81 e8 00 00 	restore                                        
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
4000ccc0:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
4000ccc4:	82 00 60 01 	inc  %g1                                       
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
4000ccc8:	a4 07 bf fc 	add  %fp, -4, %l2                              
4000cccc:	27 00 00 3f 	sethi  %hi(0xfc00), %l3                        
4000ccd0:	94 10 00 12 	mov  %l2, %o2                                  
4000ccd4:	92 14 e3 ff 	or  %l3, 0x3ff, %o1                            
4000ccd8:	40 00 07 c9 	call  4000ebfc <rtems_task_mode>               
4000ccdc:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
                                                                      
  (*asr->handler)( signal_set );                                      
4000cce0:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
4000cce4:	9f c0 40 00 	call  %g1                                      
4000cce8:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
  asr->nest_level -= 1;                                               
4000ccec:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000ccf0:	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;                                               
4000ccf4:	82 00 7f ff 	add  %g1, -1, %g1                              
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000ccf8:	92 14 e3 ff 	or  %l3, 0x3ff, %o1                            
4000ccfc:	94 10 00 12 	mov  %l2, %o2                                  
4000cd00:	40 00 07 bf 	call  4000ebfc <rtems_task_mode>               
4000cd04:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
4000cd08:	81 c7 e0 08 	ret                                            
4000cd0c:	81 e8 00 00 	restore                                        
                                                                      

4000cbf0 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables;
4000cbf0:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
  while (tvp) {                                                       
4000cbf4:	80 a0 60 00 	cmp  %g1, 0                                    
4000cbf8:	22 80 00 0b 	be,a   4000cc24 <_RTEMS_tasks_Switch_extension+0x34>
4000cbfc:	c2 02 61 58 	ld  [ %o1 + 0x158 ], %g1                       
    tvp->tval = *tvp->ptr;                                            
4000cc00:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    *tvp->ptr = tvp->gval;                                            
4000cc04:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
    tvp->tval = *tvp->ptr;                                            
4000cc08:	c8 00 80 00 	ld  [ %g2 ], %g4                               
4000cc0c:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
4000cc10:	c2 00 40 00 	ld  [ %g1 ], %g1                               
  /*                                                                  
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
4000cc14:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc18:	12 bf ff fa 	bne  4000cc00 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN
4000cc1c:	c6 20 80 00 	st  %g3, [ %g2 ]                               
    tvp->tval = *tvp->ptr;                                            
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
4000cc20:	c2 02 61 58 	ld  [ %o1 + 0x158 ], %g1                       
  while (tvp) {                                                       
4000cc24:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc28:	02 80 00 0a 	be  4000cc50 <_RTEMS_tasks_Switch_extension+0x60>
4000cc2c:	01 00 00 00 	nop                                            
    tvp->gval = *tvp->ptr;                                            
4000cc30:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    *tvp->ptr = tvp->tval;                                            
4000cc34:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
    tvp->gval = *tvp->ptr;                                            
4000cc38:	c8 00 80 00 	ld  [ %g2 ], %g4                               
4000cc3c:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
    *tvp->ptr = tvp->tval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
4000cc40:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
4000cc44:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc48:	12 bf ff fa 	bne  4000cc30 <_RTEMS_tasks_Switch_extension+0x40><== NEVER TAKEN
4000cc4c:	c6 20 80 00 	st  %g3, [ %g2 ]                               
4000cc50:	81 c3 e0 08 	retl                                           
                                                                      

400088c0 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) {
400088c0:	9d e3 bf 98 	save  %sp, -104, %sp                           
400088c4:	11 10 00 80 	sethi  %hi(0x40020000), %o0                    
400088c8:	92 10 00 18 	mov  %i0, %o1                                  
400088cc:	90 12 23 c4 	or  %o0, 0x3c4, %o0                            
400088d0:	40 00 08 39 	call  4000a9b4 <_Objects_Get>                  
400088d4:	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 ) {                                               
400088d8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400088dc:	80 a0 60 00 	cmp  %g1, 0                                    
400088e0:	12 80 00 16 	bne  40008938 <_Rate_monotonic_Timeout+0x78>   <== NEVER TAKEN
400088e4:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
400088e8:	d0 02 20 40 	ld  [ %o0 + 0x40 ], %o0                        
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
400088ec:	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);                   
400088f0:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
400088f4:	80 88 80 01 	btst  %g2, %g1                                 
400088f8:	22 80 00 08 	be,a   40008918 <_Rate_monotonic_Timeout+0x58> 
400088fc:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
40008900:	c4 02 20 20 	ld  [ %o0 + 0x20 ], %g2                        
40008904:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
40008908:	80 a0 80 01 	cmp  %g2, %g1                                  
4000890c:	02 80 00 19 	be  40008970 <_Rate_monotonic_Timeout+0xb0>    
40008910:	13 04 00 ff 	sethi  %hi(0x1003fc00), %o1                    
        _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 ) {
40008914:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
40008918:	80 a0 60 01 	cmp  %g1, 1                                    
4000891c:	02 80 00 09 	be  40008940 <_Rate_monotonic_Timeout+0x80>    
40008920:	82 10 20 04 	mov  4, %g1                                    
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
40008924:	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;                                
40008928:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4000892c:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 40020530 <_Thread_Dispatch_disable_level>
40008930:	84 00 bf ff 	add  %g2, -1, %g2                              
40008934:	c4 20 61 30 	st  %g2, [ %g1 + 0x130 ]                       
40008938:	81 c7 e0 08 	ret                                            
4000893c:	81 e8 00 00 	restore                                        
                                                                      
        _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 ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
40008940:	82 10 20 03 	mov  3, %g1                                    
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40008944:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
        _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 ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
40008948:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
4000894c:	7f ff fe 4c 	call  4000827c <_Rate_monotonic_Initiate_statistics>
40008950:	01 00 00 00 	nop                                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40008954:	c2 04 20 3c 	ld  [ %l0 + 0x3c ], %g1                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40008958:	11 10 00 81 	sethi  %hi(0x40020400), %o0                    
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000895c:	c2 24 20 1c 	st  %g1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40008960:	90 12 21 f0 	or  %o0, 0x1f0, %o0                            
40008964:	40 00 0f e0 	call  4000c8e4 <_Watchdog_Insert>              
40008968:	92 04 20 10 	add  %l0, 0x10, %o1                            
4000896c:	30 bf ff ef 	b,a   40008928 <_Rate_monotonic_Timeout+0x68>  
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40008970:	40 00 0a cb 	call  4000b49c <_Thread_Clear_state>           
40008974:	92 12 63 f8 	or  %o1, 0x3f8, %o1                            
      the_thread = the_period->owner;                                 
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
            the_thread->Wait.id == the_period->Object.id ) {          
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40008978:	10 bf ff f5 	b  4000894c <_Rate_monotonic_Timeout+0x8c>     
4000897c:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      

40008fa0 <_Scheduler_priority_Block>: #include <rtems/score/thread.h> void _Scheduler_priority_Block( Thread_Control *the_thread ) {
40008fa0:	9d e3 bf a0 	save  %sp, -96, %sp                            
)                                                                     
{                                                                     
  Scheduler_priority_Per_thread *sched_info;                          
  Chain_Control                 *ready;                               
                                                                      
  sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
40008fa4:	c4 06 20 8c 	ld  [ %i0 + 0x8c ], %g2                        
  ready      = sched_info->ready_chain;                               
40008fa8:	c2 00 80 00 	ld  [ %g2 ], %g1                               
                                                                      
  if ( _Chain_Has_only_one_node( ready ) ) {                          
40008fac:	c8 00 40 00 	ld  [ %g1 ], %g4                               
40008fb0:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
40008fb4:	80 a1 00 03 	cmp  %g4, %g3                                  
40008fb8:	22 80 00 3a 	be,a   400090a0 <_Scheduler_priority_Block+0x100>
40008fbc:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40008fc0:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
40008fc4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
  next->previous = previous;                                          
40008fc8:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
40008fcc:	c4 20 40 00 	st  %g2, [ %g1 ]                               
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (                           
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
40008fd0:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40008fd4:	82 10 62 2c 	or  %g1, 0x22c, %g1	! 4001662c <_Per_CPU_Information>
  _Scheduler_priority_Ready_queue_extract( the_thread );              
                                                                      
  /* TODO: flash critical section? */                                 
                                                                      
  if ( _Thread_Is_heir( the_thread ) )                                
40008fd8:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
40008fdc:	80 a6 00 02 	cmp  %i0, %g2                                  
40008fe0:	02 80 00 09 	be  40009004 <_Scheduler_priority_Block+0x64>  
40008fe4:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
     _Scheduler_priority_Schedule_body();                             
                                                                      
  if ( _Thread_Is_executing( the_thread ) )                           
40008fe8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40008fec:	80 a6 00 02 	cmp  %i0, %g2                                  
40008ff0:	12 80 00 03 	bne  40008ffc <_Scheduler_priority_Block+0x5c> 
40008ff4:	84 10 20 01 	mov  1, %g2                                    
    _Thread_Dispatch_necessary = true;                                
40008ff8:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
40008ffc:	81 c7 e0 08 	ret                                            
40009000:	81 e8 00 00 	restore                                        
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
40009004:	c4 10 a2 50 	lduh  [ %g2 + 0x250 ], %g2                     
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
40009008:	07 10 00 56 	sethi  %hi(0x40015800), %g3                    
4000900c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40009010:	89 30 a0 10 	srl  %g2, 0x10, %g4                            
40009014:	80 a1 20 ff 	cmp  %g4, 0xff                                 
40009018:	18 80 00 37 	bgu  400090f4 <_Scheduler_priority_Block+0x154>
4000901c:	c6 00 e0 c0 	ld  [ %g3 + 0xc0 ], %g3                        
40009020:	1b 10 00 54 	sethi  %hi(0x40015000), %o5                    
40009024:	9a 13 60 50 	or  %o5, 0x50, %o5	! 40015050 <__log2table>    
40009028:	c4 0b 40 04 	ldub  [ %o5 + %g4 ], %g2                       
4000902c:	84 00 a0 08 	add  %g2, 8, %g2                               
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
40009030:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40009034:	19 10 00 59 	sethi  %hi(0x40016400), %o4                    
40009038:	89 30 a0 0f 	srl  %g2, 0xf, %g4                             
4000903c:	98 13 22 60 	or  %o4, 0x260, %o4                            
40009040:	c8 13 00 04 	lduh  [ %o4 + %g4 ], %g4                       
40009044:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40009048:	99 31 20 10 	srl  %g4, 0x10, %o4                            
4000904c:	80 a3 20 ff 	cmp  %o4, 0xff                                 
40009050:	38 80 00 27 	bgu,a   400090ec <_Scheduler_priority_Block+0x14c>
40009054:	89 31 20 18 	srl  %g4, 0x18, %g4                            
40009058:	c8 0b 40 0c 	ldub  [ %o5 + %o4 ], %g4                       
4000905c:	88 01 20 08 	add  %g4, 8, %g4                               
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
40009060:	85 30 a0 0c 	srl  %g2, 0xc, %g2                             
          _Priority_Bits_index( minor );                              
40009064:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40009068:	89 31 20 10 	srl  %g4, 0x10, %g4                            
  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) +                       
4000906c:	88 01 00 02 	add  %g4, %g2, %g4                             
  Chain_Control       *the_ready_queue                                
)                                                                     
{                                                                     
  Priority_Control index = _Priority_bit_map_Get_highest();           
                                                                      
  if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )                
40009070:	9b 29 20 02 	sll  %g4, 2, %o5                               
40009074:	85 29 20 04 	sll  %g4, 4, %g2                               
40009078:	84 20 80 0d 	sub  %g2, %o5, %g2                             
                                                                      
}                                                                     
4000907c:	da 00 c0 02 	ld  [ %g3 + %g2 ], %o5                         
40009080:	84 00 c0 02 	add  %g3, %g2, %g2                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
40009084:	84 00 a0 04 	add  %g2, 4, %g2                               
40009088:	80 a3 40 02 	cmp  %o5, %g2                                  
4000908c:	02 80 00 03 	be  40009098 <_Scheduler_priority_Block+0xf8>  <== NEVER TAKEN
40009090:	88 10 20 00 	clr  %g4                                       
    return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
40009094:	88 10 00 0d 	mov  %o5, %g4                                  
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
40009098:	10 bf ff d4 	b  40008fe8 <_Scheduler_priority_Block+0x48>   
4000909c:	c8 20 60 10 	st  %g4, [ %g1 + 0x10 ]                        
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (                  
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor &= the_priority_map->block_minor;          
400090a0:	c8 10 a0 0e 	lduh  [ %g2 + 0xe ], %g4                       
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
400090a4:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
  tail->previous = head;                                              
400090a8:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
400090ac:	9a 00 60 04 	add  %g1, 4, %o5                               
                                                                      
  head->next = tail;                                                  
400090b0:	da 20 40 00 	st  %o5, [ %g1 ]                               
400090b4:	c2 10 c0 00 	lduh  [ %g3 ], %g1                             
400090b8:	82 08 40 04 	and  %g1, %g4, %g1                             
400090bc:	c2 30 c0 00 	sth  %g1, [ %g3 ]                              
  if ( *the_priority_map->minor == 0 )                                
400090c0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400090c4:	80 a0 60 00 	cmp  %g1, 0                                    
400090c8:	32 bf ff c3 	bne,a   40008fd4 <_Scheduler_priority_Block+0x34>
400090cc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
    _Priority_Major_bit_map &= the_priority_map->block_major;         
400090d0:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400090d4:	c4 10 a0 0c 	lduh  [ %g2 + 0xc ], %g2                       
400090d8:	c6 10 62 50 	lduh  [ %g1 + 0x250 ], %g3                     
400090dc:	84 08 c0 02 	and  %g3, %g2, %g2                             
400090e0:	c4 30 62 50 	sth  %g2, [ %g1 + 0x250 ]                      
400090e4:	10 bf ff bc 	b  40008fd4 <_Scheduler_priority_Block+0x34>   
400090e8:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
400090ec:	10 bf ff dd 	b  40009060 <_Scheduler_priority_Block+0xc0>   
400090f0:	c8 0b 40 04 	ldub  [ %o5 + %g4 ], %g4                       
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
400090f4:	1b 10 00 54 	sethi  %hi(0x40015000), %o5                    
400090f8:	85 30 a0 18 	srl  %g2, 0x18, %g2                            
400090fc:	9a 13 60 50 	or  %o5, 0x50, %o5                             
40009100:	10 bf ff cc 	b  40009030 <_Scheduler_priority_Block+0x90>   
40009104:	c4 0b 40 02 	ldub  [ %o5 + %g2 ], %g2                       
                                                                      

400092c8 <_Scheduler_priority_Schedule>: #include <rtems/system.h> #include <rtems/score/scheduler.h> #include <rtems/score/schedulerpriority.h> void _Scheduler_priority_Schedule(void) {
400092c8:	9d e3 bf a0 	save  %sp, -96, %sp                            
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
400092cc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400092d0:	c2 10 62 50 	lduh  [ %g1 + 0x250 ], %g1	! 40016650 <_Priority_Major_bit_map>
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
400092d4:	05 10 00 56 	sethi  %hi(0x40015800), %g2                    
400092d8:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400092dc:	87 30 60 10 	srl  %g1, 0x10, %g3                            
400092e0:	80 a0 e0 ff 	cmp  %g3, 0xff                                 
400092e4:	18 80 00 26 	bgu  4000937c <_Scheduler_priority_Schedule+0xb4>
400092e8:	c4 00 a0 c0 	ld  [ %g2 + 0xc0 ], %g2                        
400092ec:	09 10 00 54 	sethi  %hi(0x40015000), %g4                    
400092f0:	88 11 20 50 	or  %g4, 0x50, %g4	! 40015050 <__log2table>    
400092f4:	c2 09 00 03 	ldub  [ %g4 + %g3 ], %g1                       
400092f8:	82 00 60 08 	add  %g1, 8, %g1                               
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
400092fc:	83 28 60 10 	sll  %g1, 0x10, %g1                            
40009300:	1b 10 00 59 	sethi  %hi(0x40016400), %o5                    
40009304:	87 30 60 0f 	srl  %g1, 0xf, %g3                             
40009308:	9a 13 62 60 	or  %o5, 0x260, %o5                            
4000930c:	c6 13 40 03 	lduh  [ %o5 + %g3 ], %g3                       
40009310:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40009314:	9b 30 e0 10 	srl  %g3, 0x10, %o5                            
40009318:	80 a3 60 ff 	cmp  %o5, 0xff                                 
4000931c:	38 80 00 16 	bgu,a   40009374 <_Scheduler_priority_Schedule+0xac>
40009320:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
40009324:	c6 09 00 0d 	ldub  [ %g4 + %o5 ], %g3                       
40009328:	86 00 e0 08 	add  %g3, 8, %g3                               
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
4000932c:	83 30 60 0c 	srl  %g1, 0xc, %g1                             
          _Priority_Bits_index( minor );                              
40009330:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40009334:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
  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) +                       
40009338:	86 00 c0 01 	add  %g3, %g1, %g3                             
  Chain_Control       *the_ready_queue                                
)                                                                     
{                                                                     
  Priority_Control index = _Priority_bit_map_Get_highest();           
                                                                      
  if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )                
4000933c:	89 28 e0 02 	sll  %g3, 2, %g4                               
40009340:	83 28 e0 04 	sll  %g3, 4, %g1                               
40009344:	82 20 40 04 	sub  %g1, %g4, %g1                             
  _Scheduler_priority_Schedule_body();                                
}                                                                     
40009348:	c8 00 80 01 	ld  [ %g2 + %g1 ], %g4                         
4000934c:	82 00 80 01 	add  %g2, %g1, %g1                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
40009350:	82 00 60 04 	add  %g1, 4, %g1                               
40009354:	80 a1 00 01 	cmp  %g4, %g1                                  
40009358:	02 80 00 03 	be  40009364 <_Scheduler_priority_Schedule+0x9c><== NEVER TAKEN
4000935c:	86 10 20 00 	clr  %g3                                       
    return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
40009360:	86 10 00 04 	mov  %g4, %g3                                  
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
40009364:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40009368:	c6 20 62 3c 	st  %g3, [ %g1 + 0x23c ]	! 4001663c <_Per_CPU_Information+0x10>
4000936c:	81 c7 e0 08 	ret                                            
40009370:	81 e8 00 00 	restore                                        
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
40009374:	10 bf ff ee 	b  4000932c <_Scheduler_priority_Schedule+0x64>
40009378:	c6 09 00 03 	ldub  [ %g4 + %g3 ], %g3                       
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
4000937c:	09 10 00 54 	sethi  %hi(0x40015000), %g4                    
40009380:	83 30 60 18 	srl  %g1, 0x18, %g1                            
40009384:	88 11 20 50 	or  %g4, 0x50, %g4                             
40009388:	10 bf ff dd 	b  400092fc <_Scheduler_priority_Schedule+0x34>
4000938c:	c2 09 00 01 	ldub  [ %g4 + %g1 ], %g1                       
                                                                      

400094a4 <_Scheduler_priority_Yield>: * ready chain * select heir */ void _Scheduler_priority_Yield(void) {
400094a4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Scheduler_priority_Per_thread *sched_info;                          
  ISR_Level                      level;                               
  Thread_Control                *executing;                           
  Chain_Control                 *ready;                               
                                                                      
  executing  = _Thread_Executing;                                     
400094a8:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
400094ac:	a4 14 a2 2c 	or  %l2, 0x22c, %l2	! 4001662c <_Per_CPU_Information>
400094b0:	e0 04 a0 0c 	ld  [ %l2 + 0xc ], %l0                         
  sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
  ready      = sched_info->ready_chain;                               
400094b4:	c2 04 20 8c 	ld  [ %l0 + 0x8c ], %g1                        
  _ISR_Disable( level );                                              
400094b8:	7f ff e2 66 	call  40001e50 <sparc_disable_interrupts>      
400094bc:	e2 00 40 00 	ld  [ %g1 ], %l1                               
400094c0:	b0 10 00 08 	mov  %o0, %i0                                  
    if ( !_Chain_Has_only_one_node( ready ) ) {                       
400094c4:	c4 04 40 00 	ld  [ %l1 ], %g2                               
400094c8:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
400094cc:	80 a0 80 01 	cmp  %g2, %g1                                  
400094d0:	02 80 00 16 	be  40009528 <_Scheduler_priority_Yield+0x84>  
400094d4:	86 04 60 04 	add  %l1, 4, %g3                               
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
400094d8:	c2 04 20 04 	ld  [ %l0 + 4 ], %g1                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
400094dc:	c4 04 00 00 	ld  [ %l0 ], %g2                               
  previous       = the_node->previous;                                
  next->previous = previous;                                          
400094e0:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
400094e4:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
400094e8:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
                                                                      
  the_node->next = tail;                                              
400094ec:	c6 24 00 00 	st  %g3, [ %l0 ]                               
  tail->previous = the_node;                                          
400094f0:	e0 24 60 08 	st  %l0, [ %l1 + 8 ]                           
  old_last->next = the_node;                                          
400094f4:	e0 20 40 00 	st  %l0, [ %g1 ]                               
  the_node->previous = old_last;                                      
400094f8:	c2 24 20 04 	st  %g1, [ %l0 + 4 ]                           
      _Chain_Extract_unprotected( &executing->Object.Node );          
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
400094fc:	7f ff e2 59 	call  40001e60 <sparc_enable_interrupts>       
40009500:	01 00 00 00 	nop                                            
40009504:	7f ff e2 53 	call  40001e50 <sparc_disable_interrupts>      
40009508:	01 00 00 00 	nop                                            
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
4000950c:	c2 04 a0 10 	ld  [ %l2 + 0x10 ], %g1                        
40009510:	80 a4 00 01 	cmp  %l0, %g1                                  
40009514:	02 80 00 0b 	be  40009540 <_Scheduler_priority_Yield+0x9c>  <== ALWAYS TAKEN
40009518:	82 10 20 01 	mov  1, %g1                                    
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );      
      _Thread_Dispatch_necessary = true;                              
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
      _Thread_Dispatch_necessary = true;                              
4000951c:	c2 2c a0 18 	stb  %g1, [ %l2 + 0x18 ]                       <== NOT EXECUTED
                                                                      
  _ISR_Enable( level );                                               
40009520:	7f ff e2 50 	call  40001e60 <sparc_enable_interrupts>       
40009524:	81 e8 00 00 	restore                                        
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );      
      _Thread_Dispatch_necessary = true;                              
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
40009528:	c2 04 a0 10 	ld  [ %l2 + 0x10 ], %g1                        
4000952c:	80 a4 00 01 	cmp  %l0, %g1                                  
40009530:	02 bf ff fc 	be  40009520 <_Scheduler_priority_Yield+0x7c>  
40009534:	82 10 20 01 	mov  1, %g1                                    
      _Thread_Dispatch_necessary = true;                              
40009538:	c2 2c a0 18 	stb  %g1, [ %l2 + 0x18 ]                       
4000953c:	30 bf ff f9 	b,a   40009520 <_Scheduler_priority_Yield+0x7c>
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );      
40009540:	c2 04 40 00 	ld  [ %l1 ], %g1                               
40009544:	c2 24 a0 10 	st  %g1, [ %l2 + 0x10 ]                        
      _Thread_Dispatch_necessary = true;                              
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
      _Thread_Dispatch_necessary = true;                              
40009548:	82 10 20 01 	mov  1, %g1                                    
4000954c:	c2 2c a0 18 	stb  %g1, [ %l2 + 0x18 ]                       
40009550:	30 bf ff f4 	b,a   40009520 <_Scheduler_priority_Yield+0x7c>
                                                                      

40008140 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) {
40008140:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
40008144:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
40008148:	03 10 00 56 	sethi  %hi(0x40015800), %g1                    
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
4000814c:	c6 00 a1 10 	ld  [ %g2 + 0x110 ], %g3                       
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
40008150:	c2 00 61 a4 	ld  [ %g1 + 0x1a4 ], %g1                       
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
40008154:	86 00 e0 01 	inc  %g3                                       
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
40008158:	9b 28 60 07 	sll  %g1, 7, %o5                               
4000815c:	89 28 60 02 	sll  %g1, 2, %g4                               
40008160:	88 23 40 04 	sub  %o5, %g4, %g4                             
40008164:	82 01 00 01 	add  %g4, %g1, %g1                             
40008168:	83 28 60 03 	sll  %g1, 3, %g1                               
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
                                                                      
  /* Update the timespec format uptime */                             
  _Timestamp_Add_to( &_TOD_Uptime, &tick );                           
4000816c:	a0 07 bf f8 	add  %fp, -8, %l0                              
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
40008170:	c6 20 a1 10 	st  %g3, [ %g2 + 0x110 ]                       
                                                                      
  /* Update the timespec format uptime */                             
  _Timestamp_Add_to( &_TOD_Uptime, &tick );                           
40008174:	92 10 00 10 	mov  %l0, %o1                                  
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
40008178:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
4000817c:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
                                                                      
  /* Update the timespec format uptime */                             
  _Timestamp_Add_to( &_TOD_Uptime, &tick );                           
40008180:	11 10 00 59 	sethi  %hi(0x40016400), %o0                    
40008184:	40 00 08 fe 	call  4000a57c <_Timespec_Add_to>              
40008188:	90 12 20 7c 	or  %o0, 0x7c, %o0	! 4001647c <_TOD_Uptime>    
  /* we do not care how much the uptime changed */                    
                                                                      
  /* Update the timespec format TOD */                                
  seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );            
4000818c:	92 10 00 10 	mov  %l0, %o1                                  
40008190:	11 10 00 59 	sethi  %hi(0x40016400), %o0                    
40008194:	40 00 08 fa 	call  4000a57c <_Timespec_Add_to>              
40008198:	90 12 20 88 	or  %o0, 0x88, %o0	! 40016488 <_TOD_Now>       
  while ( seconds ) {                                                 
4000819c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
400081a0:	02 80 00 08 	be  400081c0 <_TOD_Tickle_ticks+0x80>          
400081a4:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )            
{                                                                     
                                                                      
  _Watchdog_Tickle( &_Watchdog_Seconds_chain );                       
400081a8:	a2 14 60 b4 	or  %l1, 0xb4, %l1	! 400164b4 <_Watchdog_Seconds_chain>
400081ac:	40 00 0a 84 	call  4000abbc <_Watchdog_Tickle>              
400081b0:	90 10 00 11 	mov  %l1, %o0                                  
400081b4:	a0 84 3f ff 	addcc  %l0, -1, %l0                            
400081b8:	12 bf ff fd 	bne  400081ac <_TOD_Tickle_ticks+0x6c>         <== NEVER TAKEN
400081bc:	01 00 00 00 	nop                                            
400081c0:	81 c7 e0 08 	ret                                            
400081c4:	81 e8 00 00 	restore                                        
                                                                      

4000828c <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) {
4000828c:	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();                 
40008290:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
40008294:	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();                 
40008298:	d2 00 63 14 	ld  [ %g1 + 0x314 ], %o1                       
  if ((!the_tod)                                  ||                  
4000829c:	80 a4 20 00 	cmp  %l0, 0                                    
400082a0:	02 80 00 2c 	be  40008350 <_TOD_Validate+0xc4>              <== NEVER TAKEN
400082a4:	b0 10 20 00 	clr  %i0                                       
)                                                                     
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
400082a8:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
400082ac:	40 00 4a 3b 	call  4001ab98 <.udiv>                         
400082b0:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
400082b4:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
400082b8:	80 a2 00 01 	cmp  %o0, %g1                                  
400082bc:	08 80 00 25 	bleu  40008350 <_TOD_Validate+0xc4>            
400082c0:	01 00 00 00 	nop                                            
      (the_tod->ticks  >= ticks_per_second)       ||                  
400082c4:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
400082c8:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
400082cc:	18 80 00 21 	bgu  40008350 <_TOD_Validate+0xc4>             
400082d0:	01 00 00 00 	nop                                            
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
400082d4:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
400082d8:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
400082dc:	18 80 00 1d 	bgu  40008350 <_TOD_Validate+0xc4>             
400082e0:	01 00 00 00 	nop                                            
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
400082e4:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
400082e8:	80 a0 60 17 	cmp  %g1, 0x17                                 
400082ec:	18 80 00 19 	bgu  40008350 <_TOD_Validate+0xc4>             
400082f0:	01 00 00 00 	nop                                            
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
400082f4:	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)      ||                  
400082f8:	80 a0 60 00 	cmp  %g1, 0                                    
400082fc:	02 80 00 15 	be  40008350 <_TOD_Validate+0xc4>              <== NEVER TAKEN
40008300:	80 a0 60 0c 	cmp  %g1, 0xc                                  
      (the_tod->month  == 0)                      ||                  
40008304:	18 80 00 13 	bgu  40008350 <_TOD_Validate+0xc4>             
40008308:	01 00 00 00 	nop                                            
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
4000830c:	c4 04 00 00 	ld  [ %l0 ], %g2                               
      (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)    ||                  
40008310:	80 a0 a7 c3 	cmp  %g2, 0x7c3                                
40008314:	08 80 00 0f 	bleu  40008350 <_TOD_Validate+0xc4>            
40008318:	01 00 00 00 	nop                                            
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
4000831c:	c6 04 20 08 	ld  [ %l0 + 8 ], %g3                           
      (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)          ||                  
40008320:	80 a0 e0 00 	cmp  %g3, 0                                    
40008324:	02 80 00 0b 	be  40008350 <_TOD_Validate+0xc4>              <== NEVER TAKEN
40008328:	80 88 a0 03 	btst  3, %g2                                   
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
4000832c:	32 80 00 0b 	bne,a   40008358 <_TOD_Validate+0xcc>          
40008330:	83 28 60 02 	sll  %g1, 2, %g1                               
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
40008334:	82 00 60 0d 	add  %g1, 0xd, %g1                             
40008338:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
4000833c:	83 28 60 02 	sll  %g1, 2, %g1                               
40008340:	84 10 a3 e8 	or  %g2, 0x3e8, %g2                            
40008344:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 *    false - if the the_tod is invalid                               
 *                                                                    
 *  NOTE: This routine only works for leap-years through 2099.        
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
40008348:	80 a0 40 03 	cmp  %g1, %g3                                  
4000834c:	b0 60 3f ff 	subx  %g0, -1, %i0                             
                                                                      
  if ( the_tod->day > days_in_month )                                 
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
40008350:	81 c7 e0 08 	ret                                            
40008354:	81 e8 00 00 	restore                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
40008358:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
4000835c:	84 10 a3 e8 	or  %g2, 0x3e8, %g2	! 4001efe8 <_TOD_Days_per_month>
40008360:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 *    false - if the the_tod is invalid                               
 *                                                                    
 *  NOTE: This routine only works for leap-years through 2099.        
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
40008364:	80 a0 40 03 	cmp  %g1, %g3                                  
40008368:	b0 60 3f ff 	subx  %g0, -1, %i0                             
4000836c:	81 c7 e0 08 	ret                                            
40008370:	81 e8 00 00 	restore                                        
                                                                      

400095b0 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) {
400095b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  States_Control state, original_state;                               
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
400095b4:	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 );                                
400095b8:	40 00 03 79 	call  4000a39c <_Thread_Set_transient>         
400095bc:	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 )                  
400095c0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
400095c4:	80 a0 40 19 	cmp  %g1, %i1                                  
400095c8:	02 80 00 05 	be  400095dc <_Thread_Change_priority+0x2c>    
400095cc:	a0 10 00 18 	mov  %i0, %l0                                  
    _Thread_Set_priority( the_thread, new_priority );                 
400095d0:	90 10 00 18 	mov  %i0, %o0                                  
400095d4:	40 00 03 57 	call  4000a330 <_Thread_Set_priority>          
400095d8:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  _ISR_Disable( level );                                              
400095dc:	7f ff e2 1d 	call  40001e50 <sparc_disable_interrupts>      
400095e0:	01 00 00 00 	nop                                            
400095e4:	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;                                  
400095e8:	e4 04 20 10 	ld  [ %l0 + 0x10 ], %l2                        
  if ( state != STATES_TRANSIENT ) {                                  
400095ec:	80 a4 a0 04 	cmp  %l2, 4                                    
400095f0:	02 80 00 18 	be  40009650 <_Thread_Change_priority+0xa0>    
400095f4:	80 8c 60 04 	btst  4, %l1                                   
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
400095f8:	02 80 00 0b 	be  40009624 <_Thread_Change_priority+0x74>    <== ALWAYS TAKEN
400095fc:	82 0c bf fb 	and  %l2, -5, %g1                              
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
    _ISR_Enable( level );                                             
40009600:	7f ff e2 18 	call  40001e60 <sparc_enable_interrupts>       <== NOT EXECUTED
40009604:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_ON_THREAD_QUEUE);              
40009608:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       <== NOT EXECUTED
4000960c:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
40009610:	80 8c 80 01 	btst  %l2, %g1                                 <== NOT EXECUTED
40009614:	32 80 00 0d 	bne,a   40009648 <_Thread_Change_priority+0x98><== NOT EXECUTED
40009618:	f0 04 20 44 	ld  [ %l0 + 0x44 ], %i0                        <== NOT EXECUTED
4000961c:	81 c7 e0 08 	ret                                            
40009620:	81 e8 00 00 	restore                                        
   */                                                                 
  state = the_thread->current_state;                                  
  if ( state != STATES_TRANSIENT ) {                                  
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
40009624:	c2 24 20 10 	st  %g1, [ %l0 + 0x10 ]                        
    _ISR_Enable( level );                                             
40009628:	7f ff e2 0e 	call  40001e60 <sparc_enable_interrupts>       
4000962c:	90 10 00 18 	mov  %i0, %o0                                  
40009630:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
40009634:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
40009638:	80 8c 80 01 	btst  %l2, %g1                                 
4000963c:	02 bf ff f8 	be  4000961c <_Thread_Change_priority+0x6c>    
40009640:	01 00 00 00 	nop                                            
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
40009644:	f0 04 20 44 	ld  [ %l0 + 0x44 ], %i0                        
40009648:	40 00 03 0a 	call  4000a270 <_Thread_queue_Requeue>         
4000964c:	93 e8 00 10 	restore  %g0, %l0, %o1                         
40009650:	23 10 00 56 	sethi  %hi(0x40015800), %l1                    
    }                                                                 
    return;                                                           
  }                                                                   
                                                                      
  /* Only clear the transient state if it wasn't set already */       
  if ( ! _States_Is_transient( original_state ) ) {                   
40009654:	12 80 00 08 	bne  40009674 <_Thread_Change_priority+0xc4>   <== NEVER TAKEN
40009658:	a2 14 60 c0 	or  %l1, 0xc0, %l1	! 400158c0 <_Scheduler>     
     *  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 );
                                                                      
    if ( prepend_it )                                                 
4000965c:	80 8e a0 ff 	btst  0xff, %i2                                
40009660:	02 80 00 1a 	be  400096c8 <_Thread_Change_priority+0x118>   
40009664:	c0 24 20 10 	clr  [ %l0 + 0x10 ]                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(                   
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue_first( the_thread );                  
40009668:	c2 04 60 28 	ld  [ %l1 + 0x28 ], %g1                        
4000966c:	9f c0 40 00 	call  %g1                                      
40009670:	90 10 00 10 	mov  %l0, %o0                                  
      _Scheduler_Enqueue_first( the_thread );                         
    else                                                              
      _Scheduler_Enqueue( the_thread );                               
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
40009674:	7f ff e1 fb 	call  40001e60 <sparc_enable_interrupts>       
40009678:	90 10 00 18 	mov  %i0, %o0                                  
4000967c:	7f ff e1 f5 	call  40001e50 <sparc_disable_interrupts>      
40009680:	01 00 00 00 	nop                                            
 *  This kernel routine implements the scheduling decision logic for  
 *  the scheduler. It does NOT dispatch.                              
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )                 
{                                                                     
  _Scheduler.Operations.schedule();                                   
40009684:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
40009688:	9f c0 40 00 	call  %g1                                      
4000968c:	01 00 00 00 	nop                                            
 *  is also the heir thread, and false otherwise.                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )  
{                                                                     
  return ( _Thread_Executing == _Thread_Heir );                       
40009690:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
40009694:	82 10 62 2c 	or  %g1, 0x22c, %g1	! 4001662c <_Per_CPU_Information>
40009698:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
   *  We altered the set of thread priorities.  So let's figure out   
   *  who is the heir and if we need to switch to them.               
   */                                                                 
  _Scheduler_Schedule();                                              
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
4000969c:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
400096a0:	80 a0 80 03 	cmp  %g2, %g3                                  
400096a4:	02 80 00 07 	be  400096c0 <_Thread_Change_priority+0x110>   
400096a8:	01 00 00 00 	nop                                            
400096ac:	c4 08 a0 74 	ldub  [ %g2 + 0x74 ], %g2                      
400096b0:	80 a0 a0 00 	cmp  %g2, 0                                    
400096b4:	02 80 00 03 	be  400096c0 <_Thread_Change_priority+0x110>   
400096b8:	84 10 20 01 	mov  1, %g2                                    
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
400096bc:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
  _ISR_Enable( level );                                               
400096c0:	7f ff e1 e8 	call  40001e60 <sparc_enable_interrupts>       
400096c4:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue( the_thread );                        
400096c8:	c2 04 60 24 	ld  [ %l1 + 0x24 ], %g1                        
400096cc:	9f c0 40 00 	call  %g1                                      
400096d0:	90 10 00 10 	mov  %l0, %o0                                  
400096d4:	30 bf ff e8 	b,a   40009674 <_Thread_Change_priority+0xc4>  
                                                                      

400098c4 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) {
400098c4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
400098c8:	90 10 00 18 	mov  %i0, %o0                                  
400098cc:	40 00 00 6c 	call  40009a7c <_Thread_Get>                   
400098d0:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
400098d4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400098d8:	80 a0 60 00 	cmp  %g1, 0                                    
400098dc:	12 80 00 08 	bne  400098fc <_Thread_Delay_ended+0x38>       <== NEVER TAKEN
400098e0:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
400098e4:	7f ff ff 7d 	call  400096d8 <_Thread_Clear_state>           
400098e8:	92 12 60 18 	or  %o1, 0x18, %o1	! 10000018 <RAM_SIZE+0xfc00018>
400098ec:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400098f0:	c4 00 60 00 	ld  [ %g1 ], %g2                               
400098f4:	84 00 bf ff 	add  %g2, -1, %g2                              
400098f8:	c4 20 60 00 	st  %g2, [ %g1 ]                               
400098fc:	81 c7 e0 08 	ret                                            
40009900:	81 e8 00 00 	restore                                        
                                                                      

40009904 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) {
40009904:	9d e3 bf 90 	save  %sp, -112, %sp                           
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
40009908:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
4000990c:	a4 14 a2 2c 	or  %l2, 0x22c, %l2	! 4001662c <_Per_CPU_Information>
  _ISR_Disable( level );                                              
40009910:	7f ff e1 50 	call  40001e50 <sparc_disable_interrupts>      
40009914:	e2 04 a0 0c 	ld  [ %l2 + 0xc ], %l1                         
  while ( _Thread_Dispatch_necessary == true ) {                      
40009918:	c2 0c a0 18 	ldub  [ %l2 + 0x18 ], %g1                      
4000991c:	80 a0 60 00 	cmp  %g1, 0                                    
40009920:	02 80 00 42 	be  40009a28 <_Thread_Dispatch+0x124>          
40009924:	2d 10 00 59 	sethi  %hi(0x40016400), %l6                    
    heir = _Thread_Heir;                                              
40009928:	e0 04 a0 10 	ld  [ %l2 + 0x10 ], %l0                        
    _Thread_Dispatch_disable_level = 1;                               
4000992c:	82 10 20 01 	mov  1, %g1                                    
40009930:	c2 25 a0 00 	st  %g1, [ %l6 ]                               
    _Thread_Dispatch_necessary = false;                               
40009934:	c0 2c a0 18 	clrb  [ %l2 + 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 )                                          
40009938:	80 a4 40 10 	cmp  %l1, %l0                                  
4000993c:	02 80 00 3b 	be  40009a28 <_Thread_Dispatch+0x124>          
40009940:	e0 24 a0 0c 	st  %l0, [ %l2 + 0xc ]                         
40009944:	27 10 00 59 	sethi  %hi(0x40016400), %l3                    
40009948:	3b 10 00 59 	sethi  %hi(0x40016400), %i5                    
4000994c:	a6 14 e0 ac 	or  %l3, 0xac, %l3                             
40009950:	aa 07 bf f8 	add  %fp, -8, %l5                              
40009954:	a8 07 bf f0 	add  %fp, -16, %l4                             
40009958:	ba 17 60 84 	or  %i5, 0x84, %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;            
4000995c:	37 10 00 58 	sethi  %hi(0x40016000), %i3                    
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
        _Timestamp_Subtract(                                          
40009960:	ae 10 00 13 	mov  %l3, %l7                                  
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
40009964:	10 80 00 2b 	b  40009a10 <_Thread_Dispatch+0x10c>           
40009968:	b8 10 20 01 	mov  1, %i4                                    
    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;            
                                                                      
    _ISR_Enable( level );                                             
4000996c:	7f ff e1 3d 	call  40001e60 <sparc_enable_interrupts>       
40009970:	01 00 00 00 	nop                                            
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
40009974:	40 00 0d de 	call  4000d0ec <_TOD_Get_uptime>               
40009978:	90 10 00 15 	mov  %l5, %o0                                  
        _Timestamp_Subtract(                                          
4000997c:	90 10 00 17 	mov  %l7, %o0                                  
40009980:	92 10 00 15 	mov  %l5, %o1                                  
40009984:	40 00 03 17 	call  4000a5e0 <_Timespec_Subtract>            
40009988:	94 10 00 14 	mov  %l4, %o2                                  
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
4000998c:	92 10 00 14 	mov  %l4, %o1                                  
40009990:	40 00 02 fb 	call  4000a57c <_Timespec_Add_to>              
40009994:	90 04 60 84 	add  %l1, 0x84, %o0                            
        _Thread_Time_of_last_context_switch = uptime;                 
40009998:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
4000999c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
        _Thread_Time_of_last_context_switch = uptime;                 
400099a0:	c4 24 c0 00 	st  %g2, [ %l3 ]                               
400099a4:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    if ( _Thread_libc_reent ) {                                       
      executing->libc_reent = *_Thread_libc_reent;                    
      *_Thread_libc_reent = heir->libc_reent;                         
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
400099a8:	90 10 00 11 	mov  %l1, %o0                                  
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
        _Thread_Time_of_last_context_switch = uptime;                 
400099ac:	c4 24 e0 04 	st  %g2, [ %l3 + 4 ]                           
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
400099b0:	80 a0 60 00 	cmp  %g1, 0                                    
400099b4:	02 80 00 06 	be  400099cc <_Thread_Dispatch+0xc8>           <== NEVER TAKEN
400099b8:	92 10 00 10 	mov  %l0, %o1                                  
      executing->libc_reent = *_Thread_libc_reent;                    
400099bc:	c4 00 40 00 	ld  [ %g1 ], %g2                               
400099c0:	c4 24 61 48 	st  %g2, [ %l1 + 0x148 ]                       
      *_Thread_libc_reent = heir->libc_reent;                         
400099c4:	c4 04 21 48 	ld  [ %l0 + 0x148 ], %g2                       
400099c8:	c4 20 40 00 	st  %g2, [ %g1 ]                               
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
400099cc:	40 00 03 c9 	call  4000a8f0 <_User_extensions_Thread_switch>
400099d0:	01 00 00 00 	nop                                            
    if ( executing->fp_context != NULL )                              
      _Context_Save_fp( &executing->fp_context );                     
#endif                                                                
#endif                                                                
                                                                      
    _Context_Switch( &executing->Registers, &heir->Registers );       
400099d4:	90 04 60 c0 	add  %l1, 0xc0, %o0                            
400099d8:	40 00 04 de 	call  4000ad50 <_CPU_Context_switch>           
400099dc:	92 04 20 c0 	add  %l0, 0xc0, %o1                            
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
                                                                      
    _ISR_Disable( level );                                            
400099e0:	7f ff e1 1c 	call  40001e50 <sparc_disable_interrupts>      
400099e4:	e2 04 a0 0c 	ld  [ %l2 + 0xc ], %l1                         
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
400099e8:	c2 0c a0 18 	ldub  [ %l2 + 0x18 ], %g1                      
400099ec:	80 a0 60 00 	cmp  %g1, 0                                    
400099f0:	02 80 00 0e 	be  40009a28 <_Thread_Dispatch+0x124>          
400099f4:	01 00 00 00 	nop                                            
    heir = _Thread_Heir;                                              
400099f8:	e0 04 a0 10 	ld  [ %l2 + 0x10 ], %l0                        
    _Thread_Dispatch_disable_level = 1;                               
400099fc:	f8 25 a0 00 	st  %i4, [ %l6 ]                               
    _Thread_Dispatch_necessary = false;                               
40009a00:	c0 2c a0 18 	clrb  [ %l2 + 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 )                                          
40009a04:	80 a4 00 11 	cmp  %l0, %l1                                  
40009a08:	02 80 00 08 	be  40009a28 <_Thread_Dispatch+0x124>          <== NEVER TAKEN
40009a0c:	e0 24 a0 0c 	st  %l0, [ %l2 + 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 )
40009a10:	c2 04 20 7c 	ld  [ %l0 + 0x7c ], %g1                        
40009a14:	80 a0 60 01 	cmp  %g1, 1                                    
40009a18:	12 bf ff d5 	bne  4000996c <_Thread_Dispatch+0x68>          
40009a1c:	c2 06 e3 64 	ld  [ %i3 + 0x364 ], %g1                       
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
40009a20:	10 bf ff d3 	b  4000996c <_Thread_Dispatch+0x68>            
40009a24:	c2 24 20 78 	st  %g1, [ %l0 + 0x78 ]                        
                                                                      
    _ISR_Disable( level );                                            
  }                                                                   
                                                                      
post_switch:                                                          
  _Thread_Dispatch_disable_level = 0;                                 
40009a28:	c0 25 a0 00 	clr  [ %l6 ]                                   
                                                                      
  _ISR_Enable( level );                                               
40009a2c:	7f ff e1 0d 	call  40001e60 <sparc_enable_interrupts>       
40009a30:	01 00 00 00 	nop                                            
                                                                      
  _API_extensions_Run_postswitch();                                   
40009a34:	7f ff f8 1e 	call  40007aac <_API_extensions_Run_postswitch>
40009a38:	01 00 00 00 	nop                                            
}                                                                     
40009a3c:	81 c7 e0 08 	ret                                            
40009a40:	81 e8 00 00 	restore                                        
                                                                      

4000ef88 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) {
4000ef88:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static char doneConstructors;                                     
    char doneCons;                                                    
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
4000ef8c:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
4000ef90:	e0 00 62 38 	ld  [ %g1 + 0x238 ], %l0	! 40016638 <_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();                          
4000ef94:	3f 10 00 3b 	sethi  %hi(0x4000ec00), %i7                    
4000ef98:	be 17 e3 88 	or  %i7, 0x388, %i7	! 4000ef88 <_Thread_Handler>
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
                                                                      
  level = executing->Start.isr_level;                                 
4000ef9c:	d0 04 20 ac 	ld  [ %l0 + 0xac ], %o0                        
  _ISR_Set_level(level);                                              
4000efa0:	7f ff cb b0 	call  40001e60 <sparc_enable_interrupts>       
4000efa4:	91 2a 20 08 	sll  %o0, 8, %o0                               
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
4000efa8:	03 10 00 58 	sethi  %hi(0x40016000), %g1                    
    doneConstructors = 1;                                             
4000efac:	84 10 20 01 	mov  1, %g2                                    
                                                                      
  level = executing->Start.isr_level;                                 
  _ISR_Set_level(level);                                              
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
4000efb0:	e2 08 60 8c 	ldub  [ %g1 + 0x8c ], %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 );                         
4000efb4:	90 10 00 10 	mov  %l0, %o0                                  
4000efb8:	7f ff ed ce 	call  4000a6f0 <_User_extensions_Thread_begin> 
4000efbc:	c4 28 60 8c 	stb  %g2, [ %g1 + 0x8c ]                       
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
4000efc0:	7f ff ea a1 	call  40009a44 <_Thread_Enable_dispatch>       
4000efc4:	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) */ {                 
4000efc8:	80 a4 60 00 	cmp  %l1, 0                                    
4000efcc:	02 80 00 0c 	be  4000effc <_Thread_Handler+0x74>            
4000efd0:	01 00 00 00 	nop                                            
      INIT_NAME ();                                                   
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
4000efd4:	c2 04 20 94 	ld  [ %l0 + 0x94 ], %g1                        
4000efd8:	80 a0 60 00 	cmp  %g1, 0                                    
4000efdc:	22 80 00 0f 	be,a   4000f018 <_Thread_Handler+0x90>         <== ALWAYS TAKEN
4000efe0:	c2 04 20 90 	ld  [ %l0 + 0x90 ], %g1                        
   *  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 );                       
4000efe4:	7f ff ed d7 	call  4000a740 <_User_extensions_Thread_exitted>
4000efe8:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  _Internal_error_Occurred(                                           
4000efec:	90 10 20 00 	clr  %o0                                       
4000eff0:	92 10 20 01 	mov  1, %o1                                    
4000eff4:	7f ff e5 80 	call  400085f4 <_Internal_error_Occurred>      
4000eff8:	94 10 20 05 	mov  5, %o2                                    
     *  _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) */ {                 
      INIT_NAME ();                                                   
4000effc:	40 00 1a 1b 	call  40015868 <_init>                         
4000f000:	01 00 00 00 	nop                                            
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
4000f004:	c2 04 20 94 	ld  [ %l0 + 0x94 ], %g1                        
4000f008:	80 a0 60 00 	cmp  %g1, 0                                    
4000f00c:	12 bf ff f6 	bne  4000efe4 <_Thread_Handler+0x5c>           <== NEVER TAKEN
4000f010:	01 00 00 00 	nop                                            
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
4000f014:	c2 04 20 90 	ld  [ %l0 + 0x90 ], %g1                        
4000f018:	9f c0 40 00 	call  %g1                                      
4000f01c:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
      INIT_NAME ();                                                   
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
    executing->Wait.return_argument =                                 
4000f020:	10 bf ff f1 	b  4000efe4 <_Thread_Handler+0x5c>             
4000f024:	d0 24 20 28 	st  %o0, [ %l0 + 0x28 ]                        
                                                                      

40009b28 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) {
40009b28:	9d e3 bf a0 	save  %sp, -96, %sp                            
40009b2c:	c2 07 a0 6c 	ld  [ %fp + 0x6c ], %g1                        
40009b30:	e0 0f a0 5f 	ldub  [ %fp + 0x5f ], %l0                      
40009b34:	e2 00 40 00 	ld  [ %g1 ], %l1                               
                                                                      
  /*                                                                  
   *  Zero out all the allocated memory fields                        
   */                                                                 
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    the_thread->API_Extensions[i] = NULL;                             
40009b38:	c0 26 61 4c 	clr  [ %i1 + 0x14c ]                           
40009b3c:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
40009b40:	c0 26 61 48 	clr  [ %i1 + 0x148 ]                           
                                                                      
  /*                                                                  
   *  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 );
40009b44:	90 10 00 19 	mov  %i1, %o0                                  
40009b48:	40 00 02 25 	call  4000a3dc <_Thread_Stack_Allocate>        
40009b4c:	92 10 00 1b 	mov  %i3, %o1                                  
    if ( !actual_stack_size || actual_stack_size < stack_size )       
40009b50:	80 a2 00 1b 	cmp  %o0, %i3                                  
40009b54:	0a 80 00 43 	bcs  40009c60 <_Thread_Initialize+0x138>       
40009b58:	80 a2 20 00 	cmp  %o0, 0                                    
40009b5c:	02 80 00 41 	be  40009c60 <_Thread_Initialize+0x138>        <== NEVER TAKEN
40009b60:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
40009b64:	c4 06 60 bc 	ld  [ %i1 + 0xbc ], %g2                        
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
40009b68:	c2 04 a0 90 	ld  [ %l2 + 0x90 ], %g1                        
40009b6c:	c4 26 60 b8 	st  %g2, [ %i1 + 0xb8 ]                        
  the_stack->size = size;                                             
40009b70:	d0 26 60 b4 	st  %o0, [ %i1 + 0xb4 ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40009b74:	c0 26 60 50 	clr  [ %i1 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
40009b78:	c0 26 60 64 	clr  [ %i1 + 0x64 ]                            
  the_watchdog->id        = id;                                       
40009b7c:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
40009b80:	80 a0 60 00 	cmp  %g1, 0                                    
40009b84:	12 80 00 39 	bne  40009c68 <_Thread_Initialize+0x140>       
40009b88:	c0 26 60 6c 	clr  [ %i1 + 0x6c ]                            
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
40009b8c:	c0 26 61 54 	clr  [ %i1 + 0x154 ]                           
   *  Zero out all the allocated memory fields                        
   */                                                                 
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    the_thread->API_Extensions[i] = NULL;                             
                                                                      
  extensions_area = NULL;                                             
40009b90:	b6 10 20 00 	clr  %i3                                       
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
40009b94:	c4 07 a0 60 	ld  [ %fp + 0x60 ], %g2                        
 */                                                                   
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.allocate( the_thread );                
40009b98:	03 10 00 56 	sethi  %hi(0x40015800), %g1                    
40009b9c:	c4 26 60 a4 	st  %g2, [ %i1 + 0xa4 ]                        
  the_thread->Start.budget_callout   = budget_callout;                
40009ba0:	c4 07 a0 64 	ld  [ %fp + 0x64 ], %g2                        
40009ba4:	c2 00 60 d8 	ld  [ %g1 + 0xd8 ], %g1                        
40009ba8:	c4 26 60 a8 	st  %g2, [ %i1 + 0xa8 ]                        
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
40009bac:	c4 07 a0 68 	ld  [ %fp + 0x68 ], %g2                        
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
40009bb0:	e0 2e 60 a0 	stb  %l0, [ %i1 + 0xa0 ]                       
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
40009bb4:	c4 26 60 ac 	st  %g2, [ %i1 + 0xac ]                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
40009bb8:	84 10 20 01 	mov  1, %g2                                    
  the_thread->Wait.queue              = NULL;                         
40009bbc:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
40009bc0:	c4 26 60 10 	st  %g2, [ %i1 + 0x10 ]                        
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
40009bc4:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  the_thread->real_priority           = priority;                     
40009bc8:	fa 26 60 18 	st  %i5, [ %i1 + 0x18 ]                        
  the_thread->Start.initial_priority  = priority;                     
40009bcc:	fa 26 60 b0 	st  %i5, [ %i1 + 0xb0 ]                        
40009bd0:	9f c0 40 00 	call  %g1                                      
40009bd4:	90 10 00 19 	mov  %i1, %o0                                  
  sched =_Scheduler_Allocate( the_thread );                           
  if ( !sched )                                                       
40009bd8:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40009bdc:	22 80 00 13 	be,a   40009c28 <_Thread_Initialize+0x100>     
40009be0:	d0 06 61 48 	ld  [ %i1 + 0x148 ], %o0                       
    goto failed;                                                      
  _Thread_Set_priority( the_thread, priority );                       
40009be4:	90 10 00 19 	mov  %i1, %o0                                  
40009be8:	40 00 01 d2 	call  4000a330 <_Thread_Set_priority>          
40009bec:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
   _Workspace_Free( sched );                                          
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
}                                                                     
40009bf0:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40009bf4:	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 );             
40009bf8:	c0 26 60 84 	clr  [ %i1 + 0x84 ]                            
40009bfc:	c0 26 60 88 	clr  [ %i1 + 0x88 ]                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40009c00:	83 28 60 02 	sll  %g1, 2, %g1                               
40009c04:	f2 20 80 01 	st  %i1, [ %g2 + %g1 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
40009c08:	e2 26 60 0c 	st  %l1, [ %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 );    
40009c0c:	90 10 00 19 	mov  %i1, %o0                                  
40009c10:	40 00 02 f3 	call  4000a7dc <_User_extensions_Thread_create>
40009c14:	b0 10 20 01 	mov  1, %i0                                    
  if ( extension_status )                                             
40009c18:	80 8a 20 ff 	btst  0xff, %o0                                
40009c1c:	12 80 00 24 	bne  40009cac <_Thread_Initialize+0x184>       
40009c20:	01 00 00 00 	nop                                            
    return true;                                                      
                                                                      
failed:                                                               
  _Workspace_Free( the_thread->libc_reent );                          
40009c24:	d0 06 61 48 	ld  [ %i1 + 0x148 ], %o0                       
40009c28:	40 00 04 34 	call  4000acf8 <_Workspace_Free>               
40009c2c:	b0 10 20 00 	clr  %i0                                       
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    _Workspace_Free( the_thread->API_Extensions[i] );                 
40009c30:	40 00 04 32 	call  4000acf8 <_Workspace_Free>               
40009c34:	d0 06 61 4c 	ld  [ %i1 + 0x14c ], %o0                       
40009c38:	40 00 04 30 	call  4000acf8 <_Workspace_Free>               
40009c3c:	d0 06 61 50 	ld  [ %i1 + 0x150 ], %o0                       
                                                                      
  _Workspace_Free( extensions_area );                                 
40009c40:	40 00 04 2e 	call  4000acf8 <_Workspace_Free>               
40009c44:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    _Workspace_Free( fp_area );                                       
  #endif                                                              
                                                                      
   _Workspace_Free( sched );                                          
40009c48:	40 00 04 2c 	call  4000acf8 <_Workspace_Free>               
40009c4c:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
   _Thread_Stack_Free( the_thread );                                  
40009c50:	40 00 01 fe 	call  4000a448 <_Thread_Stack_Free>            
40009c54:	90 10 00 19 	mov  %i1, %o0                                  
  return false;                                                       
40009c58:	81 c7 e0 08 	ret                                            
40009c5c:	81 e8 00 00 	restore                                        
}                                                                     
40009c60:	81 c7 e0 08 	ret                                            
40009c64:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
    extensions_area = _Workspace_Allocate(                            
40009c68:	82 00 60 01 	inc  %g1                                       
40009c6c:	40 00 04 1a 	call  4000acd4 <_Workspace_Allocate>           
40009c70:	91 28 60 02 	sll  %g1, 2, %o0                               
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
40009c74:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40009c78:	02 80 00 0f 	be  40009cb4 <_Thread_Initialize+0x18c>        
40009c7c:	c6 04 a0 90 	ld  [ %l2 + 0x90 ], %g3                        
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
40009c80:	f6 26 61 54 	st  %i3, [ %i1 + 0x154 ]                       
   * 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++ )              
40009c84:	84 10 20 00 	clr  %g2                                       
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
40009c88:	82 10 20 00 	clr  %g1                                       
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
      the_thread->extensions[i] = NULL;                               
40009c8c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009c90:	c0 26 c0 02 	clr  [ %i3 + %g2 ]                             
   * 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++ )              
40009c94:	82 00 60 01 	inc  %g1                                       
40009c98:	80 a0 40 03 	cmp  %g1, %g3                                  
40009c9c:	08 bf ff fc 	bleu  40009c8c <_Thread_Initialize+0x164>      
40009ca0:	84 10 00 01 	mov  %g1, %g2                                  
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
40009ca4:	10 bf ff bd 	b  40009b98 <_Thread_Initialize+0x70>          
40009ca8:	c4 07 a0 60 	ld  [ %fp + 0x60 ], %g2                        
40009cac:	81 c7 e0 08 	ret                                            
40009cb0:	81 e8 00 00 	restore                                        
  size_t               actual_stack_size = 0;                         
  void                *stack = NULL;                                  
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    void              *fp_area;                                       
  #endif                                                              
  void                *sched = NULL;                                  
40009cb4:	10 bf ff dc 	b  40009c24 <_Thread_Initialize+0xfc>          
40009cb8:	a0 10 20 00 	clr  %l0                                       
                                                                      

4000df1c <_Thread_Resume>: */ void _Thread_Resume( Thread_Control *the_thread, bool force ) {
4000df1c:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
4000df20:	7f ff d0 00 	call  40001f20 <sparc_disable_interrupts>      
4000df24:	01 00 00 00 	nop                                            
4000df28:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
  current_state = the_thread->current_state;                          
4000df2c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
  if ( current_state & STATES_SUSPENDED ) {                           
4000df30:	80 88 60 02 	btst  2, %g1                                   
4000df34:	02 80 00 05 	be  4000df48 <_Thread_Resume+0x2c>             <== NEVER TAKEN
4000df38:	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 ) ) {                        
4000df3c:	80 a0 60 00 	cmp  %g1, 0                                    
4000df40:	02 80 00 04 	be  4000df50 <_Thread_Resume+0x34>             
4000df44:	c2 26 20 10 	st  %g1, [ %i0 + 0x10 ]                        
      _Scheduler_Unblock( the_thread );                               
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000df48:	7f ff cf fa 	call  40001f30 <sparc_enable_interrupts>       
4000df4c:	91 e8 00 10 	restore  %g0, %l0, %o0                         
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(                         
    Thread_Control    *the_thread                                     
)                                                                     
{                                                                     
  _Scheduler.Operations.unblock( the_thread );                        
4000df50:	03 10 00 66 	sethi  %hi(0x40019800), %g1                    
4000df54:	c2 00 63 74 	ld  [ %g1 + 0x374 ], %g1	! 40019b74 <_Scheduler+0x14>
4000df58:	9f c0 40 00 	call  %g1                                      
4000df5c:	90 10 00 18 	mov  %i0, %o0                                  
4000df60:	7f ff cf f4 	call  40001f30 <sparc_enable_interrupts>       
4000df64:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

4000a270 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
4000a270:	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 )                                            
4000a274:	80 a6 20 00 	cmp  %i0, 0                                    
4000a278:	02 80 00 13 	be  4000a2c4 <_Thread_queue_Requeue+0x54>      <== NEVER TAKEN
4000a27c:	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 ) {
4000a280:	e2 06 20 34 	ld  [ %i0 + 0x34 ], %l1                        
4000a284:	80 a4 60 01 	cmp  %l1, 1                                    
4000a288:	02 80 00 04 	be  4000a298 <_Thread_queue_Requeue+0x28>      <== ALWAYS TAKEN
4000a28c:	01 00 00 00 	nop                                            
4000a290:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000a294:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
4000a298:	7f ff de ee 	call  40001e50 <sparc_disable_interrupts>      
4000a29c:	01 00 00 00 	nop                                            
4000a2a0:	a0 10 00 08 	mov  %o0, %l0                                  
4000a2a4:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
4000a2a8:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
4000a2ac:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000a2b0:	80 88 80 01 	btst  %g2, %g1                                 
4000a2b4:	12 80 00 06 	bne  4000a2cc <_Thread_queue_Requeue+0x5c>     <== ALWAYS TAKEN
4000a2b8:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
    }                                                                 
    _ISR_Enable( level );                                             
4000a2bc:	7f ff de e9 	call  40001e60 <sparc_enable_interrupts>       
4000a2c0:	90 10 00 10 	mov  %l0, %o0                                  
4000a2c4:	81 c7 e0 08 	ret                                            
4000a2c8:	81 e8 00 00 	restore                                        
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
4000a2cc:	92 10 00 19 	mov  %i1, %o1                                  
4000a2d0:	94 10 20 01 	mov  1, %o2                                    
4000a2d4:	40 00 0c fc 	call  4000d6c4 <_Thread_queue_Extract_priority_helper>
4000a2d8:	e2 26 20 30 	st  %l1, [ %i0 + 0x30 ]                        
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000a2dc:	90 10 00 18 	mov  %i0, %o0                                  
4000a2e0:	92 10 00 19 	mov  %i1, %o1                                  
4000a2e4:	7f ff ff 31 	call  40009fa8 <_Thread_queue_Enqueue_priority>
4000a2e8:	94 07 bf fc 	add  %fp, -4, %o2                              
4000a2ec:	30 bf ff f4 	b,a   4000a2bc <_Thread_queue_Requeue+0x4c>    
                                                                      

4000a2f0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) {
4000a2f0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000a2f4:	90 10 00 18 	mov  %i0, %o0                                  
4000a2f8:	7f ff fd e1 	call  40009a7c <_Thread_Get>                   
4000a2fc:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000a300:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000a304:	80 a0 60 00 	cmp  %g1, 0                                    
4000a308:	12 80 00 08 	bne  4000a328 <_Thread_queue_Timeout+0x38>     <== NEVER TAKEN
4000a30c:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
4000a310:	40 00 0d 28 	call  4000d7b0 <_Thread_queue_Process_timeout> 
4000a314:	01 00 00 00 	nop                                            
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
4000a318:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
4000a31c:	c4 00 60 00 	ld  [ %g1 ], %g2                               
4000a320:	84 00 bf ff 	add  %g2, -1, %g2                              
4000a324:	c4 20 60 00 	st  %g2, [ %g1 ]                               
4000a328:	81 c7 e0 08 	ret                                            
4000a32c:	81 e8 00 00 	restore                                        
                                                                      

40017488 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) {
40017488:	9d e3 bf 88 	save  %sp, -120, %sp                           
4001748c:	2f 10 00 fb 	sethi  %hi(0x4003ec00), %l7                    
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40017490:	ba 07 bf f4 	add  %fp, -12, %i5                             
40017494:	aa 07 bf f8 	add  %fp, -8, %l5                              
40017498:	a4 07 bf e8 	add  %fp, -24, %l2                             
4001749c:	a8 07 bf ec 	add  %fp, -20, %l4                             
400174a0:	2d 10 00 fb 	sethi  %hi(0x4003ec00), %l6                    
400174a4:	39 10 00 fb 	sethi  %hi(0x4003ec00), %i4                    
400174a8:	ea 27 bf f4 	st  %l5, [ %fp + -12 ]                         
  head->previous = NULL;                                              
400174ac:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  tail->previous = head;                                              
400174b0:	fa 27 bf fc 	st  %i5, [ %fp + -4 ]                          
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400174b4:	e8 27 bf e8 	st  %l4, [ %fp + -24 ]                         
  head->previous = NULL;                                              
400174b8:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
400174bc:	e4 27 bf f0 	st  %l2, [ %fp + -16 ]                         
400174c0:	ae 15 e3 90 	or  %l7, 0x390, %l7                            
400174c4:	a2 06 20 30 	add  %i0, 0x30, %l1                            
400174c8:	ac 15 a3 08 	or  %l6, 0x308, %l6                            
400174cc:	a6 06 20 68 	add  %i0, 0x68, %l3                            
400174d0:	b8 17 22 80 	or  %i4, 0x280, %i4                            
400174d4:	b4 06 20 08 	add  %i0, 8, %i2                               
400174d8:	b6 06 20 40 	add  %i0, 0x40, %i3                            
  Chain_Control *tmp;                                                 
  /*                                                                  
   *  Afterwards all timer inserts are directed to this chain and the interval
   *  and TOD chains will be no more modified by other parties.       
   */                                                                 
  ts->insert_chain = insert_chain;                                    
400174dc:	fa 26 20 78 	st  %i5, [ %i0 + 0x78 ]                        
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
400174e0:	c2 05 c0 00 	ld  [ %l7 ], %g1                               
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
400174e4:	d2 06 20 3c 	ld  [ %i0 + 0x3c ], %o1                        
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
400174e8:	94 10 00 12 	mov  %l2, %o2                                  
400174ec:	90 10 00 11 	mov  %l1, %o0                                  
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
400174f0:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
400174f4:	40 00 12 a3 	call  4001bf80 <_Watchdog_Adjust_to_chain>     
400174f8:	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;         
400174fc:	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();
40017500:	e0 05 80 00 	ld  [ %l6 ], %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 ) {                                   
40017504:	80 a4 00 0a 	cmp  %l0, %o2                                  
40017508:	18 80 00 43 	bgu  40017614 <_Timer_server_Body+0x18c>       
4001750c:	92 24 00 0a 	sub  %l0, %o2, %o1                             
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
40017510:	0a 80 00 39 	bcs  400175f4 <_Timer_server_Body+0x16c>       
40017514:	90 10 00 13 	mov  %l3, %o0                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
40017518:	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 );
4001751c:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
40017520:	40 00 02 f4 	call  400180f0 <_Chain_Get>                    
40017524:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
40017528:	92 92 20 00 	orcc  %o0, 0, %o1                              
4001752c:	02 80 00 10 	be  4001756c <_Timer_server_Body+0xe4>         
40017530:	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 ) {                 
40017534:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        
40017538:	80 a0 60 01 	cmp  %g1, 1                                    
4001753c:	02 80 00 32 	be  40017604 <_Timer_server_Body+0x17c>        
40017540:	80 a0 60 03 	cmp  %g1, 3                                    
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
40017544:	12 bf ff f6 	bne  4001751c <_Timer_server_Body+0x94>        <== NEVER TAKEN
40017548:	92 02 60 10 	add  %o1, 0x10, %o1                            
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
4001754c:	40 00 12 c0 	call  4001c04c <_Watchdog_Insert>              
40017550:	90 10 00 13 	mov  %l3, %o0                                  
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
40017554:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
40017558:	40 00 02 e6 	call  400180f0 <_Chain_Get>                    
4001755c:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
40017560:	92 92 20 00 	orcc  %o0, 0, %o1                              
40017564:	32 bf ff f5 	bne,a   40017538 <_Timer_server_Body+0xb0>     <== NEVER TAKEN
40017568:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        <== NOT EXECUTED
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
4001756c:	7f ff de 52 	call  4000eeb4 <sparc_disable_interrupts>      
40017570:	01 00 00 00 	nop                                            
      tmp = ts->insert_chain;                                         
40017574:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
      if ( _Chain_Is_empty( insert_chain ) ) {                        
40017578:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
4001757c:	80 a0 40 15 	cmp  %g1, %l5                                  
40017580:	02 80 00 29 	be  40017624 <_Timer_server_Body+0x19c>        <== ALWAYS TAKEN
40017584:	a0 10 20 01 	mov  1, %l0                                    
        ts->insert_chain = NULL;                                      
        do_loop          = false;                                     
      }                                                               
    _ISR_Enable( level );                                             
40017588:	7f ff de 4f 	call  4000eec4 <sparc_enable_interrupts>       
4001758c:	01 00 00 00 	nop                                            
   *  Afterwards all timer inserts are directed to this chain and the interval
   *  and TOD chains will be no more modified by other parties.       
   */                                                                 
  ts->insert_chain = insert_chain;                                    
                                                                      
  while ( do_loop ) {                                                 
40017590:	80 8c 20 ff 	btst  0xff, %l0                                
40017594:	12 bf ff d3 	bne  400174e0 <_Timer_server_Body+0x58>        <== NEVER TAKEN
40017598:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
  _Chain_Initialize_empty( &fire_chain );                             
                                                                      
  while ( true ) {                                                    
    _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
                                                                      
    if ( !_Chain_Is_empty( &fire_chain ) ) {                          
4001759c:	80 a0 40 14 	cmp  %g1, %l4                                  
400175a0:	12 80 00 0c 	bne  400175d0 <_Timer_server_Body+0x148>       
400175a4:	01 00 00 00 	nop                                            
400175a8:	30 80 00 22 	b,a   40017630 <_Timer_server_Body+0x1a8>      
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
                                                                      
  head->next = new_first;                                             
  new_first->previous = head;                                         
400175ac:	e4 20 60 04 	st  %l2, [ %g1 + 4 ]                           
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
                                                                      
  head->next = new_first;                                             
400175b0:	c2 27 bf e8 	st  %g1, [ %fp + -24 ]                         
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
400175b4:	c0 24 20 08 	clr  [ %l0 + 8 ]                               
          _ISR_Enable( level );                                       
400175b8:	7f ff de 43 	call  4000eec4 <sparc_enable_interrupts>       
400175bc:	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 );    
400175c0:	d0 04 20 20 	ld  [ %l0 + 0x20 ], %o0                        
400175c4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
400175c8:	9f c0 40 00 	call  %g1                                      
400175cc:	d2 04 20 24 	ld  [ %l0 + 0x24 ], %o1                        
                                                                      
        /*                                                            
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
400175d0:	7f ff de 39 	call  4000eeb4 <sparc_disable_interrupts>      
400175d4:	01 00 00 00 	nop                                            
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
400175d8:	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))                                   
400175dc:	80 a4 00 14 	cmp  %l0, %l4                                  
400175e0:	32 bf ff f3 	bne,a   400175ac <_Timer_server_Body+0x124>    
400175e4:	c2 04 00 00 	ld  [ %l0 ], %g1                               
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
          _ISR_Enable( level );                                       
        } else {                                                      
          _ISR_Enable( level );                                       
400175e8:	7f ff de 37 	call  4000eec4 <sparc_enable_interrupts>       
400175ec:	01 00 00 00 	nop                                            
400175f0:	30 bf ff bb 	b,a   400174dc <_Timer_server_Body+0x54>       
     /*                                                               
      *  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 ); 
400175f4:	92 10 20 01 	mov  1, %o1	! 1 <PROM_START+0x1>               
400175f8:	40 00 12 32 	call  4001bec0 <_Watchdog_Adjust>              
400175fc:	94 22 80 10 	sub  %o2, %l0, %o2                             
40017600:	30 bf ff c6 	b,a   40017518 <_Timer_server_Body+0x90>       
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
40017604:	90 10 00 11 	mov  %l1, %o0                                  
40017608:	40 00 12 91 	call  4001c04c <_Watchdog_Insert>              
4001760c:	92 02 60 10 	add  %o1, 0x10, %o1                            
40017610:	30 bf ff c3 	b,a   4001751c <_Timer_server_Body+0x94>       
    /*                                                                
     *  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 );
40017614:	90 10 00 13 	mov  %l3, %o0                                  
40017618:	40 00 12 5a 	call  4001bf80 <_Watchdog_Adjust_to_chain>     
4001761c:	94 10 00 12 	mov  %l2, %o2                                  
40017620:	30 bf ff be 	b,a   40017518 <_Timer_server_Body+0x90>       
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
      tmp = ts->insert_chain;                                         
      if ( _Chain_Is_empty( insert_chain ) ) {                        
        ts->insert_chain = NULL;                                      
40017624:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
        do_loop          = false;                                     
40017628:	10 bf ff d8 	b  40017588 <_Timer_server_Body+0x100>         
4001762c:	a0 10 20 00 	clr  %l0                                       
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
40017630:	c0 2e 20 7c 	clrb  [ %i0 + 0x7c ]                           
40017634:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40017638:	82 00 60 01 	inc  %g1                                       
4001763c:	c2 27 00 00 	st  %g1, [ %i4 ]                               
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
40017640:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40017644:	40 00 10 58 	call  4001b7a4 <_Thread_Set_state>             
40017648:	92 10 20 08 	mov  8, %o1                                    
        _Timer_server_Reset_interval_system_watchdog( ts );           
4001764c:	7f ff ff 65 	call  400173e0 <_Timer_server_Reset_interval_system_watchdog>
40017650:	90 10 00 18 	mov  %i0, %o0                                  
        _Timer_server_Reset_tod_system_watchdog( ts );                
40017654:	7f ff ff 78 	call  40017434 <_Timer_server_Reset_tod_system_watchdog>
40017658:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_Enable_dispatch();                                      
4001765c:	40 00 0d e0 	call  4001addc <_Thread_Enable_dispatch>       
40017660:	01 00 00 00 	nop                                            
                                                                      
      ts->active = true;                                              
40017664:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40017668:	90 10 00 1a 	mov  %i2, %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;                                              
4001766c:	c2 2e 20 7c 	stb  %g1, [ %i0 + 0x7c ]                       
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40017670:	40 00 12 e2 	call  4001c1f8 <_Watchdog_Remove>              
40017674:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
40017678:	40 00 12 e0 	call  4001c1f8 <_Watchdog_Remove>              
4001767c:	90 10 00 1b 	mov  %i3, %o0                                  
40017680:	30 bf ff 97 	b,a   400174dc <_Timer_server_Body+0x54>       
                                                                      

40017684 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) {
40017684:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( ts->insert_chain == NULL ) {                                   
40017688:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
4001768c:	80 a0 60 00 	cmp  %g1, 0                                    
40017690:	02 80 00 05 	be  400176a4 <_Timer_server_Schedule_operation_method+0x20>
40017694:	a0 10 00 19 	mov  %i1, %l0                                  
     *  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 );           
40017698:	f0 06 20 78 	ld  [ %i0 + 0x78 ], %i0                        
4001769c:	40 00 02 7f 	call  40018098 <_Chain_Append>                 
400176a0:	81 e8 00 00 	restore                                        
400176a4:	03 10 00 fb 	sethi  %hi(0x4003ec00), %g1                    
400176a8:	c4 00 62 80 	ld  [ %g1 + 0x280 ], %g2	! 4003ee80 <_Thread_Dispatch_disable_level>
400176ac:	84 00 a0 01 	inc  %g2                                       
400176b0:	c4 20 62 80 	st  %g2, [ %g1 + 0x280 ]                       
   *  being inserted.  This could result in an integer overflow.      
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
400176b4:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
400176b8:	80 a0 60 01 	cmp  %g1, 1                                    
400176bc:	02 80 00 28 	be  4001775c <_Timer_server_Schedule_operation_method+0xd8>
400176c0:	80 a0 60 03 	cmp  %g1, 3                                    
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
                                                                      
    if ( !ts->active ) {                                              
      _Timer_server_Reset_interval_system_watchdog( ts );             
    }                                                                 
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
400176c4:	02 80 00 04 	be  400176d4 <_Timer_server_Schedule_operation_method+0x50>
400176c8:	01 00 00 00 	nop                                            
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
400176cc:	40 00 0d c4 	call  4001addc <_Thread_Enable_dispatch>       
400176d0:	81 e8 00 00 	restore                                        
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
    /*                                                                
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
400176d4:	7f ff dd f8 	call  4000eeb4 <sparc_disable_interrupts>      
400176d8:	01 00 00 00 	nop                                            
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
400176dc:	c4 06 20 68 	ld  [ %i0 + 0x68 ], %g2                        
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
400176e0:	c6 06 20 74 	ld  [ %i0 + 0x74 ], %g3                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
400176e4:	88 06 20 6c 	add  %i0, 0x6c, %g4                            
    /*                                                                
     *  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();        
400176e8:	03 10 00 fb 	sethi  %hi(0x4003ec00), %g1                    
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
400176ec:	80 a0 80 04 	cmp  %g2, %g4                                  
400176f0:	02 80 00 0d 	be  40017724 <_Timer_server_Schedule_operation_method+0xa0>
400176f4:	c2 00 63 08 	ld  [ %g1 + 0x308 ], %g1                       
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
400176f8:	da 00 a0 10 	ld  [ %g2 + 0x10 ], %o5                        
      if ( snapshot > last_snapshot ) {                               
400176fc:	80 a0 40 03 	cmp  %g1, %g3                                  
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
40017700:	88 03 40 03 	add  %o5, %g3, %g4                             
    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 ) {                               
40017704:	08 80 00 07 	bleu  40017720 <_Timer_server_Schedule_operation_method+0x9c>
40017708:	88 21 00 01 	sub  %g4, %g1, %g4                             
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
4001770c:	86 20 40 03 	sub  %g1, %g3, %g3                             
        if (delta_interval > delta) {                                 
40017710:	80 a3 40 03 	cmp  %o5, %g3                                  
40017714:	08 80 00 03 	bleu  40017720 <_Timer_server_Schedule_operation_method+0x9c><== NEVER TAKEN
40017718:	88 10 20 00 	clr  %g4                                       
          delta_interval -= delta;                                    
4001771c:	88 23 40 03 	sub  %o5, %g3, %g4                             
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
        delta_interval += delta;                                      
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
40017720:	c8 20 a0 10 	st  %g4, [ %g2 + 0x10 ]                        
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
40017724:	c2 26 20 74 	st  %g1, [ %i0 + 0x74 ]                        
    _ISR_Enable( level );                                             
40017728:	7f ff dd e7 	call  4000eec4 <sparc_enable_interrupts>       
4001772c:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
40017730:	90 06 20 68 	add  %i0, 0x68, %o0                            
40017734:	40 00 12 46 	call  4001c04c <_Watchdog_Insert>              
40017738:	92 04 20 10 	add  %l0, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
4001773c:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
40017740:	80 a0 60 00 	cmp  %g1, 0                                    
40017744:	12 bf ff e2 	bne  400176cc <_Timer_server_Schedule_operation_method+0x48>
40017748:	01 00 00 00 	nop                                            
      _Timer_server_Reset_tod_system_watchdog( ts );                  
4001774c:	7f ff ff 3a 	call  40017434 <_Timer_server_Reset_tod_system_watchdog>
40017750:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
40017754:	40 00 0d a2 	call  4001addc <_Thread_Enable_dispatch>       
40017758:	81 e8 00 00 	restore                                        
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
    /*                                                                
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
4001775c:	7f ff dd d6 	call  4000eeb4 <sparc_disable_interrupts>      
40017760:	01 00 00 00 	nop                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
40017764:	05 10 00 fb 	sethi  %hi(0x4003ec00), %g2                    
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
40017768:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
    /*                                                                
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
4001776c:	c4 00 a3 90 	ld  [ %g2 + 0x390 ], %g2                       
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
40017770:	c8 06 20 3c 	ld  [ %i0 + 0x3c ], %g4                        
40017774:	86 06 20 34 	add  %i0, 0x34, %g3                            
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
40017778:	80 a0 40 03 	cmp  %g1, %g3                                  
4001777c:	02 80 00 08 	be  4001779c <_Timer_server_Schedule_operation_method+0x118>
40017780:	88 20 80 04 	sub  %g2, %g4, %g4                             
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
40017784:	da 00 60 10 	ld  [ %g1 + 0x10 ], %o5                        
      if (delta_interval > delta) {                                   
40017788:	80 a1 00 0d 	cmp  %g4, %o5                                  
4001778c:	1a 80 00 03 	bcc  40017798 <_Timer_server_Schedule_operation_method+0x114>
40017790:	86 10 20 00 	clr  %g3                                       
        delta_interval -= delta;                                      
40017794:	86 23 40 04 	sub  %o5, %g4, %g3                             
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
40017798:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
4001779c:	c4 26 20 3c 	st  %g2, [ %i0 + 0x3c ]                        
    _ISR_Enable( level );                                             
400177a0:	7f ff dd c9 	call  4000eec4 <sparc_enable_interrupts>       
400177a4:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
400177a8:	90 06 20 30 	add  %i0, 0x30, %o0                            
400177ac:	40 00 12 28 	call  4001c04c <_Watchdog_Insert>              
400177b0:	92 04 20 10 	add  %l0, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
400177b4:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
400177b8:	80 a0 60 00 	cmp  %g1, 0                                    
400177bc:	12 bf ff c4 	bne  400176cc <_Timer_server_Schedule_operation_method+0x48>
400177c0:	01 00 00 00 	nop                                            
      _Timer_server_Reset_interval_system_watchdog( ts );             
400177c4:	7f ff ff 07 	call  400173e0 <_Timer_server_Reset_interval_system_watchdog>
400177c8:	90 10 00 18 	mov  %i0, %o0                                  
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
400177cc:	40 00 0d 84 	call  4001addc <_Thread_Enable_dispatch>       
400177d0:	81 e8 00 00 	restore                                        
                                                                      

4000a57c <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) {
4000a57c:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000a580:	82 10 00 18 	mov  %i0, %g1                                  
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000a584:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  time->tv_nsec += add->tv_nsec;                                      
4000a588:	c8 06 60 04 	ld  [ %i1 + 4 ], %g4                           
uint32_t _Timespec_Add_to(                                            
  struct timespec       *time,                                        
  const struct timespec *add                                          
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
4000a58c:	f0 06 40 00 	ld  [ %i1 ], %i0                               
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
4000a590:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000a594:	86 00 c0 18 	add  %g3, %i0, %g3                             
  time->tv_nsec += add->tv_nsec;                                      
4000a598:	84 01 00 02 	add  %g4, %g2, %g2                             
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000a59c:	c6 20 40 00 	st  %g3, [ %g1 ]                               
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
4000a5a0:	09 0e e6 b2 	sethi  %hi(0x3b9ac800), %g4                    
4000a5a4:	88 11 21 ff 	or  %g4, 0x1ff, %g4	! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000a5a8:	80 a0 80 04 	cmp  %g2, %g4                                  
4000a5ac:	08 80 00 0b 	bleu  4000a5d8 <_Timespec_Add_to+0x5c>         
4000a5b0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                      
4000a5b4:	1b 31 19 4d 	sethi  %hi(0xc4653400), %o5                    
4000a5b8:	9a 13 62 00 	or  %o5, 0x200, %o5	! c4653600 <LEON_REG+0x44653600>
4000a5bc:	84 00 80 0d 	add  %g2, %o5, %g2                             
 *                                                                    
 *  This routines adds two timespecs.  The second argument is added   
 *  to the first.                                                     
 */                                                                   
                                                                      
uint32_t _Timespec_Add_to(                                            
4000a5c0:	86 00 e0 01 	inc  %g3                                       
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
4000a5c4:	80 a0 80 04 	cmp  %g2, %g4                                  
4000a5c8:	18 bf ff fd 	bgu  4000a5bc <_Timespec_Add_to+0x40>          <== NEVER TAKEN
4000a5cc:	b0 06 20 01 	inc  %i0                                       
4000a5d0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
4000a5d4:	c6 20 40 00 	st  %g3, [ %g1 ]                               
    time->tv_sec++;                                                   
    seconds++;                                                        
  }                                                                   
                                                                      
  return seconds;                                                     
}                                                                     
4000a5d8:	81 c7 e0 08 	ret                                            
4000a5dc:	81 e8 00 00 	restore                                        
                                                                      

4000a78c <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) {
4000a78c:	9d e3 bf a0 	save  %sp, -96, %sp                            
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
4000a790:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a794:	a2 14 61 e8 	or  %l1, 0x1e8, %l1	! 400165e8 <_User_extensions_List>
4000a798:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
4000a79c:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a7a0:	02 80 00 0d 	be  4000a7d4 <_User_extensions_Fatal+0x48>     <== NEVER TAKEN
4000a7a4:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
        !_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 )                      
4000a7a8:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
4000a7ac:	80 a0 60 00 	cmp  %g1, 0                                    
4000a7b0:	02 80 00 05 	be  4000a7c4 <_User_extensions_Fatal+0x38>     
4000a7b4:	90 10 00 18 	mov  %i0, %o0                                  
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
4000a7b8:	92 10 00 19 	mov  %i1, %o1                                  
4000a7bc:	9f c0 40 00 	call  %g1                                      
4000a7c0:	94 10 00 1a 	mov  %i2, %o2                                  
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
4000a7c4:	e0 04 20 04 	ld  [ %l0 + 4 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
4000a7c8:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a7cc:	32 bf ff f8 	bne,a   4000a7ac <_User_extensions_Fatal+0x20> <== ALWAYS TAKEN
4000a7d0:	c2 04 20 30 	ld  [ %l0 + 0x30 ], %g1                        
4000a7d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000a7d8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000a638 <_User_extensions_Handler_initialization>: #include <rtems/score/userext.h> #include <rtems/score/wkspace.h> #include <string.h> void _User_extensions_Handler_initialization(void) {
4000a638:	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;  
4000a63c:	07 10 00 56 	sethi  %hi(0x40015800), %g3                    
4000a640:	86 10 e1 98 	or  %g3, 0x198, %g3	! 40015998 <Configuration> 
  initial_extensions   = Configuration.User_extension_table;          
4000a644:	e6 00 e0 3c 	ld  [ %g3 + 0x3c ], %l3                        
4000a648:	1b 10 00 59 	sethi  %hi(0x40016400), %o5                    
4000a64c:	09 10 00 59 	sethi  %hi(0x40016400), %g4                    
4000a650:	84 13 61 e8 	or  %o5, 0x1e8, %g2                            
4000a654:	82 11 20 04 	or  %g4, 4, %g1                                
4000a658:	96 00 a0 04 	add  %g2, 4, %o3                               
4000a65c:	98 00 60 04 	add  %g1, 4, %o4                               
4000a660:	d6 23 61 e8 	st  %o3, [ %o5 + 0x1e8 ]                       
  head->previous = NULL;                                              
4000a664:	c0 20 a0 04 	clr  [ %g2 + 4 ]                               
  tail->previous = head;                                              
4000a668:	c4 20 a0 08 	st  %g2, [ %g2 + 8 ]                           
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000a66c:	d8 21 20 04 	st  %o4, [ %g4 + 4 ]                           
  head->previous = NULL;                                              
4000a670:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
  tail->previous = head;                                              
4000a674:	c2 20 60 08 	st  %g1, [ %g1 + 8 ]                           
                                                                      
  _Chain_Initialize_empty( &_User_extensions_List );                  
  _Chain_Initialize_empty( &_User_extensions_Switches_list );         
                                                                      
  if ( initial_extensions ) {                                         
4000a678:	80 a4 e0 00 	cmp  %l3, 0                                    
4000a67c:	02 80 00 1b 	be  4000a6e8 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
4000a680:	e4 00 e0 38 	ld  [ %g3 + 0x38 ], %l2                        
    extension = (User_extensions_Control *)                           
      _Workspace_Allocate_or_fatal_error(                             
        number_of_extensions * sizeof( User_extensions_Control )      
4000a684:	83 2c a0 02 	sll  %l2, 2, %g1                               
4000a688:	a3 2c a0 04 	sll  %l2, 4, %l1                               
4000a68c:	a2 24 40 01 	sub  %l1, %g1, %l1                             
4000a690:	a2 04 40 12 	add  %l1, %l2, %l1                             
4000a694:	a3 2c 60 02 	sll  %l1, 2, %l1                               
  _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(                             
4000a698:	40 00 01 9f 	call  4000ad14 <_Workspace_Allocate_or_fatal_error>
4000a69c:	90 10 00 11 	mov  %l1, %o0                                  
        number_of_extensions * sizeof( User_extensions_Control )      
      );                                                              
                                                                      
    memset (                                                          
4000a6a0:	92 10 20 00 	clr  %o1                                       
  _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(                             
4000a6a4:	a0 10 00 08 	mov  %o0, %l0                                  
        number_of_extensions * sizeof( User_extensions_Control )      
      );                                                              
                                                                      
    memset (                                                          
4000a6a8:	40 00 15 32 	call  4000fb70 <memset>                        
4000a6ac:	94 10 00 11 	mov  %l1, %o2                                  
      extension,                                                      
      0,                                                              
      number_of_extensions * sizeof( User_extensions_Control )        
    );                                                                
                                                                      
    for ( i = 0 ; i < number_of_extensions ; i++ ) {                  
4000a6b0:	80 a4 a0 00 	cmp  %l2, 0                                    
4000a6b4:	02 80 00 0d 	be  4000a6e8 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
4000a6b8:	a2 10 20 00 	clr  %l1                                       
#include <rtems/config.h>                                             
#include <rtems/score/userext.h>                                      
#include <rtems/score/wkspace.h>                                      
#include <string.h>                                                   
                                                                      
void _User_extensions_Handler_initialization(void)                    
4000a6bc:	93 2c 60 05 	sll  %l1, 5, %o1                               
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(        
  User_extensions_Control     *extension,                             
  const User_extensions_Table *extension_table                        
)                                                                     
{                                                                     
  extension->Callouts = *extension_table;                             
4000a6c0:	94 10 20 20 	mov  0x20, %o2                                 
4000a6c4:	92 04 c0 09 	add  %l3, %o1, %o1                             
4000a6c8:	40 00 14 f1 	call  4000fa8c <memcpy>                        
4000a6cc:	90 04 20 14 	add  %l0, 0x14, %o0                            
                                                                      
  _User_extensions_Add_set( extension );                              
4000a6d0:	40 00 0c 5c 	call  4000d840 <_User_extensions_Add_set>      
4000a6d4:	90 10 00 10 	mov  %l0, %o0                                  
      extension,                                                      
      0,                                                              
      number_of_extensions * sizeof( User_extensions_Control )        
    );                                                                
                                                                      
    for ( i = 0 ; i < number_of_extensions ; i++ ) {                  
4000a6d8:	a2 04 60 01 	inc  %l1                                       
4000a6dc:	80 a4 80 11 	cmp  %l2, %l1                                  
4000a6e0:	18 bf ff f7 	bgu  4000a6bc <_User_extensions_Handler_initialization+0x84>
4000a6e4:	a0 04 20 34 	add  %l0, 0x34, %l0                            
4000a6e8:	81 c7 e0 08 	ret                                            
4000a6ec:	81 e8 00 00 	restore                                        
                                                                      

4000a6f0 <_User_extensions_Thread_begin>: #include <rtems/score/userext.h> void _User_extensions_Thread_begin ( Thread_Control *executing ) {
4000a6f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
4000a6f4:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a6f8:	e0 04 61 e8 	ld  [ %l1 + 0x1e8 ], %l0	! 400165e8 <_User_extensions_List>
4000a6fc:	a2 14 61 e8 	or  %l1, 0x1e8, %l1                            
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000a700:	a2 04 60 04 	add  %l1, 4, %l1                               
4000a704:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a708:	02 80 00 0c 	be  4000a738 <_User_extensions_Thread_begin+0x48><== NEVER TAKEN
4000a70c:	01 00 00 00 	nop                                            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_begin != NULL )               
4000a710:	c2 04 20 28 	ld  [ %l0 + 0x28 ], %g1                        
4000a714:	80 a0 60 00 	cmp  %g1, 0                                    
4000a718:	02 80 00 04 	be  4000a728 <_User_extensions_Thread_begin+0x38>
4000a71c:	90 10 00 18 	mov  %i0, %o0                                  
      (*the_extension->Callouts.thread_begin)( executing );           
4000a720:	9f c0 40 00 	call  %g1                                      
4000a724:	01 00 00 00 	nop                                            
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
4000a728:	e0 04 00 00 	ld  [ %l0 ], %l0                               
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000a72c:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a730:	32 bf ff f9 	bne,a   4000a714 <_User_extensions_Thread_begin+0x24>
4000a734:	c2 04 20 28 	ld  [ %l0 + 0x28 ], %g1                        
4000a738:	81 c7 e0 08 	ret                                            
4000a73c:	81 e8 00 00 	restore                                        
                                                                      

4000a7dc <_User_extensions_Thread_create>: #include <rtems/score/userext.h> bool _User_extensions_Thread_create ( Thread_Control *the_thread ) {
4000a7dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
        return false;                                                 
    }                                                                 
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
4000a7e0:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a7e4:	e0 04 61 e8 	ld  [ %l1 + 0x1e8 ], %l0	! 400165e8 <_User_extensions_List>
#include <rtems/score/userext.h>                                      
                                                                      
bool _User_extensions_Thread_create (                                 
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
4000a7e8:	a6 10 00 18 	mov  %i0, %l3                                  
        return false;                                                 
    }                                                                 
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
4000a7ec:	a2 14 61 e8 	or  %l1, 0x1e8, %l1                            
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
  bool                     status;                                    
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000a7f0:	a2 04 60 04 	add  %l1, 4, %l1                               
4000a7f4:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a7f8:	02 80 00 13 	be  4000a844 <_User_extensions_Thread_create+0x68><== NEVER TAKEN
4000a7fc:	b0 10 20 01 	mov  1, %i0                                    
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_create != NULL ) {            
      status = (*the_extension->Callouts.thread_create)(              
4000a800:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_create != NULL ) {            
4000a804:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
4000a808:	80 a0 60 00 	cmp  %g1, 0                                    
4000a80c:	02 80 00 08 	be  4000a82c <_User_extensions_Thread_create+0x50>
4000a810:	84 14 a2 2c 	or  %l2, 0x22c, %g2                            
      status = (*the_extension->Callouts.thread_create)(              
4000a814:	d0 00 a0 0c 	ld  [ %g2 + 0xc ], %o0                         
4000a818:	9f c0 40 00 	call  %g1                                      
4000a81c:	92 10 00 13 	mov  %l3, %o1                                  
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
      if ( !status )                                                  
4000a820:	80 8a 20 ff 	btst  0xff, %o0                                
4000a824:	22 80 00 08 	be,a   4000a844 <_User_extensions_Thread_create+0x68>
4000a828:	b0 10 20 00 	clr  %i0                                       
  User_extensions_Control *the_extension;                             
  bool                     status;                                    
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
4000a82c:	e0 04 00 00 	ld  [ %l0 ], %l0                               
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
  bool                     status;                                    
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000a830:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a834:	32 bf ff f5 	bne,a   4000a808 <_User_extensions_Thread_create+0x2c>
4000a838:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
      if ( !status )                                                  
        return false;                                                 
    }                                                                 
  }                                                                   
                                                                      
  return true;                                                        
4000a83c:	81 c7 e0 08 	ret                                            
4000a840:	91 e8 20 01 	restore  %g0, 1, %o0                           
}                                                                     
4000a844:	81 c7 e0 08 	ret                                            
4000a848:	81 e8 00 00 	restore                                        
                                                                      

4000a84c <_User_extensions_Thread_delete>: #include <rtems/score/userext.h> void _User_extensions_Thread_delete ( Thread_Control *the_thread ) {
4000a84c:	9d e3 bf a0 	save  %sp, -96, %sp                            
      (*the_extension->Callouts.thread_delete)(                       
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
4000a850:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a854:	a2 14 61 e8 	or  %l1, 0x1e8, %l1	! 400165e8 <_User_extensions_List>
4000a858:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
4000a85c:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a860:	02 80 00 0d 	be  4000a894 <_User_extensions_Thread_delete+0x48><== NEVER TAKEN
4000a864:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
        !_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_delete != NULL )              
4000a868:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %g1                        
4000a86c:	80 a0 60 00 	cmp  %g1, 0                                    
4000a870:	02 80 00 05 	be  4000a884 <_User_extensions_Thread_delete+0x38>
4000a874:	84 14 a2 2c 	or  %l2, 0x22c, %g2                            
      (*the_extension->Callouts.thread_delete)(                       
4000a878:	d0 00 a0 0c 	ld  [ %g2 + 0xc ], %o0                         
4000a87c:	9f c0 40 00 	call  %g1                                      
4000a880:	92 10 00 18 	mov  %i0, %o1                                  
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
4000a884:	e0 04 20 04 	ld  [ %l0 + 4 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
4000a888:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a88c:	32 bf ff f8 	bne,a   4000a86c <_User_extensions_Thread_delete+0x20>
4000a890:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %g1                        
4000a894:	81 c7 e0 08 	ret                                            
4000a898:	81 e8 00 00 	restore                                        
                                                                      

4000a740 <_User_extensions_Thread_exitted>: } void _User_extensions_Thread_exitted ( Thread_Control *executing ) {
4000a740:	9d e3 bf a0 	save  %sp, -96, %sp                            
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
4000a744:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a748:	a2 14 61 e8 	or  %l1, 0x1e8, %l1	! 400165e8 <_User_extensions_List>
4000a74c:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
4000a750:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a754:	02 80 00 0c 	be  4000a784 <_User_extensions_Thread_exitted+0x44><== NEVER TAKEN
4000a758:	01 00 00 00 	nop                                            
        !_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 )             
4000a75c:	c2 04 20 2c 	ld  [ %l0 + 0x2c ], %g1                        
4000a760:	80 a0 60 00 	cmp  %g1, 0                                    
4000a764:	02 80 00 04 	be  4000a774 <_User_extensions_Thread_exitted+0x34>
4000a768:	90 10 00 18 	mov  %i0, %o0                                  
      (*the_extension->Callouts.thread_exitted)( executing );         
4000a76c:	9f c0 40 00 	call  %g1                                      
4000a770:	01 00 00 00 	nop                                            
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
4000a774:	e0 04 20 04 	ld  [ %l0 + 4 ], %l0                           
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
4000a778:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a77c:	32 bf ff f9 	bne,a   4000a760 <_User_extensions_Thread_exitted+0x20>
4000a780:	c2 04 20 2c 	ld  [ %l0 + 0x2c ], %g1                        
4000a784:	81 c7 e0 08 	ret                                            
4000a788:	81 e8 00 00 	restore                                        
                                                                      

4000b5c4 <_User_extensions_Thread_restart>: #include <rtems/score/userext.h> void _User_extensions_Thread_restart ( Thread_Control *the_thread ) {
4000b5c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
      (*the_extension->Callouts.thread_restart)(                      
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
4000b5c8:	23 10 00 7c 	sethi  %hi(0x4001f000), %l1                    
4000b5cc:	e0 04 62 a8 	ld  [ %l1 + 0x2a8 ], %l0	! 4001f2a8 <_User_extensions_List>
4000b5d0:	a2 14 62 a8 	or  %l1, 0x2a8, %l1                            
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000b5d4:	a2 04 60 04 	add  %l1, 4, %l1                               
4000b5d8:	80 a4 00 11 	cmp  %l0, %l1                                  
4000b5dc:	02 80 00 0d 	be  4000b610 <_User_extensions_Thread_restart+0x4c><== NEVER TAKEN
4000b5e0:	25 10 00 7c 	sethi  %hi(0x4001f000), %l2                    
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_restart != NULL )             
4000b5e4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
4000b5e8:	80 a0 60 00 	cmp  %g1, 0                                    
4000b5ec:	02 80 00 05 	be  4000b600 <_User_extensions_Thread_restart+0x3c>
4000b5f0:	84 14 a2 ec 	or  %l2, 0x2ec, %g2                            
      (*the_extension->Callouts.thread_restart)(                      
4000b5f4:	d0 00 a0 0c 	ld  [ %g2 + 0xc ], %o0                         
4000b5f8:	9f c0 40 00 	call  %g1                                      
4000b5fc:	92 10 00 18 	mov  %i0, %o1                                  
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
4000b600:	e0 04 00 00 	ld  [ %l0 ], %l0                               
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000b604:	80 a4 00 11 	cmp  %l0, %l1                                  
4000b608:	32 bf ff f8 	bne,a   4000b5e8 <_User_extensions_Thread_restart+0x24>
4000b60c:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
4000b610:	81 c7 e0 08 	ret                                            
4000b614:	81 e8 00 00 	restore                                        
                                                                      

4000a89c <_User_extensions_Thread_start>: #include <rtems/score/userext.h> void _User_extensions_Thread_start ( Thread_Control *the_thread ) {
4000a89c:	9d e3 bf a0 	save  %sp, -96, %sp                            
      (*the_extension->Callouts.thread_start)(                        
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
4000a8a0:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a8a4:	e0 04 61 e8 	ld  [ %l1 + 0x1e8 ], %l0	! 400165e8 <_User_extensions_List>
4000a8a8:	a2 14 61 e8 	or  %l1, 0x1e8, %l1                            
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000a8ac:	a2 04 60 04 	add  %l1, 4, %l1                               
4000a8b0:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a8b4:	02 80 00 0d 	be  4000a8e8 <_User_extensions_Thread_start+0x4c><== NEVER TAKEN
4000a8b8:	25 10 00 59 	sethi  %hi(0x40016400), %l2                    
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_start != NULL )               
4000a8bc:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
4000a8c0:	80 a0 60 00 	cmp  %g1, 0                                    
4000a8c4:	02 80 00 05 	be  4000a8d8 <_User_extensions_Thread_start+0x3c>
4000a8c8:	84 14 a2 2c 	or  %l2, 0x22c, %g2                            
      (*the_extension->Callouts.thread_start)(                        
4000a8cc:	d0 00 a0 0c 	ld  [ %g2 + 0xc ], %o0                         
4000a8d0:	9f c0 40 00 	call  %g1                                      
4000a8d4:	92 10 00 18 	mov  %i0, %o1                                  
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
4000a8d8:	e0 04 00 00 	ld  [ %l0 ], %l0                               
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
4000a8dc:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a8e0:	32 bf ff f8 	bne,a   4000a8c0 <_User_extensions_Thread_start+0x24>
4000a8e4:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
4000a8e8:	81 c7 e0 08 	ret                                            
4000a8ec:	81 e8 00 00 	restore                                        
                                                                      

4000a8f0 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) {
4000a8f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
    the_extension_switch = (User_extensions_Switch_control *) the_node;
                                                                      
    (*the_extension_switch->thread_switch)( executing, heir );        
  }                                                                   
}                                                                     
4000a8f4:	23 10 00 59 	sethi  %hi(0x40016400), %l1                    
4000a8f8:	e0 04 60 04 	ld  [ %l1 + 4 ], %l0	! 40016404 <_User_extensions_Switches_list>
4000a8fc:	a2 14 60 04 	or  %l1, 4, %l1                                
)                                                                     
{                                                                     
  Chain_Node                     *the_node;                           
  User_extensions_Switch_control *the_extension_switch;               
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_Switches_list );   
4000a900:	a2 04 60 04 	add  %l1, 4, %l1                               
4000a904:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a908:	02 80 00 0a 	be  4000a930 <_User_extensions_Thread_switch+0x40><== NEVER TAKEN
4000a90c:	01 00 00 00 	nop                                            
        !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
        the_node = the_node->next ) {                                 
                                                                      
    the_extension_switch = (User_extensions_Switch_control *) the_node;
                                                                      
    (*the_extension_switch->thread_switch)( executing, heir );        
4000a910:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
4000a914:	90 10 00 18 	mov  %i0, %o0                                  
4000a918:	9f c0 40 00 	call  %g1                                      
4000a91c:	92 10 00 19 	mov  %i1, %o1                                  
  Chain_Node                     *the_node;                           
  User_extensions_Switch_control *the_extension_switch;               
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_Switches_list );   
        !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
        the_node = the_node->next ) {                                 
4000a920:	e0 04 00 00 	ld  [ %l0 ], %l0                               
)                                                                     
{                                                                     
  Chain_Node                     *the_node;                           
  User_extensions_Switch_control *the_extension_switch;               
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_Switches_list );   
4000a924:	80 a4 00 11 	cmp  %l0, %l1                                  
4000a928:	32 bf ff fb 	bne,a   4000a914 <_User_extensions_Thread_switch+0x24>
4000a92c:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
4000a930:	81 c7 e0 08 	ret                                            
4000a934:	81 e8 00 00 	restore                                        
                                                                      

4000c9c0 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) {
4000c9c0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
4000c9c4:	7f ff d9 02 	call  40002dcc <sparc_disable_interrupts>      
4000c9c8:	a0 10 00 18 	mov  %i0, %l0                                  
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
4000c9cc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000c9d0:	a4 06 20 04 	add  %i0, 4, %l2                               
   *       hence the compiler must not assume *header to remain       
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
4000c9d4:	80 a0 40 12 	cmp  %g1, %l2                                  
4000c9d8:	02 80 00 1f 	be  4000ca54 <_Watchdog_Adjust+0x94>           
4000c9dc:	80 a6 60 00 	cmp  %i1, 0                                    
    switch ( direction ) {                                            
4000c9e0:	12 80 00 1f 	bne  4000ca5c <_Watchdog_Adjust+0x9c>          
4000c9e4:	80 a6 60 01 	cmp  %i1, 1                                    
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
4000c9e8:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c9ec:	02 80 00 1a 	be  4000ca54 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
4000c9f0:	01 00 00 00 	nop                                            
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000c9f4:	e2 00 60 10 	ld  [ %g1 + 0x10 ], %l1                        
4000c9f8:	80 a6 80 11 	cmp  %i2, %l1                                  
4000c9fc:	1a 80 00 0b 	bcc  4000ca28 <_Watchdog_Adjust+0x68>          <== ALWAYS TAKEN
4000ca00:	a6 10 20 01 	mov  1, %l3                                    
            _Watchdog_First( header )->delta_interval -= units;       
4000ca04:	10 80 00 1d 	b  4000ca78 <_Watchdog_Adjust+0xb8>            <== NOT EXECUTED
4000ca08:	a2 24 40 1a 	sub  %l1, %i2, %l1                             <== NOT EXECUTED
    switch ( direction ) {                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
4000ca0c:	b4 a6 80 11 	subcc  %i2, %l1, %i2                           
4000ca10:	02 80 00 11 	be  4000ca54 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
4000ca14:	01 00 00 00 	nop                                            
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000ca18:	e2 00 60 10 	ld  [ %g1 + 0x10 ], %l1                        
4000ca1c:	80 a4 40 1a 	cmp  %l1, %i2                                  
4000ca20:	38 80 00 16 	bgu,a   4000ca78 <_Watchdog_Adjust+0xb8>       
4000ca24:	a2 24 40 1a 	sub  %l1, %i2, %l1                             
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
4000ca28:	e6 20 60 10 	st  %l3, [ %g1 + 0x10 ]                        
                                                                      
            _ISR_Enable( level );                                     
4000ca2c:	7f ff d8 ec 	call  40002ddc <sparc_enable_interrupts>       
4000ca30:	01 00 00 00 	nop                                            
                                                                      
            _Watchdog_Tickle( header );                               
4000ca34:	40 00 00 b4 	call  4000cd04 <_Watchdog_Tickle>              
4000ca38:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
            _ISR_Disable( level );                                    
4000ca3c:	7f ff d8 e4 	call  40002dcc <sparc_disable_interrupts>      
4000ca40:	01 00 00 00 	nop                                            
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
4000ca44:	c4 04 00 00 	ld  [ %l0 ], %g2                               
                                                                      
            _Watchdog_Tickle( header );                               
                                                                      
            _ISR_Disable( level );                                    
                                                                      
            if ( _Chain_Is_empty( header ) )                          
4000ca48:	80 a4 80 02 	cmp  %l2, %g2                                  
4000ca4c:	12 bf ff f0 	bne  4000ca0c <_Watchdog_Adjust+0x4c>          
4000ca50:	82 10 00 02 	mov  %g2, %g1                                  
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000ca54:	7f ff d8 e2 	call  40002ddc <sparc_enable_interrupts>       
4000ca58:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
    switch ( direction ) {                                            
4000ca5c:	12 bf ff fe 	bne  4000ca54 <_Watchdog_Adjust+0x94>          <== NEVER TAKEN
4000ca60:	01 00 00 00 	nop                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
4000ca64:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000ca68:	b4 00 80 1a 	add  %g2, %i2, %i2                             
4000ca6c:	f4 20 60 10 	st  %i2, [ %g1 + 0x10 ]                        
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000ca70:	7f ff d8 db 	call  40002ddc <sparc_enable_interrupts>       
4000ca74:	91 e8 00 08 	restore  %g0, %o0, %o0                         
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
4000ca78:	10 bf ff f7 	b  4000ca54 <_Watchdog_Adjust+0x94>            
4000ca7c:	e2 20 60 10 	st  %l1, [ %g1 + 0x10 ]                        
                                                                      

4000aae4 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) {
4000aae4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
4000aae8:	7f ff dc da 	call  40001e50 <sparc_disable_interrupts>      
4000aaec:	01 00 00 00 	nop                                            
  previous_state = the_watchdog->state;                               
4000aaf0:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
  switch ( previous_state ) {                                         
4000aaf4:	80 a4 20 01 	cmp  %l0, 1                                    
4000aaf8:	02 80 00 2a 	be  4000aba0 <_Watchdog_Remove+0xbc>           
4000aafc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
4000ab00:	1a 80 00 09 	bcc  4000ab24 <_Watchdog_Remove+0x40>          
4000ab04:	80 a4 20 03 	cmp  %l0, 3                                    
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000ab08:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
4000ab0c:	c2 00 61 10 	ld  [ %g1 + 0x110 ], %g1	! 40016510 <_Watchdog_Ticks_since_boot>
4000ab10:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000ab14:	7f ff dc d3 	call  40001e60 <sparc_enable_interrupts>       
4000ab18:	b0 10 00 10 	mov  %l0, %i0                                  
  return( previous_state );                                           
}                                                                     
4000ab1c:	81 c7 e0 08 	ret                                            
4000ab20:	81 e8 00 00 	restore                                        
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  previous_state = the_watchdog->state;                               
  switch ( previous_state ) {                                         
4000ab24:	18 bf ff fa 	bgu  4000ab0c <_Watchdog_Remove+0x28>          <== NEVER TAKEN
4000ab28:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
                                                                      
  _ISR_Enable( level );                                               
  return( previous_state );                                           
}                                                                     
4000ab2c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
4000ab30:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
4000ab34:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000ab38:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ab3c:	02 80 00 07 	be  4000ab58 <_Watchdog_Remove+0x74>           
4000ab40:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
        next_watchdog->delta_interval += the_watchdog->delta_interval;
4000ab44:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
4000ab48:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000ab4c:	84 00 c0 02 	add  %g3, %g2, %g2                             
4000ab50:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
      if ( _Watchdog_Sync_count )                                     
4000ab54:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
4000ab58:	c4 00 a1 0c 	ld  [ %g2 + 0x10c ], %g2	! 4001650c <_Watchdog_Sync_count>
4000ab5c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ab60:	22 80 00 07 	be,a   4000ab7c <_Watchdog_Remove+0x98>        
4000ab64:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
        _Watchdog_Sync_level = _ISR_Nest_level;                       
4000ab68:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
4000ab6c:	c6 00 a2 34 	ld  [ %g2 + 0x234 ], %g3	! 40016634 <_Per_CPU_Information+0x8>
4000ab70:	05 10 00 59 	sethi  %hi(0x40016400), %g2                    
4000ab74:	c6 20 a0 a4 	st  %g3, [ %g2 + 0xa4 ]	! 400164a4 <_Watchdog_Sync_level>
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000ab78:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  next->previous = previous;                                          
4000ab7c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  previous->next = next;                                              
4000ab80:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000ab84:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
4000ab88:	c2 00 61 10 	ld  [ %g1 + 0x110 ], %g1	! 40016510 <_Watchdog_Ticks_since_boot>
4000ab8c:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000ab90:	7f ff dc b4 	call  40001e60 <sparc_enable_interrupts>       
4000ab94:	b0 10 00 10 	mov  %l0, %i0                                  
  return( previous_state );                                           
}                                                                     
4000ab98:	81 c7 e0 08 	ret                                            
4000ab9c:	81 e8 00 00 	restore                                        
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000aba0:	c2 00 61 10 	ld  [ %g1 + 0x110 ], %g1                       
                                                                      
      /*                                                              
       *  It is not actually on the chain so just change the state and
       *  the Insert operation we interrupted will be aborted.        
       */                                                             
      the_watchdog->state = WATCHDOG_INACTIVE;                        
4000aba4:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000aba8:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000abac:	7f ff dc ad 	call  40001e60 <sparc_enable_interrupts>       
4000abb0:	b0 10 00 10 	mov  %l0, %i0                                  
  return( previous_state );                                           
}                                                                     
4000abb4:	81 c7 e0 08 	ret                                            
4000abb8:	81 e8 00 00 	restore                                        
                                                                      

4000c1d0 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) {
4000c1d0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
4000c1d4:	7f ff d9 d0 	call  40002914 <sparc_disable_interrupts>      
4000c1d8:	01 00 00 00 	nop                                            
4000c1dc:	a0 10 00 08 	mov  %o0, %l0                                  
    printk( "Watchdog Chain: %s %p\n", name, header );                
4000c1e0:	11 10 00 7a 	sethi  %hi(0x4001e800), %o0                    
4000c1e4:	94 10 00 19 	mov  %i1, %o2                                  
4000c1e8:	92 10 00 18 	mov  %i0, %o1                                  
4000c1ec:	7f ff e4 89 	call  40005410 <printk>                        
4000c1f0:	90 12 20 70 	or  %o0, 0x70, %o0                             
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
}                                                                     
4000c1f4:	e2 06 40 00 	ld  [ %i1 ], %l1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000c1f8:	b2 06 60 04 	add  %i1, 4, %i1                               
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
4000c1fc:	80 a4 40 19 	cmp  %l1, %i1                                  
4000c200:	02 80 00 0f 	be  4000c23c <_Watchdog_Report_chain+0x6c>     
4000c204:	11 10 00 7a 	sethi  %hi(0x4001e800), %o0                    
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
4000c208:	92 10 00 11 	mov  %l1, %o1                                  
4000c20c:	40 00 00 0f 	call  4000c248 <_Watchdog_Report>              
4000c210:	90 10 20 00 	clr  %o0                                       
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
4000c214:	e2 04 40 00 	ld  [ %l1 ], %l1                               
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
4000c218:	80 a4 40 19 	cmp  %l1, %i1                                  
4000c21c:	12 bf ff fc 	bne  4000c20c <_Watchdog_Report_chain+0x3c>    <== NEVER TAKEN
4000c220:	92 10 00 11 	mov  %l1, %o1                                  
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
4000c224:	11 10 00 7a 	sethi  %hi(0x4001e800), %o0                    
4000c228:	92 10 00 18 	mov  %i0, %o1                                  
4000c22c:	7f ff e4 79 	call  40005410 <printk>                        
4000c230:	90 12 20 88 	or  %o0, 0x88, %o0                             
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
4000c234:	7f ff d9 bc 	call  40002924 <sparc_enable_interrupts>       
4000c238:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
4000c23c:	7f ff e4 75 	call  40005410 <printk>                        
4000c240:	90 12 20 98 	or  %o0, 0x98, %o0                             
4000c244:	30 bf ff fc 	b,a   4000c234 <_Watchdog_Report_chain+0x64>   
                                                                      

4000f818 <rtems_barrier_create>: rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) {
4000f818:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000f81c:	a0 10 00 18 	mov  %i0, %l0                                  
  Barrier_Control         *the_barrier;                               
  CORE_barrier_Attributes  the_attributes;                            
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
4000f820:	80 a4 20 00 	cmp  %l0, 0                                    
4000f824:	02 80 00 23 	be  4000f8b0 <rtems_barrier_create+0x98>       
4000f828:	b0 10 20 03 	mov  3, %i0                                    
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
4000f82c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000f830:	02 80 00 20 	be  4000f8b0 <rtems_barrier_create+0x98>       
4000f834:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Initialize core barrier attributes */                            
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
4000f838:	80 8e 60 10 	btst  0x10, %i1                                
4000f83c:	02 80 00 1f 	be  4000f8b8 <rtems_barrier_create+0xa0>       
4000f840:	80 a6 a0 00 	cmp  %i2, 0                                    
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
4000f844:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    if ( maximum_waiters == 0 )                                       
4000f848:	02 80 00 1a 	be  4000f8b0 <rtems_barrier_create+0x98>       
4000f84c:	b0 10 20 0a 	mov  0xa, %i0                                  
4000f850:	03 10 00 8d 	sethi  %hi(0x40023400), %g1                    
4000f854:	c4 00 61 50 	ld  [ %g1 + 0x150 ], %g2	! 40023550 <_Thread_Dispatch_disable_level>
      return RTEMS_INVALID_NUMBER;                                    
  } else                                                              
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;          
  the_attributes.maximum_count = maximum_waiters;                     
4000f858:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
4000f85c:	84 00 a0 01 	inc  %g2                                       
4000f860:	c4 20 61 50 	st  %g2, [ %g1 + 0x150 ]                       
 *  This function allocates a barrier control block from              
 *  the inactive chain of free barrier control blocks.                
 */                                                                   
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )       
{                                                                     
  return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
4000f864:	25 10 00 8d 	sethi  %hi(0x40023400), %l2                    
4000f868:	7f ff ec 13 	call  4000a8b4 <_Objects_Allocate>             
4000f86c:	90 14 a3 d0 	or  %l2, 0x3d0, %o0	! 400237d0 <_Barrier_Information>
                                                                      
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _Barrier_Allocate();                                  
                                                                      
  if ( !the_barrier ) {                                               
4000f870:	a2 92 20 00 	orcc  %o0, 0, %l1                              
4000f874:	02 80 00 1e 	be  4000f8ec <rtems_barrier_create+0xd4>       <== NEVER TAKEN
4000f878:	90 04 60 14 	add  %l1, 0x14, %o0                            
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_barrier->attribute_set = attribute_set;                         
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
4000f87c:	92 07 bf f8 	add  %fp, -8, %o1                              
4000f880:	40 00 02 43 	call  4001018c <_CORE_barrier_Initialize>      
4000f884:	f2 24 60 10 	st  %i1, [ %l1 + 0x10 ]                        
4000f888:	c4 14 60 0a 	lduh  [ %l1 + 0xa ], %g2                       
                                                                      
  *id = the_barrier->Object.id;                                       
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000f88c:	a4 14 a3 d0 	or  %l2, 0x3d0, %l2                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000f890:	c6 04 a0 1c 	ld  [ %l2 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
4000f894:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000f898:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000f89c:	e2 20 c0 02 	st  %l1, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
4000f8a0:	e0 24 60 0c 	st  %l0, [ %l1 + 0xc ]                         
    &_Barrier_Information,                                            
    &the_barrier->Object,                                             
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_barrier->Object.id;                                       
4000f8a4:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
4000f8a8:	7f ff f0 ca 	call  4000bbd0 <_Thread_Enable_dispatch>       
4000f8ac:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000f8b0:	81 c7 e0 08 	ret                                            
4000f8b4:	81 e8 00 00 	restore                                        
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
    if ( maximum_waiters == 0 )                                       
      return RTEMS_INVALID_NUMBER;                                    
  } else                                                              
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;          
4000f8b8:	82 10 20 01 	mov  1, %g1                                    
4000f8bc:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
4000f8c0:	03 10 00 8d 	sethi  %hi(0x40023400), %g1                    
4000f8c4:	c4 00 61 50 	ld  [ %g1 + 0x150 ], %g2	! 40023550 <_Thread_Dispatch_disable_level>
  the_attributes.maximum_count = maximum_waiters;                     
4000f8c8:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
4000f8cc:	84 00 a0 01 	inc  %g2                                       
4000f8d0:	c4 20 61 50 	st  %g2, [ %g1 + 0x150 ]                       
4000f8d4:	25 10 00 8d 	sethi  %hi(0x40023400), %l2                    
4000f8d8:	7f ff eb f7 	call  4000a8b4 <_Objects_Allocate>             
4000f8dc:	90 14 a3 d0 	or  %l2, 0x3d0, %o0	! 400237d0 <_Barrier_Information>
                                                                      
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _Barrier_Allocate();                                  
                                                                      
  if ( !the_barrier ) {                                               
4000f8e0:	a2 92 20 00 	orcc  %o0, 0, %l1                              
4000f8e4:	12 bf ff e6 	bne  4000f87c <rtems_barrier_create+0x64>      
4000f8e8:	90 04 60 14 	add  %l1, 0x14, %o0                            
    _Thread_Enable_dispatch();                                        
4000f8ec:	7f ff f0 b9 	call  4000bbd0 <_Thread_Enable_dispatch>       
4000f8f0:	b0 10 20 05 	mov  5, %i0                                    
    return RTEMS_TOO_MANY;                                            
4000f8f4:	81 c7 e0 08 	ret                                            
4000f8f8:	81 e8 00 00 	restore                                        
                                                                      

40007fa4 <rtems_chain_get_with_wait>: rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) {
40007fa4:	9d e3 bf 98 	save  %sp, -104, %sp                           
40007fa8:	a0 10 00 18 	mov  %i0, %l0                                  
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
40007fac:	a4 07 bf fc 	add  %fp, -4, %l2                              
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
40007fb0:	40 00 01 89 	call  400085d4 <_Chain_Get>                    
40007fb4:	90 10 00 10 	mov  %l0, %o0                                  
40007fb8:	92 10 20 00 	clr  %o1                                       
40007fbc:	a2 10 00 08 	mov  %o0, %l1                                  
40007fc0:	94 10 00 1a 	mov  %i2, %o2                                  
40007fc4:	90 10 00 19 	mov  %i1, %o0                                  
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
40007fc8:	80 a4 60 00 	cmp  %l1, 0                                    
40007fcc:	12 80 00 0a 	bne  40007ff4 <rtems_chain_get_with_wait+0x50> 
40007fd0:	96 10 00 12 	mov  %l2, %o3                                  
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
40007fd4:	7f ff fc e3 	call  40007360 <rtems_event_receive>           
40007fd8:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
40007fdc:	80 a2 20 00 	cmp  %o0, 0                                    
40007fe0:	02 bf ff f4 	be  40007fb0 <rtems_chain_get_with_wait+0xc>   <== NEVER TAKEN
40007fe4:	b0 10 00 08 	mov  %o0, %i0                                  
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
40007fe8:	e2 26 c0 00 	st  %l1, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
40007fec:	81 c7 e0 08 	ret                                            
40007ff0:	81 e8 00 00 	restore                                        
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
40007ff4:	90 10 20 00 	clr  %o0                                       
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
40007ff8:	e2 26 c0 00 	st  %l1, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
40007ffc:	81 c7 e0 08 	ret                                            
40008000:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

40008dcc <rtems_io_register_driver>: rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) {
40008dcc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
40008dd0:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40008dd4:	c4 00 61 64 	ld  [ %g1 + 0x164 ], %g2	! 4001ad64 <_Per_CPU_Information+0x8>
rtems_status_code rtems_io_register_driver(                           
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
40008dd8:	86 10 00 19 	mov  %i1, %g3                                  
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
40008ddc:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
40008de0:	80 a0 a0 00 	cmp  %g2, 0                                    
40008de4:	12 80 00 42 	bne  40008eec <rtems_io_register_driver+0x120> 
40008de8:	c8 00 61 f4 	ld  [ %g1 + 0x1f4 ], %g4                       
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( registered_major == NULL )                                     
40008dec:	80 a6 a0 00 	cmp  %i2, 0                                    
40008df0:	02 80 00 50 	be  40008f30 <rtems_io_register_driver+0x164>  
40008df4:	01 00 00 00 	nop                                            
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Set it to an invalid value */                                    
  *registered_major = major_limit;                                    
                                                                      
  if ( driver_table == NULL )                                         
40008df8:	80 a6 60 00 	cmp  %i1, 0                                    
40008dfc:	02 80 00 4d 	be  40008f30 <rtems_io_register_driver+0x164>  
40008e00:	c8 26 80 00 	st  %g4, [ %i2 ]                               
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008e04:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40008e08:	80 a0 a0 00 	cmp  %g2, 0                                    
40008e0c:	22 80 00 46 	be,a   40008f24 <rtems_io_register_driver+0x158>
40008e10:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( major >= major_limit )                                         
40008e14:	80 a1 00 18 	cmp  %g4, %i0                                  
40008e18:	08 80 00 33 	bleu  40008ee4 <rtems_io_register_driver+0x118>
40008e1c:	01 00 00 00 	nop                                            
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
40008e20:	05 10 00 6a 	sethi  %hi(0x4001a800), %g2                    
40008e24:	c8 00 a3 30 	ld  [ %g2 + 0x330 ], %g4	! 4001ab30 <_Thread_Dispatch_disable_level>
40008e28:	88 01 20 01 	inc  %g4                                       
40008e2c:	c8 20 a3 30 	st  %g4, [ %g2 + 0x330 ]                       
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( major == 0 ) {                                                 
40008e30:	80 a6 20 00 	cmp  %i0, 0                                    
40008e34:	12 80 00 30 	bne  40008ef4 <rtems_io_register_driver+0x128> 
40008e38:	1b 10 00 6b 	sethi  %hi(0x4001ac00), %o5                    
                                                                      
static rtems_status_code rtems_io_obtain_major_number(                
  rtems_device_major_number *major                                    
)                                                                     
{                                                                     
  rtems_device_major_number n = _IO_Number_of_drivers;                
40008e3c:	c8 00 61 f4 	ld  [ %g1 + 0x1f4 ], %g4                       
  rtems_device_major_number m = 0;                                    
                                                                      
  /* major is error checked by caller */                              
                                                                      
  for ( m = 0; m < n; ++m ) {                                         
40008e40:	80 a1 20 00 	cmp  %g4, 0                                    
40008e44:	22 80 00 3d 	be,a   40008f38 <rtems_io_register_driver+0x16c><== NEVER TAKEN
40008e48:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
40008e4c:	10 80 00 05 	b  40008e60 <rtems_io_register_driver+0x94>    
40008e50:	c2 03 61 f8 	ld  [ %o5 + 0x1f8 ], %g1                       
40008e54:	80 a1 00 18 	cmp  %g4, %i0                                  
40008e58:	08 80 00 0a 	bleu  40008e80 <rtems_io_register_driver+0xb4> 
40008e5c:	82 00 60 18 	add  %g1, 0x18, %g1                            
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008e60:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40008e64:	80 a0 a0 00 	cmp  %g2, 0                                    
40008e68:	32 bf ff fb 	bne,a   40008e54 <rtems_io_register_driver+0x88>
40008e6c:	b0 06 20 01 	inc  %i0                                       
40008e70:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40008e74:	80 a0 a0 00 	cmp  %g2, 0                                    
40008e78:	32 bf ff f7 	bne,a   40008e54 <rtems_io_register_driver+0x88>
40008e7c:	b0 06 20 01 	inc  %i0                                       
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
                                                                      
  if ( m != n )                                                       
40008e80:	80 a1 00 18 	cmp  %g4, %i0                                  
40008e84:	02 80 00 2d 	be  40008f38 <rtems_io_register_driver+0x16c>  
40008e88:	f0 26 80 00 	st  %i0, [ %i2 ]                               
40008e8c:	83 2e 20 03 	sll  %i0, 3, %g1                               
40008e90:	85 2e 20 05 	sll  %i0, 5, %g2                               
40008e94:	84 20 80 01 	sub  %g2, %g1, %g2                             
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008e98:	c8 03 61 f8 	ld  [ %o5 + 0x1f8 ], %g4                       
40008e9c:	da 00 c0 00 	ld  [ %g3 ], %o5                               
40008ea0:	82 01 00 02 	add  %g4, %g2, %g1                             
40008ea4:	da 21 00 02 	st  %o5, [ %g4 + %g2 ]                         
40008ea8:	c4 00 e0 04 	ld  [ %g3 + 4 ], %g2                           
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008eac:	b2 10 20 00 	clr  %i1                                       
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008eb0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
40008eb4:	c4 00 e0 08 	ld  [ %g3 + 8 ], %g2                           
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008eb8:	b4 10 20 00 	clr  %i2                                       
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008ebc:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
40008ec0:	c4 00 e0 0c 	ld  [ %g3 + 0xc ], %g2                         
40008ec4:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
40008ec8:	c4 00 e0 10 	ld  [ %g3 + 0x10 ], %g2                        
40008ecc:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
40008ed0:	c4 00 e0 14 	ld  [ %g3 + 0x14 ], %g2                        
                                                                      
  _Thread_Enable_dispatch();                                          
40008ed4:	40 00 08 54 	call  4000b024 <_Thread_Enable_dispatch>       
40008ed8:	c4 20 60 14 	st  %g2, [ %g1 + 0x14 ]                        
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008edc:	40 00 22 05 	call  400116f0 <rtems_io_initialize>           
40008ee0:	81 e8 00 00 	restore                                        
}                                                                     
40008ee4:	81 c7 e0 08 	ret                                            
40008ee8:	91 e8 20 0a 	restore  %g0, 0xa, %o0                         
)                                                                     
{                                                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
    return RTEMS_CALLED_FROM_ISR;                                     
40008eec:	81 c7 e0 08 	ret                                            
40008ef0:	91 e8 20 12 	restore  %g0, 0x12, %o0                        
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
40008ef4:	c2 03 61 f8 	ld  [ %o5 + 0x1f8 ], %g1                       
40008ef8:	89 2e 20 05 	sll  %i0, 5, %g4                               
40008efc:	85 2e 20 03 	sll  %i0, 3, %g2                               
40008f00:	84 21 00 02 	sub  %g4, %g2, %g2                             
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008f04:	c8 00 40 02 	ld  [ %g1 + %g2 ], %g4                         
40008f08:	80 a1 20 00 	cmp  %g4, 0                                    
40008f0c:	02 80 00 0f 	be  40008f48 <rtems_io_register_driver+0x17c>  
40008f10:	82 00 40 02 	add  %g1, %g2, %g1                             
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
                                                                      
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
40008f14:	40 00 08 44 	call  4000b024 <_Thread_Enable_dispatch>       
40008f18:	b0 10 20 0c 	mov  0xc, %i0                                  
      return RTEMS_RESOURCE_IN_USE;                                   
40008f1c:	81 c7 e0 08 	ret                                            
40008f20:	81 e8 00 00 	restore                                        
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008f24:	80 a0 a0 00 	cmp  %g2, 0                                    
40008f28:	32 bf ff bc 	bne,a   40008e18 <rtems_io_register_driver+0x4c>
40008f2c:	80 a1 00 18 	cmp  %g4, %i0                                  
                                                                      
  if ( driver_table == NULL )                                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
40008f30:	81 c7 e0 08 	ret                                            
40008f34:	91 e8 20 09 	restore  %g0, 9, %o0                           
                                                                      
  if ( major == 0 ) {                                                 
    rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
                                                                      
    if ( sc != RTEMS_SUCCESSFUL ) {                                   
      _Thread_Enable_dispatch();                                      
40008f38:	40 00 08 3b 	call  4000b024 <_Thread_Enable_dispatch>       
40008f3c:	b0 10 20 05 	mov  5, %i0                                    
      return sc;                                                      
40008f40:	81 c7 e0 08 	ret                                            
40008f44:	81 e8 00 00 	restore                                        
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008f48:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40008f4c:	80 a0 60 00 	cmp  %g1, 0                                    
40008f50:	12 bf ff f1 	bne  40008f14 <rtems_io_register_driver+0x148> 
40008f54:	01 00 00 00 	nop                                            
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
      return RTEMS_RESOURCE_IN_USE;                                   
    }                                                                 
                                                                      
    *registered_major = major;                                        
40008f58:	10 bf ff d0 	b  40008e98 <rtems_io_register_driver+0xcc>    
40008f5c:	f0 26 80 00 	st  %i0, [ %i2 ]                               
                                                                      

4000a308 <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) {
4000a308:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
4000a30c:	80 a6 20 00 	cmp  %i0, 0                                    
4000a310:	02 80 00 23 	be  4000a39c <rtems_iterate_over_all_threads+0x94><== NEVER TAKEN
4000a314:	25 10 00 84 	sethi  %hi(0x40021000), %l2                    
4000a318:	a4 14 a0 fc 	or  %l2, 0xfc, %l2	! 400210fc <_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) 
4000a31c:	a6 04 a0 0c 	add  %l2, 0xc, %l3                             
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
4000a320:	c2 04 80 00 	ld  [ %l2 ], %g1                               
4000a324:	80 a0 60 00 	cmp  %g1, 0                                    
4000a328:	22 80 00 1a 	be,a   4000a390 <rtems_iterate_over_all_threads+0x88>
4000a32c:	a4 04 a0 04 	add  %l2, 4, %l2                               
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
4000a330:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
    if ( !information )                                               
4000a334:	80 a4 60 00 	cmp  %l1, 0                                    
4000a338:	22 80 00 16 	be,a   4000a390 <rtems_iterate_over_all_threads+0x88>
4000a33c:	a4 04 a0 04 	add  %l2, 4, %l2                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
4000a340:	c2 14 60 10 	lduh  [ %l1 + 0x10 ], %g1                      
4000a344:	84 90 60 00 	orcc  %g1, 0, %g2                              
4000a348:	22 80 00 12 	be,a   4000a390 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
4000a34c:	a4 04 a0 04 	add  %l2, 4, %l2                               <== NOT EXECUTED
4000a350:	a0 10 20 01 	mov  1, %l0                                    
      the_thread = (Thread_Control *)information->local_table[ i ];   
4000a354:	c6 04 60 1c 	ld  [ %l1 + 0x1c ], %g3                        
4000a358:	83 2c 20 02 	sll  %l0, 2, %g1                               
4000a35c:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
                                                                      
      if ( !the_thread )                                              
4000a360:	90 90 60 00 	orcc  %g1, 0, %o0                              
4000a364:	02 80 00 05 	be  4000a378 <rtems_iterate_over_all_threads+0x70><== NEVER TAKEN
4000a368:	a0 04 20 01 	inc  %l0                                       
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
4000a36c:	9f c6 00 00 	call  %i0                                      
4000a370:	01 00 00 00 	nop                                            
4000a374:	c4 14 60 10 	lduh  [ %l1 + 0x10 ], %g2                      
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
4000a378:	83 28 a0 10 	sll  %g2, 0x10, %g1                            
4000a37c:	83 30 60 10 	srl  %g1, 0x10, %g1                            
4000a380:	80 a0 40 10 	cmp  %g1, %l0                                  
4000a384:	3a bf ff f5 	bcc,a   4000a358 <rtems_iterate_over_all_threads+0x50>
4000a388:	c6 04 60 1c 	ld  [ %l1 + 0x1c ], %g3                        
4000a38c:	a4 04 a0 04 	add  %l2, 4, %l2                               
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
4000a390:	80 a4 80 13 	cmp  %l2, %l3                                  
4000a394:	32 bf ff e4 	bne,a   4000a324 <rtems_iterate_over_all_threads+0x1c>
4000a398:	c2 04 80 00 	ld  [ %l2 ], %g1                               
4000a39c:	81 c7 e0 08 	ret                                            
4000a3a0:	81 e8 00 00 	restore                                        
                                                                      

40008f7c <rtems_object_get_class_information>: rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) {
40008f7c:	9d e3 bf a0 	save  %sp, -96, %sp                            
40008f80:	90 10 00 18 	mov  %i0, %o0                                  
  int                  i;                                             
                                                                      
  /*                                                                  
   * Validate parameters and look up information structure.           
   */                                                                 
  if ( !info )                                                        
40008f84:	80 a6 a0 00 	cmp  %i2, 0                                    
40008f88:	02 80 00 21 	be  4000900c <rtems_object_get_class_information+0x90>
40008f8c:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  obj_info = _Objects_Get_information( the_api, the_class );          
40008f90:	93 2e 60 10 	sll  %i1, 0x10, %o1                            
  if ( !obj_info )                                                    
    return RTEMS_INVALID_NUMBER;                                      
40008f94:	b0 10 20 0a 	mov  0xa, %i0                                  
   * Validate parameters and look up information structure.           
   */                                                                 
  if ( !info )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  obj_info = _Objects_Get_information( the_api, the_class );          
40008f98:	40 00 07 75 	call  4000ad6c <_Objects_Get_information>      
40008f9c:	93 32 60 10 	srl  %o1, 0x10, %o1                            
  if ( !obj_info )                                                    
40008fa0:	80 a2 20 00 	cmp  %o0, 0                                    
40008fa4:	02 80 00 1a 	be  4000900c <rtems_object_get_class_information+0x90>
40008fa8:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
40008fac:	c4 02 20 0c 	ld  [ %o0 + 0xc ], %g2                         
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
40008fb0:	c8 12 20 10 	lduh  [ %o0 + 0x10 ], %g4                      
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
40008fb4:	c6 02 20 08 	ld  [ %o0 + 8 ], %g3                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
40008fb8:	c2 0a 20 12 	ldub  [ %o0 + 0x12 ], %g1                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
40008fbc:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]                           
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
40008fc0:	c6 26 80 00 	st  %g3, [ %i2 ]                               
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
40008fc4:	c2 2e a0 0c 	stb  %g1, [ %i2 + 0xc ]                        
  info->maximum     = obj_info->maximum;                              
40008fc8:	c8 26 a0 08 	st  %g4, [ %i2 + 8 ]                           
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008fcc:	80 a1 20 00 	cmp  %g4, 0                                    
40008fd0:	02 80 00 0d 	be  40009004 <rtems_object_get_class_information+0x88><== NEVER TAKEN
40008fd4:	84 10 20 00 	clr  %g2                                       
40008fd8:	da 02 20 1c 	ld  [ %o0 + 0x1c ], %o5                        
40008fdc:	86 10 20 01 	mov  1, %g3                                    
40008fe0:	82 10 20 01 	mov  1, %g1                                    
    if ( !obj_info->local_table[i] )                                  
40008fe4:	87 28 e0 02 	sll  %g3, 2, %g3                               
40008fe8:	c6 03 40 03 	ld  [ %o5 + %g3 ], %g3                         
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008fec:	82 00 60 01 	inc  %g1                                       
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
40008ff0:	80 a0 00 03 	cmp  %g0, %g3                                  
40008ff4:	84 60 bf ff 	subx  %g2, -1, %g2                             
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008ff8:	80 a1 00 01 	cmp  %g4, %g1                                  
40008ffc:	1a bf ff fa 	bcc  40008fe4 <rtems_object_get_class_information+0x68>
40009000:	86 10 00 01 	mov  %g1, %g3                                  
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
40009004:	c4 26 a0 10 	st  %g2, [ %i2 + 0x10 ]                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40009008:	b0 10 20 00 	clr  %i0                                       
}                                                                     
4000900c:	81 c7 e0 08 	ret                                            
40009010:	81 e8 00 00 	restore                                        
                                                                      

40014d58 <rtems_partition_create>: uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) {
40014d58:	9d e3 bf a0 	save  %sp, -96, %sp                            
40014d5c:	a0 10 00 18 	mov  %i0, %l0                                  
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
40014d60:	80 a4 20 00 	cmp  %l0, 0                                    
40014d64:	02 80 00 34 	be  40014e34 <rtems_partition_create+0xdc>     
40014d68:	b0 10 20 03 	mov  3, %i0                                    
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
40014d6c:	80 a6 60 00 	cmp  %i1, 0                                    
40014d70:	02 80 00 31 	be  40014e34 <rtems_partition_create+0xdc>     
40014d74:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
40014d78:	80 a7 60 00 	cmp  %i5, 0                                    
40014d7c:	02 80 00 2e 	be  40014e34 <rtems_partition_create+0xdc>     <== NEVER TAKEN
40014d80:	80 a6 e0 00 	cmp  %i3, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
40014d84:	02 80 00 2e 	be  40014e3c <rtems_partition_create+0xe4>     
40014d88:	80 a6 a0 00 	cmp  %i2, 0                                    
40014d8c:	02 80 00 2c 	be  40014e3c <rtems_partition_create+0xe4>     
40014d90:	80 a6 80 1b 	cmp  %i2, %i3                                  
40014d94:	0a 80 00 28 	bcs  40014e34 <rtems_partition_create+0xdc>    
40014d98:	b0 10 20 08 	mov  8, %i0                                    
40014d9c:	80 8e e0 07 	btst  7, %i3                                   
40014da0:	12 80 00 25 	bne  40014e34 <rtems_partition_create+0xdc>    
40014da4:	80 8e 60 07 	btst  7, %i1                                   
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
40014da8:	12 80 00 23 	bne  40014e34 <rtems_partition_create+0xdc>    
40014dac:	b0 10 20 09 	mov  9, %i0                                    
40014db0:	03 10 00 fb 	sethi  %hi(0x4003ec00), %g1                    
40014db4:	c4 00 62 80 	ld  [ %g1 + 0x280 ], %g2	! 4003ee80 <_Thread_Dispatch_disable_level>
40014db8:	84 00 a0 01 	inc  %g2                                       
40014dbc:	c4 20 62 80 	st  %g2, [ %g1 + 0x280 ]                       
 *  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 );
40014dc0:	25 10 00 fb 	sethi  %hi(0x4003ec00), %l2                    
40014dc4:	40 00 13 0d 	call  400199f8 <_Objects_Allocate>             
40014dc8:	90 14 a0 94 	or  %l2, 0x94, %o0	! 4003ec94 <_Partition_Information>
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
40014dcc:	a2 92 20 00 	orcc  %o0, 0, %l1                              
40014dd0:	02 80 00 1d 	be  40014e44 <rtems_partition_create+0xec>     
40014dd4:	92 10 00 1b 	mov  %i3, %o1                                  
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
40014dd8:	f8 24 60 1c 	st  %i4, [ %l1 + 0x1c ]                        
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
40014ddc:	f2 24 60 10 	st  %i1, [ %l1 + 0x10 ]                        
  the_partition->length                = length;                      
40014de0:	f4 24 60 14 	st  %i2, [ %l1 + 0x14 ]                        
  the_partition->buffer_size           = buffer_size;                 
40014de4:	f6 24 60 18 	st  %i3, [ %l1 + 0x18 ]                        
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
40014de8:	c0 24 60 20 	clr  [ %l1 + 0x20 ]                            
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
                        length / buffer_size, buffer_size );          
40014dec:	40 00 63 e0 	call  4002dd6c <.udiv>                         
40014df0:	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,        
40014df4:	92 10 00 19 	mov  %i1, %o1                                  
                        length / buffer_size, buffer_size );          
40014df8:	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,        
40014dfc:	96 10 00 1b 	mov  %i3, %o3                                  
40014e00:	b8 04 60 24 	add  %l1, 0x24, %i4                            
40014e04:	40 00 0c ce 	call  4001813c <_Chain_Initialize>             
40014e08:	90 10 00 1c 	mov  %i4, %o0                                  
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40014e0c:	c4 14 60 0a 	lduh  [ %l1 + 0xa ], %g2                       
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40014e10:	a4 14 a0 94 	or  %l2, 0x94, %l2                             
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40014e14:	c6 04 a0 1c 	ld  [ %l2 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40014e18:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40014e1c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40014e20:	e2 20 c0 02 	st  %l1, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
40014e24:	e0 24 60 0c 	st  %l0, [ %l1 + 0xc ]                         
    &_Partition_Information,                                          
    &the_partition->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_partition->Object.id;                                     
40014e28:	c2 27 40 00 	st  %g1, [ %i5 ]                               
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
40014e2c:	40 00 17 ec 	call  4001addc <_Thread_Enable_dispatch>       
40014e30:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
40014e34:	81 c7 e0 08 	ret                                            
40014e38:	81 e8 00 00 	restore                                        
}                                                                     
40014e3c:	81 c7 e0 08 	ret                                            
40014e40:	91 e8 20 08 	restore  %g0, 8, %o0                           
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
    _Thread_Enable_dispatch();                                        
40014e44:	40 00 17 e6 	call  4001addc <_Thread_Enable_dispatch>       
40014e48:	b0 10 20 05 	mov  5, %i0                                    
    return RTEMS_TOO_MANY;                                            
40014e4c:	81 c7 e0 08 	ret                                            
40014e50:	81 e8 00 00 	restore                                        
                                                                      

400083ec <rtems_rate_monotonic_period>: rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) {
400083ec:	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 );       
400083f0:	11 10 00 80 	sethi  %hi(0x40020000), %o0                    
400083f4:	92 10 00 18 	mov  %i0, %o1                                  
400083f8:	90 12 23 c4 	or  %o0, 0x3c4, %o0                            
400083fc:	40 00 09 6e 	call  4000a9b4 <_Objects_Get>                  
40008400:	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 ) {                                               
40008404:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008408:	80 a0 60 00 	cmp  %g1, 0                                    
4000840c:	02 80 00 04 	be  4000841c <rtems_rate_monotonic_period+0x30>
40008410:	a0 10 00 08 	mov  %o0, %l0                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40008414:	81 c7 e0 08 	ret                                            
40008418:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
                                                                      
  switch ( location ) {                                               
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
4000841c:	c4 02 20 40 	ld  [ %o0 + 0x40 ], %g2                        
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
40008420:	23 10 00 81 	sethi  %hi(0x40020400), %l1                    
40008424:	a2 14 63 5c 	or  %l1, 0x35c, %l1	! 4002075c <_Per_CPU_Information>
40008428:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
4000842c:	80 a0 80 01 	cmp  %g2, %g1                                  
40008430:	02 80 00 06 	be  40008448 <rtems_rate_monotonic_period+0x5c>
40008434:	80 a6 60 00 	cmp  %i1, 0                                    
        _Thread_Enable_dispatch();                                    
40008438:	40 00 0c f4 	call  4000b808 <_Thread_Enable_dispatch>       
4000843c:	b0 10 20 17 	mov  0x17, %i0                                 
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
40008440:	81 c7 e0 08 	ret                                            
40008444:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
40008448:	12 80 00 0f 	bne  40008484 <rtems_rate_monotonic_period+0x98>
4000844c:	01 00 00 00 	nop                                            
        switch ( the_period->state ) {                                
40008450:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40008454:	80 a0 60 04 	cmp  %g1, 4                                    
40008458:	08 80 00 06 	bleu  40008470 <rtems_rate_monotonic_period+0x84><== ALWAYS TAKEN
4000845c:	b0 10 20 00 	clr  %i0                                       
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
        the_period->next_length = length;                             
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
40008460:	40 00 0c ea 	call  4000b808 <_Thread_Enable_dispatch>       
40008464:	01 00 00 00 	nop                                            
        return RTEMS_TIMEOUT;                                         
40008468:	81 c7 e0 08 	ret                                            
4000846c:	81 e8 00 00 	restore                                        
        _Thread_Enable_dispatch();                                    
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
        switch ( the_period->state ) {                                
40008470:	83 28 60 02 	sll  %g1, 2, %g1                               
40008474:	05 10 00 79 	sethi  %hi(0x4001e400), %g2                    
40008478:	84 10 a1 e4 	or  %g2, 0x1e4, %g2	! 4001e5e4 <CSWTCH.2>      
4000847c:	10 bf ff f9 	b  40008460 <rtems_rate_monotonic_period+0x74> 
40008480:	f0 00 80 01 	ld  [ %g2 + %g1 ], %i0                         
        }                                                             
        _Thread_Enable_dispatch();                                    
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
40008484:	7f ff ea 1b 	call  40002cf0 <sparc_disable_interrupts>      
40008488:	01 00 00 00 	nop                                            
4000848c:	a6 10 00 08 	mov  %o0, %l3                                  
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
40008490:	e4 04 20 38 	ld  [ %l0 + 0x38 ], %l2                        
40008494:	80 a4 a0 00 	cmp  %l2, 0                                    
40008498:	02 80 00 14 	be  400084e8 <rtems_rate_monotonic_period+0xfc>
4000849c:	80 a4 a0 02 	cmp  %l2, 2                                    
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
400084a0:	02 80 00 29 	be  40008544 <rtems_rate_monotonic_period+0x158>
400084a4:	80 a4 a0 04 	cmp  %l2, 4                                    
                                                                      
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {            
400084a8:	12 bf ff e6 	bne  40008440 <rtems_rate_monotonic_period+0x54><== NEVER TAKEN
400084ac:	b0 10 20 04 	mov  4, %i0                                    
        /*                                                            
         *  Update statistics from the concluding period              
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
400084b0:	7f ff ff 8f 	call  400082ec <_Rate_monotonic_Update_statistics>
400084b4:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
        _ISR_Enable( level );                                         
400084b8:	7f ff ea 12 	call  40002d00 <sparc_enable_interrupts>       
400084bc:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
400084c0:	82 10 20 02 	mov  2, %g1                                    
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
400084c4:	92 04 20 10 	add  %l0, 0x10, %o1                            
400084c8:	11 10 00 81 	sethi  %hi(0x40020400), %o0                    
        the_period->next_length = length;                             
400084cc:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
400084d0:	90 12 21 f0 	or  %o0, 0x1f0, %o0                            
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
                                                                      
        _ISR_Enable( level );                                         
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
400084d4:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
400084d8:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
400084dc:	40 00 11 02 	call  4000c8e4 <_Watchdog_Insert>              
400084e0:	b0 10 20 06 	mov  6, %i0                                    
400084e4:	30 bf ff df 	b,a   40008460 <rtems_rate_monotonic_period+0x74>
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
        _ISR_Enable( level );                                         
400084e8:	7f ff ea 06 	call  40002d00 <sparc_enable_interrupts>       
400084ec:	01 00 00 00 	nop                                            
                                                                      
        /*                                                            
         *  Baseline statistics information for the beginning of a period.
         */                                                           
        _Rate_monotonic_Initiate_statistics( the_period );            
400084f0:	7f ff ff 63 	call  4000827c <_Rate_monotonic_Initiate_statistics>
400084f4:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
400084f8:	82 10 20 02 	mov  2, %g1                                    
400084fc:	92 04 20 10 	add  %l0, 0x10, %o1                            
40008500:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
40008504:	11 10 00 81 	sethi  %hi(0x40020400), %o0                    
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40008508:	03 10 00 22 	sethi  %hi(0x40008800), %g1                    
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000850c:	90 12 21 f0 	or  %o0, 0x1f0, %o0                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40008510:	82 10 60 c0 	or  %g1, 0xc0, %g1                             
  the_watchdog->id        = id;                                       
40008514:	f0 24 20 30 	st  %i0, [ %l0 + 0x30 ]                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40008518:	c2 24 20 2c 	st  %g1, [ %l0 + 0x2c ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
4000851c:	c0 24 20 18 	clr  [ %l0 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
40008520:	c0 24 20 34 	clr  [ %l0 + 0x34 ]                            
          _Rate_monotonic_Timeout,                                    
          id,                                                         
          NULL                                                        
        );                                                            
                                                                      
        the_period->next_length = length;                             
40008524:	f2 24 20 3c 	st  %i1, [ %l0 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40008528:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000852c:	40 00 10 ee 	call  4000c8e4 <_Watchdog_Insert>              
40008530:	b0 10 20 00 	clr  %i0                                       
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
40008534:	40 00 0c b5 	call  4000b808 <_Thread_Enable_dispatch>       
40008538:	01 00 00 00 	nop                                            
        return RTEMS_SUCCESSFUL;                                      
4000853c:	81 c7 e0 08 	ret                                            
40008540:	81 e8 00 00 	restore                                        
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
        /*                                                            
         *  Update statistics from the concluding period.             
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
40008544:	7f ff ff 6a 	call  400082ec <_Rate_monotonic_Update_statistics>
40008548:	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;         
4000854c:	82 10 20 01 	mov  1, %g1                                    
        the_period->next_length = length;                             
40008550:	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;         
40008554:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
        the_period->next_length = length;                             
                                                                      
        _ISR_Enable( level );                                         
40008558:	7f ff e9 ea 	call  40002d00 <sparc_enable_interrupts>       
4000855c:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
40008560:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
40008564:	c4 04 20 08 	ld  [ %l0 + 8 ], %g2                           
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40008568:	90 10 00 01 	mov  %g1, %o0                                  
4000856c:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
40008570:	40 00 0e e9 	call  4000c114 <_Thread_Set_state>             
40008574:	c4 20 60 20 	st  %g2, [ %g1 + 0x20 ]                        
                                                                      
        /*                                                            
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
40008578:	7f ff e9 de 	call  40002cf0 <sparc_disable_interrupts>      
4000857c:	01 00 00 00 	nop                                            
          local_state = the_period->state;                            
40008580:	e6 04 20 38 	ld  [ %l0 + 0x38 ], %l3                        
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
40008584:	e4 24 20 38 	st  %l2, [ %l0 + 0x38 ]                        
        _ISR_Enable( level );                                         
40008588:	7f ff e9 de 	call  40002d00 <sparc_enable_interrupts>       
4000858c:	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 )   
40008590:	80 a4 e0 03 	cmp  %l3, 3                                    
40008594:	22 80 00 06 	be,a   400085ac <rtems_rate_monotonic_period+0x1c0>
40008598:	d0 04 60 0c 	ld  [ %l1 + 0xc ], %o0                         
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
                                                                      
        _Thread_Enable_dispatch();                                    
4000859c:	40 00 0c 9b 	call  4000b808 <_Thread_Enable_dispatch>       
400085a0:	b0 10 20 00 	clr  %i0                                       
        return RTEMS_SUCCESSFUL;                                      
400085a4:	81 c7 e0 08 	ret                                            
400085a8:	81 e8 00 00 	restore                                        
        /*                                                            
         *  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 )   
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
400085ac:	40 00 0b bc 	call  4000b49c <_Thread_Clear_state>           
400085b0:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
400085b4:	30 bf ff fa 	b,a   4000859c <rtems_rate_monotonic_period+0x1b0>
                                                                      

400085b8 <rtems_rate_monotonic_report_statistics_with_plugin>: */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
400085b8:	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 )                                                       
400085bc:	80 a6 60 00 	cmp  %i1, 0                                    
400085c0:	02 80 00 4c 	be  400086f0 <rtems_rate_monotonic_report_statistics_with_plugin+0x138><== NEVER TAKEN
400085c4:	90 10 00 18 	mov  %i0, %o0                                  
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
400085c8:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
400085cc:	9f c6 40 00 	call  %i1                                      
400085d0:	92 12 61 f8 	or  %o1, 0x1f8, %o1	! 4001e5f8 <CSWTCH.2+0x14> 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
400085d4:	90 10 00 18 	mov  %i0, %o0                                  
400085d8:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
400085dc:	9f c6 40 00 	call  %i1                                      
400085e0:	92 12 62 18 	or  %o1, 0x218, %o1	! 4001e618 <CSWTCH.2+0x34> 
    (*print)( context, "--- Wall times are in seconds ---\n" );       
400085e4:	90 10 00 18 	mov  %i0, %o0                                  
400085e8:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
400085ec:	9f c6 40 00 	call  %i1                                      
400085f0:	92 12 62 40 	or  %o1, 0x240, %o1	! 4001e640 <CSWTCH.2+0x5c> 
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
400085f4:	90 10 00 18 	mov  %i0, %o0                                  
400085f8:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
400085fc:	9f c6 40 00 	call  %i1                                      
40008600:	92 12 62 68 	or  %o1, 0x268, %o1	! 4001e668 <CSWTCH.2+0x84> 
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
40008604:	90 10 00 18 	mov  %i0, %o0                                  
40008608:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
4000860c:	9f c6 40 00 	call  %i1                                      
40008610:	92 12 62 b8 	or  %o1, 0x2b8, %o1	! 4001e6b8 <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 ;                   
40008614:	23 10 00 80 	sethi  %hi(0x40020000), %l1                    
40008618:	a2 14 63 c4 	or  %l1, 0x3c4, %l1	! 400203c4 <_Rate_monotonic_Information>
4000861c:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
40008620:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
40008624:	80 a4 00 01 	cmp  %l0, %g1                                  
40008628:	18 80 00 32 	bgu  400086f0 <rtems_rate_monotonic_report_statistics_with_plugin+0x138><== NEVER TAKEN
4000862c:	2f 10 00 79 	sethi  %hi(0x4001e400), %l7                    
      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,                                              
40008630:	39 10 00 79 	sethi  %hi(0x4001e400), %i4                    
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
40008634:	2b 10 00 76 	sethi  %hi(0x4001d800), %l5                    
40008638:	a4 07 bf a0 	add  %fp, -96, %l2                             
    #if defined(RTEMS_DEBUG)                                          
      status = rtems_rate_monotonic_get_status( id, &the_status );    
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
4000863c:	ba 07 bf d8 	add  %fp, -40, %i5                             
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
40008640:	a6 07 bf f8 	add  %fp, -8, %l3                              
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
40008644:	ae 15 e3 08 	or  %l7, 0x308, %l7                            
    {                                                                 
    #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;         
40008648:	ac 07 bf b8 	add  %fp, -72, %l6                             
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
4000864c:	a8 07 bf f0 	add  %fp, -16, %l4                             
      (*print)( context,                                              
40008650:	b8 17 23 20 	or  %i4, 0x320, %i4                            
    {                                                                 
    #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;       
40008654:	b4 07 bf d0 	add  %fp, -48, %i2                             
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
40008658:	10 80 00 06 	b  40008670 <rtems_rate_monotonic_report_statistics_with_plugin+0xb8>
4000865c:	aa 15 60 e8 	or  %l5, 0xe8, %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 ;                   
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
40008660:	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 ;                   
40008664:	80 a0 40 10 	cmp  %g1, %l0                                  
40008668:	0a 80 00 22 	bcs  400086f0 <rtems_rate_monotonic_report_statistics_with_plugin+0x138>
4000866c:	01 00 00 00 	nop                                            
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
40008670:	90 10 00 10 	mov  %l0, %o0                                  
40008674:	40 00 19 48 	call  4000eb94 <rtems_rate_monotonic_get_statistics>
40008678:	92 10 00 12 	mov  %l2, %o1                                  
    if ( status != RTEMS_SUCCESSFUL )                                 
4000867c:	80 a2 20 00 	cmp  %o0, 0                                    
40008680:	32 bf ff f8 	bne,a   40008660 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
40008684:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
    #if defined(RTEMS_DEBUG)                                          
      status = rtems_rate_monotonic_get_status( id, &the_status );    
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
40008688:	92 10 00 1d 	mov  %i5, %o1                                  
4000868c:	40 00 19 71 	call  4000ec50 <rtems_rate_monotonic_get_status>
40008690:	90 10 00 10 	mov  %l0, %o0                                  
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
40008694:	d0 07 bf d8 	ld  [ %fp + -40 ], %o0                         
40008698:	94 10 00 13 	mov  %l3, %o2                                  
4000869c:	40 00 00 b9 	call  40008980 <rtems_object_get_name>         
400086a0:	92 10 20 05 	mov  5, %o1                                    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
400086a4:	d8 1f bf a0 	ldd  [ %fp + -96 ], %o4                        
400086a8:	92 10 00 17 	mov  %l7, %o1                                  
400086ac:	94 10 00 10 	mov  %l0, %o2                                  
400086b0:	90 10 00 18 	mov  %i0, %o0                                  
400086b4:	9f c6 40 00 	call  %i1                                      
400086b8:	96 10 00 13 	mov  %l3, %o3                                  
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
400086bc:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
      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 );
400086c0:	94 10 00 14 	mov  %l4, %o2                                  
400086c4:	90 10 00 16 	mov  %l6, %o0                                  
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
400086c8:	80 a0 60 00 	cmp  %g1, 0                                    
400086cc:	12 80 00 0b 	bne  400086f8 <rtems_rate_monotonic_report_statistics_with_plugin+0x140>
400086d0:	92 10 00 15 	mov  %l5, %o1                                  
      (*print)( context, "\n" );                                      
400086d4:	9f c6 40 00 	call  %i1                                      
400086d8:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   * 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 ;                   
400086dc:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
400086e0:	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 ;                   
400086e4:	80 a0 40 10 	cmp  %g1, %l0                                  
400086e8:	1a bf ff e3 	bcc  40008674 <rtems_rate_monotonic_report_statistics_with_plugin+0xbc><== ALWAYS TAKEN
400086ec:	90 10 00 10 	mov  %l0, %o0                                  
400086f0:	81 c7 e0 08 	ret                                            
400086f4:	81 e8 00 00 	restore                                        
      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 );
400086f8:	40 00 0f 3f 	call  4000c3f4 <_Timespec_Divide_by_integer>   
400086fc:	92 10 00 01 	mov  %g1, %o1                                  
      (*print)( context,                                              
40008700:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
40008704:	40 00 47 6c 	call  4001a4b4 <.div>                          
40008708:	92 10 23 e8 	mov  0x3e8, %o1                                
4000870c:	96 10 00 08 	mov  %o0, %o3                                  
40008710:	d0 07 bf b4 	ld  [ %fp + -76 ], %o0                         
40008714:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        
40008718:	40 00 47 67 	call  4001a4b4 <.div>                          
4000871c:	92 10 23 e8 	mov  0x3e8, %o1                                
40008720:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
40008724:	b6 10 00 08 	mov  %o0, %i3                                  
40008728:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
4000872c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40008730:	40 00 47 61 	call  4001a4b4 <.div>                          
40008734:	92 10 23 e8 	mov  0x3e8, %o1                                
40008738:	d8 07 bf b0 	ld  [ %fp + -80 ], %o4                         
4000873c:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        
40008740:	d4 07 bf a8 	ld  [ %fp + -88 ], %o2                         
40008744:	9a 10 00 1b 	mov  %i3, %o5                                  
40008748:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
4000874c:	92 10 00 1c 	mov  %i4, %o1                                  
40008750:	9f c6 40 00 	call  %i1                                      
40008754:	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);
40008758:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         
4000875c:	94 10 00 14 	mov  %l4, %o2                                  
40008760:	40 00 0f 25 	call  4000c3f4 <_Timespec_Divide_by_integer>   
40008764:	90 10 00 1a 	mov  %i2, %o0                                  
      (*print)( context,                                              
40008768:	d0 07 bf c4 	ld  [ %fp + -60 ], %o0                         
4000876c:	40 00 47 52 	call  4001a4b4 <.div>                          
40008770:	92 10 23 e8 	mov  0x3e8, %o1                                
40008774:	96 10 00 08 	mov  %o0, %o3                                  
40008778:	d0 07 bf cc 	ld  [ %fp + -52 ], %o0                         
4000877c:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        
40008780:	40 00 47 4d 	call  4001a4b4 <.div>                          
40008784:	92 10 23 e8 	mov  0x3e8, %o1                                
40008788:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
4000878c:	b6 10 00 08 	mov  %o0, %i3                                  
40008790:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
40008794:	92 10 23 e8 	mov  0x3e8, %o1                                
40008798:	40 00 47 47 	call  4001a4b4 <.div>                          
4000879c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
400087a0:	d4 07 bf c0 	ld  [ %fp + -64 ], %o2                         
400087a4:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        
400087a8:	d8 07 bf c8 	ld  [ %fp + -56 ], %o4                         
400087ac:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
400087b0:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
400087b4:	90 10 00 18 	mov  %i0, %o0                                  
400087b8:	92 12 63 40 	or  %o1, 0x340, %o1                            
400087bc:	9f c6 40 00 	call  %i1                                      
400087c0:	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 ;                   
400087c4:	10 bf ff a7 	b  40008660 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
400087c8:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
                                                                      

400087e8 <rtems_rate_monotonic_reset_all_statistics>: /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) {
400087e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
400087ec:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
400087f0:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 40020530 <_Thread_Dispatch_disable_level>
400087f4:	84 00 a0 01 	inc  %g2                                       
400087f8:	c4 20 61 30 	st  %g2, [ %g1 + 0x130 ]                       
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset 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 ;                 
400087fc:	23 10 00 80 	sethi  %hi(0x40020000), %l1                    
40008800:	a2 14 63 c4 	or  %l1, 0x3c4, %l1	! 400203c4 <_Rate_monotonic_Information>
40008804:	e0 04 60 08 	ld  [ %l1 + 8 ], %l0                           
40008808:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
4000880c:	80 a4 00 01 	cmp  %l0, %g1                                  
40008810:	18 80 00 09 	bgu  40008834 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
40008814:	01 00 00 00 	nop                                            
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
      (void) rtems_rate_monotonic_reset_statistics( id );             
40008818:	40 00 00 0a 	call  40008840 <rtems_rate_monotonic_reset_statistics>
4000881c:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset 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 ;                 
40008820:	c2 04 60 0c 	ld  [ %l1 + 0xc ], %g1                         
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
40008824:	a0 04 20 01 	inc  %l0                                       
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset 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 ;                 
40008828:	80 a0 40 10 	cmp  %g1, %l0                                  
4000882c:	1a bf ff fb 	bcc  40008818 <rtems_rate_monotonic_reset_all_statistics+0x30>
40008830:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
  /*                                                                  
   *  Done so exit thread dispatching disabled critical section.      
   */                                                                 
  _Thread_Enable_dispatch();                                          
40008834:	40 00 0b f5 	call  4000b808 <_Thread_Enable_dispatch>       
40008838:	81 e8 00 00 	restore                                        
                                                                      

40016378 <rtems_signal_send>: rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) {
40016378:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
4001637c:	80 a6 60 00 	cmp  %i1, 0                                    
40016380:	12 80 00 04 	bne  40016390 <rtems_signal_send+0x18>         
40016384:	82 10 20 0a 	mov  0xa, %g1                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40016388:	81 c7 e0 08 	ret                                            
4001638c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
40016390:	90 10 00 18 	mov  %i0, %o0                                  
40016394:	40 00 12 a0 	call  4001ae14 <_Thread_Get>                   
40016398:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4001639c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400163a0:	80 a0 60 00 	cmp  %g1, 0                                    
400163a4:	02 80 00 05 	be  400163b8 <rtems_signal_send+0x40>          
400163a8:	a2 10 00 08 	mov  %o0, %l1                                  
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
400163ac:	82 10 20 04 	mov  4, %g1                                    
}                                                                     
400163b0:	81 c7 e0 08 	ret                                            
400163b4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
400163b8:	e0 02 21 4c 	ld  [ %o0 + 0x14c ], %l0                       
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
400163bc:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
400163c0:	80 a0 60 00 	cmp  %g1, 0                                    
400163c4:	02 80 00 25 	be  40016458 <rtems_signal_send+0xe0>          
400163c8:	01 00 00 00 	nop                                            
        if ( asr->is_enabled ) {                                      
400163cc:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
400163d0:	80 a0 60 00 	cmp  %g1, 0                                    
400163d4:	02 80 00 15 	be  40016428 <rtems_signal_send+0xb0>          
400163d8:	01 00 00 00 	nop                                            
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
400163dc:	7f ff e2 b6 	call  4000eeb4 <sparc_disable_interrupts>      
400163e0:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
400163e4:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
400163e8:	b2 10 40 19 	or  %g1, %i1, %i1                              
400163ec:	f2 24 20 14 	st  %i1, [ %l0 + 0x14 ]                        
  _ISR_Enable( _level );                                              
400163f0:	7f ff e2 b5 	call  4000eec4 <sparc_enable_interrupts>       
400163f4:	01 00 00 00 	nop                                            
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
400163f8:	03 10 00 fc 	sethi  %hi(0x4003f000), %g1                    
400163fc:	82 10 60 b4 	or  %g1, 0xb4, %g1	! 4003f0b4 <_Per_CPU_Information>
40016400:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
40016404:	80 a0 a0 00 	cmp  %g2, 0                                    
40016408:	02 80 00 0f 	be  40016444 <rtems_signal_send+0xcc>          
4001640c:	01 00 00 00 	nop                                            
40016410:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40016414:	80 a4 40 02 	cmp  %l1, %g2                                  
40016418:	12 80 00 0b 	bne  40016444 <rtems_signal_send+0xcc>         <== NEVER TAKEN
4001641c:	84 10 20 01 	mov  1, %g2                                    
            _Thread_Dispatch_necessary = true;                        
40016420:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
40016424:	30 80 00 08 	b,a   40016444 <rtems_signal_send+0xcc>        
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
40016428:	7f ff e2 a3 	call  4000eeb4 <sparc_disable_interrupts>      
4001642c:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
40016430:	c2 04 20 18 	ld  [ %l0 + 0x18 ], %g1                        
40016434:	b2 10 40 19 	or  %g1, %i1, %i1                              
40016438:	f2 24 20 18 	st  %i1, [ %l0 + 0x18 ]                        
  _ISR_Enable( _level );                                              
4001643c:	7f ff e2 a2 	call  4000eec4 <sparc_enable_interrupts>       
40016440:	01 00 00 00 	nop                                            
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
40016444:	40 00 12 66 	call  4001addc <_Thread_Enable_dispatch>       
40016448:	01 00 00 00 	nop                                            
        return RTEMS_SUCCESSFUL;                                      
4001644c:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40016450:	81 c7 e0 08 	ret                                            
40016454:	91 e8 00 01 	restore  %g0, %g1, %o0                         
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
40016458:	40 00 12 61 	call  4001addc <_Thread_Enable_dispatch>       
4001645c:	01 00 00 00 	nop                                            
      return RTEMS_NOT_DEFINED;                                       
40016460:	10 bf ff ca 	b  40016388 <rtems_signal_send+0x10>           
40016464:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
                                                                      

4000ebfc <rtems_task_mode>: rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) {
4000ebfc:	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 )                                           
4000ec00:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ec04:	02 80 00 43 	be  4000ed10 <rtems_task_mode+0x114>           
4000ec08:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
4000ec0c:	27 10 00 59 	sethi  %hi(0x40016400), %l3                    
4000ec10:	a6 14 e2 2c 	or  %l3, 0x22c, %l3	! 4001662c <_Per_CPU_Information>
4000ec14:	e0 04 e0 0c 	ld  [ %l3 + 0xc ], %l0                         
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000ec18:	c4 0c 20 74 	ldub  [ %l0 + 0x74 ], %g2                      
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000ec1c:	c2 04 20 7c 	ld  [ %l0 + 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;
4000ec20:	80 a0 00 02 	cmp  %g0, %g2                                  
                                                                      
  if ( !previous_mode_set )                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
4000ec24:	e2 04 21 4c 	ld  [ %l0 + 0x14c ], %l1                       
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000ec28:	a4 60 3f ff 	subx  %g0, -1, %l2                             
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000ec2c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ec30:	12 80 00 3a 	bne  4000ed18 <rtems_task_mode+0x11c>          
4000ec34:	a5 2c a0 08 	sll  %l2, 8, %l2                               
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
4000ec38:	c2 0c 60 08 	ldub  [ %l1 + 8 ], %g1                         
4000ec3c:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
4000ec40:	7f ff f1 48 	call  4000b160 <_CPU_ISR_Get_level>            
4000ec44:	a8 60 3f ff 	subx  %g0, -1, %l4                             
  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;           
4000ec48:	a9 2d 20 0a 	sll  %l4, 0xa, %l4                             
4000ec4c:	a8 15 00 08 	or  %l4, %o0, %l4                              
  old_mode |= _ISR_Get_level();                                       
4000ec50:	a4 15 00 12 	or  %l4, %l2, %l2                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
4000ec54:	80 8e 61 00 	btst  0x100, %i1                               
4000ec58:	02 80 00 06 	be  4000ec70 <rtems_task_mode+0x74>            
4000ec5c:	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;           
4000ec60:	82 0e 21 00 	and  %i0, 0x100, %g1                           
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4000ec64:	80 a0 00 01 	cmp  %g0, %g1                                  
4000ec68:	82 60 3f ff 	subx  %g0, -1, %g1                             
4000ec6c:	c2 2c 20 74 	stb  %g1, [ %l0 + 0x74 ]                       
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
4000ec70:	80 8e 62 00 	btst  0x200, %i1                               
4000ec74:	02 80 00 0b 	be  4000eca0 <rtems_task_mode+0xa4>            
4000ec78:	80 8e 60 0f 	btst  0xf, %i1                                 
    if ( _Modes_Is_timeslice(mode_set) ) {                            
4000ec7c:	80 8e 22 00 	btst  0x200, %i0                               
4000ec80:	22 80 00 07 	be,a   4000ec9c <rtems_task_mode+0xa0>         
4000ec84:	c0 24 20 7c 	clr  [ %l0 + 0x7c ]                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
4000ec88:	03 10 00 58 	sethi  %hi(0x40016000), %g1                    
4000ec8c:	c2 00 63 64 	ld  [ %g1 + 0x364 ], %g1	! 40016364 <_Thread_Ticks_per_timeslice>
4000ec90:	c2 24 20 78 	st  %g1, [ %l0 + 0x78 ]                        
  if ( mask & RTEMS_PREEMPT_MASK )                                    
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
    if ( _Modes_Is_timeslice(mode_set) ) {                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000ec94:	82 10 20 01 	mov  1, %g1                                    
4000ec98:	c2 24 20 7c 	st  %g1, [ %l0 + 0x7c ]                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
4000ec9c:	80 8e 60 0f 	btst  0xf, %i1                                 
4000eca0:	12 80 00 3d 	bne  4000ed94 <rtems_task_mode+0x198>          
4000eca4:	01 00 00 00 	nop                                            
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
4000eca8:	80 8e 64 00 	btst  0x400, %i1                               
4000ecac:	02 80 00 14 	be  4000ecfc <rtems_task_mode+0x100>           
4000ecb0:	86 10 20 00 	clr  %g3                                       
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
4000ecb4:	c4 0c 60 08 	ldub  [ %l1 + 8 ], %g2                         
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Modes_Is_asr_disabled (                    
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
   return (mode_set & RTEMS_ASR_MASK) == RTEMS_NO_ASR;                
4000ecb8:	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(                                    
4000ecbc:	80 a0 00 18 	cmp  %g0, %i0                                  
4000ecc0:	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 ) {                        
4000ecc4:	80 a0 80 01 	cmp  %g2, %g1                                  
4000ecc8:	22 80 00 0e 	be,a   4000ed00 <rtems_task_mode+0x104>        
4000eccc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
)                                                                     
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
4000ecd0:	7f ff cc 60 	call  40001e50 <sparc_disable_interrupts>      
4000ecd4:	c2 2c 60 08 	stb  %g1, [ %l1 + 8 ]                          
    _signals                     = information->signals_pending;      
4000ecd8:	c4 04 60 18 	ld  [ %l1 + 0x18 ], %g2                        
    information->signals_pending = information->signals_posted;       
4000ecdc:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
    information->signals_posted  = _signals;                          
4000ece0:	c4 24 60 14 	st  %g2, [ %l1 + 0x14 ]                        
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
    _signals                     = information->signals_pending;      
    information->signals_pending = information->signals_posted;       
4000ece4:	c2 24 60 18 	st  %g1, [ %l1 + 0x18 ]                        
    information->signals_posted  = _signals;                          
  _ISR_Enable( _level );                                              
4000ece8:	7f ff cc 5e 	call  40001e60 <sparc_enable_interrupts>       
4000ecec:	01 00 00 00 	nop                                            
      asr->is_enabled = is_asr_enabled;                               
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
4000ecf0:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
                                                                      
  /*                                                                  
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
4000ecf4:	80 a0 00 01 	cmp  %g0, %g1                                  
4000ecf8:	86 40 20 00 	addx  %g0, 0, %g3                              
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
4000ecfc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
4000ed00:	c4 00 61 58 	ld  [ %g1 + 0x158 ], %g2	! 40016558 <_System_state_Current>
4000ed04:	80 a0 a0 03 	cmp  %g2, 3                                    
4000ed08:	02 80 00 11 	be  4000ed4c <rtems_task_mode+0x150>           
4000ed0c:	82 10 20 00 	clr  %g1                                       
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000ed10:	81 c7 e0 08 	ret                                            
4000ed14:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  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;           
4000ed18:	c2 0c 60 08 	ldub  [ %l1 + 8 ], %g1                         
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
4000ed1c:	a4 14 a2 00 	or  %l2, 0x200, %l2                            
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
4000ed20:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
4000ed24:	7f ff f1 0f 	call  4000b160 <_CPU_ISR_Get_level>            
4000ed28:	a8 60 3f ff 	subx  %g0, -1, %l4                             
  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;           
4000ed2c:	a9 2d 20 0a 	sll  %l4, 0xa, %l4                             
4000ed30:	a8 15 00 08 	or  %l4, %o0, %l4                              
  old_mode |= _ISR_Get_level();                                       
4000ed34:	a4 15 00 12 	or  %l4, %l2, %l2                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
4000ed38:	80 8e 61 00 	btst  0x100, %i1                               
4000ed3c:	02 bf ff cd 	be  4000ec70 <rtems_task_mode+0x74>            
4000ed40:	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;           
4000ed44:	10 bf ff c8 	b  4000ec64 <rtems_task_mode+0x68>             
4000ed48:	82 0e 21 00 	and  %i0, 0x100, %g1                           
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
                                                                      
  if ( are_signals_pending ||                                         
4000ed4c:	80 88 e0 ff 	btst  0xff, %g3                                
4000ed50:	12 80 00 0a 	bne  4000ed78 <rtems_task_mode+0x17c>          
4000ed54:	c4 04 e0 0c 	ld  [ %l3 + 0xc ], %g2                         
4000ed58:	c6 04 e0 10 	ld  [ %l3 + 0x10 ], %g3                        
4000ed5c:	80 a0 80 03 	cmp  %g2, %g3                                  
4000ed60:	02 bf ff ec 	be  4000ed10 <rtems_task_mode+0x114>           
4000ed64:	01 00 00 00 	nop                                            
       (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4000ed68:	c4 08 a0 74 	ldub  [ %g2 + 0x74 ], %g2                      
4000ed6c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ed70:	02 bf ff e8 	be  4000ed10 <rtems_task_mode+0x114>           <== NEVER TAKEN
4000ed74:	01 00 00 00 	nop                                            
    _Thread_Dispatch_necessary = true;                                
4000ed78:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
4000ed7c:	c2 2c e0 18 	stb  %g1, [ %l3 + 0x18 ]                       
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
4000ed80:	7f ff ea e1 	call  40009904 <_Thread_Dispatch>              
4000ed84:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000ed88:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
}                                                                     
4000ed8c:	81 c7 e0 08 	ret                                            
4000ed90:	91 e8 00 01 	restore  %g0, %g1, %o0                         
 */                                                                   
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (           
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  return ( mode_set & RTEMS_INTERRUPT_MASK );                         
4000ed94:	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 ) );           
4000ed98:	7f ff cc 32 	call  40001e60 <sparc_enable_interrupts>       
4000ed9c:	91 2a 20 08 	sll  %o0, 8, %o0                               
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
4000eda0:	10 bf ff c3 	b  4000ecac <rtems_task_mode+0xb0>             
4000eda4:	80 8e 64 00 	btst  0x400, %i1                               
                                                                      

4000c07c <rtems_task_set_priority>: rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) {
4000c07c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
4000c080:	80 a6 60 00 	cmp  %i1, 0                                    
4000c084:	02 80 00 07 	be  4000c0a0 <rtems_task_set_priority+0x24>    
4000c088:	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 ) );             
4000c08c:	03 10 00 69 	sethi  %hi(0x4001a400), %g1                    
4000c090:	c2 08 61 24 	ldub  [ %g1 + 0x124 ], %g1	! 4001a524 <rtems_maximum_priority>
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
4000c094:	80 a6 40 01 	cmp  %i1, %g1                                  
4000c098:	18 80 00 1c 	bgu  4000c108 <rtems_task_set_priority+0x8c>   
4000c09c:	b0 10 20 13 	mov  0x13, %i0                                 
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
4000c0a0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c0a4:	02 80 00 19 	be  4000c108 <rtems_task_set_priority+0x8c>    
4000c0a8:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000c0ac:	40 00 09 a3 	call  4000e738 <_Thread_Get>                   
4000c0b0:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000c0b4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000c0b8:	80 a0 60 00 	cmp  %g1, 0                                    
4000c0bc:	12 80 00 13 	bne  4000c108 <rtems_task_set_priority+0x8c>   
4000c0c0:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
4000c0c4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
4000c0c8:	80 a6 60 00 	cmp  %i1, 0                                    
4000c0cc:	02 80 00 0d 	be  4000c100 <rtems_task_set_priority+0x84>    
4000c0d0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
4000c0d4:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
4000c0d8:	80 a0 60 00 	cmp  %g1, 0                                    
4000c0dc:	02 80 00 06 	be  4000c0f4 <rtems_task_set_priority+0x78>    
4000c0e0:	f2 22 20 18 	st  %i1, [ %o0 + 0x18 ]                        
4000c0e4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000c0e8:	80 a6 40 01 	cmp  %i1, %g1                                  
4000c0ec:	1a 80 00 05 	bcc  4000c100 <rtems_task_set_priority+0x84>   <== ALWAYS TAKEN
4000c0f0:	01 00 00 00 	nop                                            
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
4000c0f4:	92 10 00 19 	mov  %i1, %o1                                  
4000c0f8:	40 00 08 5d 	call  4000e26c <_Thread_Change_priority>       
4000c0fc:	94 10 20 00 	clr  %o2                                       
      }                                                               
      _Thread_Enable_dispatch();                                      
4000c100:	40 00 09 80 	call  4000e700 <_Thread_Enable_dispatch>       
4000c104:	b0 10 20 00 	clr  %i0                                       
      return RTEMS_SUCCESSFUL;                                        
4000c108:	81 c7 e0 08 	ret                                            
4000c10c:	81 e8 00 00 	restore                                        
                                                                      

40008430 <rtems_task_variable_delete>: rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) {
40008430:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
40008434:	80 a6 60 00 	cmp  %i1, 0                                    
40008438:	02 80 00 1e 	be  400084b0 <rtems_task_variable_delete+0x80> 
4000843c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  prev = NULL;                                                        
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
40008440:	90 10 00 18 	mov  %i0, %o0                                  
40008444:	40 00 09 2b 	call  4000a8f0 <_Thread_Get>                   
40008448:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch (location) {                                                 
4000844c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008450:	80 a0 60 00 	cmp  %g1, 0                                    
40008454:	12 80 00 19 	bne  400084b8 <rtems_task_variable_delete+0x88>
40008458:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
4000845c:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
      while (tvp) {                                                   
40008460:	80 a0 60 00 	cmp  %g1, 0                                    
40008464:	02 80 00 10 	be  400084a4 <rtems_task_variable_delete+0x74> 
40008468:	01 00 00 00 	nop                                            
        if (tvp->ptr == ptr) {                                        
4000846c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40008470:	80 a0 80 19 	cmp  %g2, %i1                                  
40008474:	32 80 00 09 	bne,a   40008498 <rtems_task_variable_delete+0x68>
40008478:	d2 00 40 00 	ld  [ %g1 ], %o1                               
          if (prev)                                                   
            prev->next = tvp->next;                                   
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
4000847c:	10 80 00 19 	b  400084e0 <rtems_task_variable_delete+0xb0>  
40008480:	c4 00 40 00 	ld  [ %g1 ], %g2                               
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
40008484:	80 a0 80 19 	cmp  %g2, %i1                                  
40008488:	22 80 00 0e 	be,a   400084c0 <rtems_task_variable_delete+0x90>
4000848c:	c4 02 40 00 	ld  [ %o1 ], %g2                               
40008490:	82 10 00 09 	mov  %o1, %g1                                  
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
40008494:	d2 00 40 00 	ld  [ %g1 ], %o1                               
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
40008498:	80 a2 60 00 	cmp  %o1, 0                                    
4000849c:	32 bf ff fa 	bne,a   40008484 <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
400084a0:	c4 02 60 04 	ld  [ %o1 + 4 ], %g2                           
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
400084a4:	40 00 09 05 	call  4000a8b8 <_Thread_Enable_dispatch>       
400084a8:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_ADDRESS;                                   
400084ac:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400084b0:	81 c7 e0 08 	ret                                            
400084b4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
400084b8:	81 c7 e0 08 	ret                                            
400084bc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
          if (prev)                                                   
            prev->next = tvp->next;                                   
400084c0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
                                                                      
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
400084c4:	40 00 00 2e 	call  4000857c <_RTEMS_Tasks_Invoke_task_variable_dtor>
400084c8:	01 00 00 00 	nop                                            
          _Thread_Enable_dispatch();                                  
400084cc:	40 00 08 fb 	call  4000a8b8 <_Thread_Enable_dispatch>       
400084d0:	01 00 00 00 	nop                                            
          return RTEMS_SUCCESSFUL;                                    
400084d4:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400084d8:	81 c7 e0 08 	ret                                            
400084dc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
          if (prev)                                                   
            prev->next = tvp->next;                                   
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
400084e0:	92 10 00 01 	mov  %g1, %o1                                  
400084e4:	10 bf ff f8 	b  400084c4 <rtems_task_variable_delete+0x94>  
400084e8:	c4 22 21 58 	st  %g2, [ %o0 + 0x158 ]                       
                                                                      

400084ec <rtems_task_variable_get>: rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) {
400084ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
400084f0:	90 10 00 18 	mov  %i0, %o0                                  
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp;                                         
                                                                      
  if ( !ptr )                                                         
400084f4:	80 a6 60 00 	cmp  %i1, 0                                    
400084f8:	02 80 00 1b 	be  40008564 <rtems_task_variable_get+0x78>    
400084fc:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !result )                                                      
40008500:	80 a6 a0 00 	cmp  %i2, 0                                    
40008504:	02 80 00 1c 	be  40008574 <rtems_task_variable_get+0x88>    
40008508:	01 00 00 00 	nop                                            
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
4000850c:	40 00 08 f9 	call  4000a8f0 <_Thread_Get>                   
40008510:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch (location) {                                                 
40008514:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008518:	80 a0 60 00 	cmp  %g1, 0                                    
4000851c:	12 80 00 12 	bne  40008564 <rtems_task_variable_get+0x78>   
40008520:	b0 10 20 04 	mov  4, %i0                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is in this task's list.          
       */                                                             
      tvp = the_thread->task_variables;                               
40008524:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
      while (tvp) {                                                   
40008528:	80 a0 60 00 	cmp  %g1, 0                                    
4000852c:	32 80 00 07 	bne,a   40008548 <rtems_task_variable_get+0x5c>
40008530:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40008534:	30 80 00 0e 	b,a   4000856c <rtems_task_variable_get+0x80>  
40008538:	80 a0 60 00 	cmp  %g1, 0                                    
4000853c:	02 80 00 0c 	be  4000856c <rtems_task_variable_get+0x80>    <== NEVER TAKEN
40008540:	01 00 00 00 	nop                                            
        if (tvp->ptr == ptr) {                                        
40008544:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40008548:	80 a0 80 19 	cmp  %g2, %i1                                  
4000854c:	32 bf ff fb 	bne,a   40008538 <rtems_task_variable_get+0x4c>
40008550:	c2 00 40 00 	ld  [ %g1 ], %g1                               
	  /*                                                                 
	   * Should this return the current (i.e not the                     
	   * saved) value if `tid' is the current task?                      
	   */                                                                
          *result = tvp->tval;                                        
40008554:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
40008558:	b0 10 20 00 	clr  %i0                                       
	  /*                                                                 
	   * Should this return the current (i.e not the                     
	   * saved) value if `tid' is the current task?                      
	   */                                                                
          *result = tvp->tval;                                        
          _Thread_Enable_dispatch();                                  
4000855c:	40 00 08 d7 	call  4000a8b8 <_Thread_Enable_dispatch>       
40008560:	c2 26 80 00 	st  %g1, [ %i2 ]                               
          return RTEMS_SUCCESSFUL;                                    
40008564:	81 c7 e0 08 	ret                                            
40008568:	81 e8 00 00 	restore                                        
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
4000856c:	40 00 08 d3 	call  4000a8b8 <_Thread_Enable_dispatch>       
40008570:	b0 10 20 09 	mov  9, %i0                                    
      return RTEMS_INVALID_ADDRESS;                                   
40008574:	81 c7 e0 08 	ret                                            
40008578:	81 e8 00 00 	restore                                        
                                                                      

40016dd4 <rtems_timer_cancel>: */ rtems_status_code rtems_timer_cancel( rtems_id id ) {
40016dd4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
    _Objects_Get( &_Timer_Information, id, location );                
40016dd8:	11 10 00 fc 	sethi  %hi(0x4003f000), %o0                    
40016ddc:	92 10 00 18 	mov  %i0, %o1                                  
40016de0:	90 12 21 44 	or  %o0, 0x144, %o0                            
40016de4:	40 00 0c 69 	call  40019f88 <_Objects_Get>                  
40016de8:	94 07 bf fc 	add  %fp, -4, %o2                              
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40016dec:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40016df0:	80 a0 60 00 	cmp  %g1, 0                                    
40016df4:	22 80 00 04 	be,a   40016e04 <rtems_timer_cancel+0x30>      
40016df8:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40016dfc:	81 c7 e0 08 	ret                                            
40016e00:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
40016e04:	80 a0 60 04 	cmp  %g1, 4                                    
40016e08:	02 80 00 04 	be  40016e18 <rtems_timer_cancel+0x44>         <== NEVER TAKEN
40016e0c:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &the_timer->Ticker );                
40016e10:	40 00 14 fa 	call  4001c1f8 <_Watchdog_Remove>              
40016e14:	90 02 20 10 	add  %o0, 0x10, %o0                            
      _Thread_Enable_dispatch();                                      
40016e18:	40 00 0f f1 	call  4001addc <_Thread_Enable_dispatch>       
40016e1c:	b0 10 20 00 	clr  %i0                                       
      return RTEMS_SUCCESSFUL;                                        
40016e20:	81 c7 e0 08 	ret                                            
40016e24:	81 e8 00 00 	restore                                        
                                                                      

400172ec <rtems_timer_server_fire_when>: rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
400172ec:	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;                 
400172f0:	03 10 00 fc 	sethi  %hi(0x4003f000), %g1                    
400172f4:	e0 00 61 84 	ld  [ %g1 + 0x184 ], %l0	! 4003f184 <_Timer_server>
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
400172f8:	a2 10 00 18 	mov  %i0, %l1                                  
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
400172fc:	80 a4 20 00 	cmp  %l0, 0                                    
40017300:	02 80 00 10 	be  40017340 <rtems_timer_server_fire_when+0x54>
40017304:	b0 10 20 0e 	mov  0xe, %i0                                  
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
40017308:	03 10 00 fb 	sethi  %hi(0x4003ec00), %g1                    
4001730c:	c2 08 62 90 	ldub  [ %g1 + 0x290 ], %g1	! 4003ee90 <_TOD_Is_set>
40017310:	80 a0 60 00 	cmp  %g1, 0                                    
40017314:	02 80 00 0b 	be  40017340 <rtems_timer_server_fire_when+0x54><== NEVER TAKEN
40017318:	b0 10 20 0b 	mov  0xb, %i0                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
4001731c:	80 a6 a0 00 	cmp  %i2, 0                                    
40017320:	02 80 00 08 	be  40017340 <rtems_timer_server_fire_when+0x54>
40017324:	b0 10 20 09 	mov  9, %i0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
40017328:	90 10 00 19 	mov  %i1, %o0                                  
4001732c:	7f ff f3 b3 	call  400141f8 <_TOD_Validate>                 
40017330:	b0 10 20 14 	mov  0x14, %i0                                 
40017334:	80 8a 20 ff 	btst  0xff, %o0                                
40017338:	12 80 00 04 	bne  40017348 <rtems_timer_server_fire_when+0x5c>
4001733c:	01 00 00 00 	nop                                            
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40017340:	81 c7 e0 08 	ret                                            
40017344:	81 e8 00 00 	restore                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
40017348:	7f ff f3 76 	call  40014120 <_TOD_To_seconds>               
4001734c:	90 10 00 19 	mov  %i1, %o0                                  
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
40017350:	25 10 00 fb 	sethi  %hi(0x4003ec00), %l2                    
40017354:	c2 04 a3 08 	ld  [ %l2 + 0x308 ], %g1	! 4003ef08 <_TOD_Now> 
40017358:	80 a2 00 01 	cmp  %o0, %g1                                  
4001735c:	08 bf ff f9 	bleu  40017340 <rtems_timer_server_fire_when+0x54>
40017360:	b2 10 00 08 	mov  %o0, %i1                                  
40017364:	92 10 00 11 	mov  %l1, %o1                                  
40017368:	11 10 00 fc 	sethi  %hi(0x4003f000), %o0                    
4001736c:	94 07 bf fc 	add  %fp, -4, %o2                              
40017370:	40 00 0b 06 	call  40019f88 <_Objects_Get>                  
40017374:	90 12 21 44 	or  %o0, 0x144, %o0                            
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40017378:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001737c:	80 a0 60 00 	cmp  %g1, 0                                    
40017380:	12 80 00 16 	bne  400173d8 <rtems_timer_server_fire_when+0xec>
40017384:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
40017388:	40 00 13 9c 	call  4001c1f8 <_Watchdog_Remove>              
4001738c:	90 02 20 10 	add  %o0, 0x10, %o0                            
      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();
40017390:	c4 04 a3 08 	ld  [ %l2 + 0x308 ], %g2                       
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
40017394:	c2 04 20 04 	ld  [ %l0 + 4 ], %g1                           
40017398:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
    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();
4001739c:	b2 26 40 02 	sub  %i1, %g2, %i1                             
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
400173a0:	90 10 00 10 	mov  %l0, %o0                                  
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
400173a4:	84 10 20 03 	mov  3, %g2                                    
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
400173a8:	f4 26 20 2c 	st  %i2, [ %i0 + 0x2c ]                        
400173ac:	c4 26 20 38 	st  %g2, [ %i0 + 0x38 ]                        
  the_watchdog->id        = id;                                       
400173b0:	e2 26 20 30 	st  %l1, [ %i0 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
400173b4:	f6 26 20 34 	st  %i3, [ %i0 + 0x34 ]                        
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
400173b8:	f2 26 20 1c 	st  %i1, [ %i0 + 0x1c ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
400173bc:	c0 26 20 18 	clr  [ %i0 + 0x18 ]                            
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
400173c0:	9f c0 40 00 	call  %g1                                      
400173c4:	b0 10 20 00 	clr  %i0                                       
                                                                      
      _Thread_Enable_dispatch();                                      
400173c8:	40 00 0e 85 	call  4001addc <_Thread_Enable_dispatch>       
400173cc:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
400173d0:	81 c7 e0 08 	ret                                            
400173d4:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400173d8:	81 c7 e0 08 	ret                                            
400173dc:	91 e8 20 04 	restore  %g0, 4, %o0