===============================================================================
40005c74 <_POSIX_Condition_variables_Auto_initialization>:
           
#include <string.h>
                                                  

                                                                     
bool _POSIX_Condition_variables_Auto_initialization(
                 
  POSIX_Condition_variables_Control *the_cond
                        
)
                                                                    
{
                                                                    
40005c74:	9d e3 bf 80 	save  %sp, -128, %sp
                          <== NOT EXECUTED
  POSIX_Condition_variables_Control zero;
                            
  unsigned long                     flags;
                           

                                                                     
  memset( &zero, 0, sizeof( zero ) );
                                

                                                                     
  if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
       
40005c78:	94 10 20 1c 	mov  0x1c, %o2
                                <== NOT EXECUTED
  memset( &zero, 0, sizeof( zero ) );
                                
40005c7c:	c0 27 bf e4 	clr  [ %fp + -28 ]
                            <== NOT EXECUTED
  if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
       
40005c80:	92 07 bf e4 	add  %fp, -28, %o1
                            <== NOT EXECUTED
  memset( &zero, 0, sizeof( zero ) );
                                
40005c84:	c0 27 bf e8 	clr  [ %fp + -24 ]
                            <== NOT EXECUTED
  if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
       
40005c88:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  memset( &zero, 0, sizeof( zero ) );
                                
40005c8c:	c0 27 bf ec 	clr  [ %fp + -20 ]
                            <== NOT EXECUTED
40005c90:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
40005c94:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
40005c98:	c0 27 bf f8 	clr  [ %fp + -8 ]
                             <== NOT EXECUTED
  if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
       
40005c9c:	40 00 20 68 	call  4000de3c <memcmp>
                       <== NOT EXECUTED
40005ca0:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
40005ca4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40005ca8:	12 80 00 08 	bne  40005cc8 <_POSIX_Condition_variables_Auto_initialization+0x54>
<== NOT EXECUTED
40005cac:	82 10 20 00 	clr  %g1
                                      <== NOT EXECUTED
    return false;
                                                    
  }
                                                                  

                                                                     
  flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
    
40005cb0:	03 06 37 ec 	sethi  %hi(0x18dfb000), %g1
                   <== NOT EXECUTED
40005cb4:	82 10 61 fe 	or  %g1, 0x1fe, %g1	! 18dfb1fe <RAM_SIZE+0x189fb1fe>
<== NOT EXECUTED
40005cb8:	82 1e 00 01 	xor  %i0, %g1, %g1
                            <== NOT EXECUTED
  flags &= ~POSIX_CONDITION_VARIABLES_FLAGS_MASK;
                    
40005cbc:	82 08 7f fe 	and  %g1, -2, %g1
                             <== NOT EXECUTED
  the_cond->flags = flags;
                                           
40005cc0:	c2 26 00 00 	st  %g1, [ %i0 ]
                              <== NOT EXECUTED
  return true;
                                                       
40005cc4:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
}
                                                                    
40005cc8:	b0 08 60 01 	and  %g1, 1, %i0
                              <== NOT EXECUTED
40005ccc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005cd0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000fb40 <_POSIX_Condition_variables_Default_attributes>:
            
4000fb40:	00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 01     ................

	...
                                                                 

                                                                     
===============================================================================
40005b94 <_POSIX_Condition_variables_Signal_support>:
                

                                                                     
int _POSIX_Condition_variables_Signal_support(
                       
  pthread_cond_t            *cond,
                                   
  bool                       is_broadcast
                            
)
                                                                    
{
                                                                    
40005b94:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  unsigned long                      flags;
                          
  const Thread_queue_Operations     *operations;
                     
  Thread_queue_Heads                *heads;
                          

                                                                     
  the_cond = _POSIX_Condition_variables_Get( cond );
                 
  POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
      
40005b98:	80 a6 20 00 	cmp  %i0, 0
                                   
40005b9c:	02 80 00 28 	be  40005c3c <_POSIX_Condition_variables_Signal_support+0xa8>
<== NEVER TAKEN
40005ba0:	05 06 37 ec 	sethi  %hi(0x18dfb000), %g2
                   
40005ba4:	c2 06 00 00 	ld  [ %i0 ], %g1
                              
40005ba8:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40005bac:	84 10 a1 fe 	or  %g2, 0x1fe, %g2
                           
40005bb0:	82 18 40 02 	xor  %g1, %g2, %g1
                            
40005bb4:	80 88 7f fe 	btst  -2, %g1
                                 
40005bb8:	12 80 00 1c 	bne  40005c28 <_POSIX_Condition_variables_Signal_support+0x94>
<== NEVER TAKEN
40005bbc:	3b 10 00 3e 	sethi  %hi(0x4000f800), %i5
                   <== NOT EXECUTED

                                                                     
    if ( heads != NULL ) {
                                           
      Thread_Control *the_thread;
                                    

                                                                     
      the_thread = ( *operations->first )( heads );
                  
      _Thread_queue_Extract_critical(
                                
40005bc0:	b8 06 20 0c 	add  %i0, 0xc, %i4
                            <== NOT EXECUTED
      the_thread = ( *operations->first )( heads );
                  
40005bc4:	ba 17 61 fc 	or  %i5, 0x1fc, %i5
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005bc8:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
)
                                                                    
{
                                                                    
#if defined( RTEMS_SMP )
                                             
  context->Lock_context.isr_level = level;
                           
#else
                                                                
  context->isr_level = level;
                                        
40005bcc:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        
    heads = the_cond->Queue.Queue.heads;
                             
40005bd0:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1
                        
    if ( heads != NULL ) {
                                           
40005bd4:	90 90 60 00 	orcc  %g1, 0, %o0
                             
40005bd8:	22 80 00 0f 	be,a   40005c14 <_POSIX_Condition_variables_Signal_support+0x80>

40005bdc:	c0 26 20 18 	clr  [ %i0 + 0x18 ]
                           
      the_thread = ( *operations->first )( heads );
                  
40005be0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1
                       
40005be4:	9f c0 40 00 	call  %g1
                                     
40005be8:	01 00 00 00 	nop 
                                          
      _Thread_queue_Extract_critical(
                                
40005bec:	96 07 bf dc 	add  %fp, -36, %o3
                            
40005bf0:	94 10 00 08 	mov  %o0, %o2
                                 
40005bf4:	92 10 00 1d 	mov  %i5, %o1
                                 
40005bf8:	40 00 10 17 	call  40009c54 <_Thread_queue_Extract_critical>

40005bfc:	90 10 00 1c 	mov  %i4, %o0
                                 
      );
                                                             
    } else {
                                                         
      the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
          
      _POSIX_Condition_variables_Release( the_cond, &queue_context );

    }
                                                                
  } while ( is_broadcast && heads != NULL );
                         
40005c00:	80 a6 60 00 	cmp  %i1, 0
                                   
40005c04:	12 bf ff f1 	bne  40005bc8 <_POSIX_Condition_variables_Signal_support+0x34>

40005c08:	01 00 00 00 	nop 
                                          

                                                                     
  return 0;
                                                          
}
                                                                    
40005c0c:	81 c7 e0 08 	ret 
                                          
40005c10:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40005c14:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005c18:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005c1c:	01 00 00 00 	nop 
                                          
40005c20:	81 c7 e0 08 	ret 
                                          
40005c24:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
      
40005c28:	40 00 00 07 	call  40005c44 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
40005c2c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40005c30:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40005c34:	12 bf ff e3 	bne  40005bc0 <_POSIX_Condition_variables_Signal_support+0x2c>
<== NOT EXECUTED
40005c38:	3b 10 00 3e 	sethi  %hi(0x4000f800), %i5
                   <== NOT EXECUTED
40005c3c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005c40:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
40005e18 <_POSIX_Condition_variables_Wait_support>:
                  
int _POSIX_Condition_variables_Wait_support(
                         
  pthread_cond_t            *cond,
                                   
  pthread_mutex_t           *mutex,
                                  
  const struct timespec     *abstime
                                 
)
                                                                    
{
                                                                    
40005e18:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  Thread_queue_Context               queue_context;
                  
  int                                error;
                          
  Thread_Control                    *executing;
                      

                                                                     
  the_cond = _POSIX_Condition_variables_Get( cond );
                 
  POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
      
40005e1c:	80 a6 20 00 	cmp  %i0, 0
                                   
40005e20:	02 80 00 44 	be  40005f30 <_POSIX_Condition_variables_Wait_support+0x118>
<== NEVER TAKEN
40005e24:	05 06 37 ec 	sethi  %hi(0x18dfb000), %g2
                   
40005e28:	fa 06 00 00 	ld  [ %i0 ], %i5
                              
40005e2c:	82 1e 00 1d 	xor  %i0, %i5, %g1
                            
40005e30:	84 10 a1 fe 	or  %g2, 0x1fe, %g2
                           
40005e34:	82 18 40 02 	xor  %g1, %g2, %g1
                            
40005e38:	80 88 7f fe 	btst  -2, %g1
                                 
40005e3c:	12 80 00 38 	bne  40005f1c <_POSIX_Condition_variables_Wait_support+0x104>
<== NEVER TAKEN
40005e40:	80 a6 a0 00 	cmp  %i2, 0
                                   

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                

                                                                     
  if ( abstime != NULL ) {
                                           
40005e44:	02 80 00 3d 	be  40005f38 <_POSIX_Condition_variables_Wait_support+0x120>

40005e48:	80 8f 60 01 	btst  1, %i5
                                  

                                                                     
RTEMS_INLINE_ROUTINE clockid_t _POSIX_Condition_variables_Get_clock(
 
  unsigned long flags
                                                
)
                                                                    
{
                                                                    
  if ( ( flags & POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC ) != 0 ) {

40005e4c:	12 80 00 13 	bne  40005e98 <_POSIX_Condition_variables_Wait_support+0x80>
<== NEVER TAKEN
40005e50:	f4 27 bf e8 	st  %i2, [ %fp + -24 ]
                        <== NOT EXECUTED
  queue_context->enqueue_callout = enqueue_callout;
                  
40005e54:	03 10 00 17 	sethi  %hi(0x40005c00), %g1
                   <== NOT EXECUTED
40005e58:	82 10 61 d8 	or  %g1, 0x1d8, %g1	! 40005dd8 <_POSIX_Condition_variables_Enqueue_with_timeout_realtime>
<== NOT EXECUTED
40005e5c:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005e60:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
40005e64:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        
  }
                                                                  

                                                                     
  executing = _POSIX_Condition_variables_Acquire( the_cond, &queue_context );


                                                                     
  if (
                                                               
    the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
            
40005e68:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       
      && the_cond->mutex != mutex
                                    
40005e6c:	80 a0 40 19 	cmp  %g1, %i1
                                 
40005e70:	02 80 00 13 	be  40005ebc <_POSIX_Condition_variables_Wait_support+0xa4>

40005e74:	84 10 00 06 	mov  %g6, %g2
                                 
40005e78:	80 a0 60 00 	cmp  %g1, 0
                                   
40005e7c:	22 80 00 11 	be,a   40005ec0 <_POSIX_Condition_variables_Wait_support+0xa8>
<== ALWAYS TAKEN
40005e80:	fa 00 a0 20 	ld  [ %g2 + 0x20 ], %i5
                       
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40005e84:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005e88:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005e8c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  ) {
                                                                
    _POSIX_Condition_variables_Release( the_cond, &queue_context );
  
    return EINVAL;
                                                   
40005e90:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005e94:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
40005e98:	03 10 00 17 	sethi  %hi(0x40005c00), %g1
                   <== NOT EXECUTED
40005e9c:	82 10 61 f8 	or  %g1, 0x1f8, %g1	! 40005df8 <_POSIX_Condition_variables_Enqueue_with_timeout_monotonic>
<== NOT EXECUTED
40005ea0:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005ea4:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
40005ea8:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        <== NOT EXECUTED
    the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
            
40005eac:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       <== NOT EXECUTED
      && the_cond->mutex != mutex
                                    
40005eb0:	80 a0 40 19 	cmp  %g1, %i1
                                 <== NOT EXECUTED
40005eb4:	12 bf ff f1 	bne  40005e78 <_POSIX_Condition_variables_Wait_support+0x60>
<== NOT EXECUTED
40005eb8:	84 10 00 06 	mov  %g6, %g2
                                 <== NOT EXECUTED
  ISR_Level       level;
                                             
  Thread_Control *executing;
                                         

                                                                     
  _Thread_queue_Context_ISR_disable( queue_context, level );
         
  _Thread_queue_Context_set_ISR_level( queue_context, level );
       
  executing = _Thread_Executing;
                                     
40005ebc:	fa 00 a0 20 	ld  [ %g2 + 0x20 ], %i5
                       
  }
                                                                  

                                                                     
  the_cond->mutex = mutex;
                                           
40005ec0:	f2 26 20 18 	st  %i1, [ %i0 + 0x18 ]
                       
  queue_context->thread_state = thread_state;
                        
40005ec4:	82 10 20 20 	mov  0x20, %g1
                                

                                                                     
  _Thread_queue_Context_set_thread_state(
                            
    &queue_context,
                                                  
    STATES_WAITING_FOR_CONDITION_VARIABLE
                            
  );
                                                                 
  _Thread_queue_Enqueue(
                                             
40005ec8:	90 06 20 0c 	add  %i0, 0xc, %o0
                            
40005ecc:	96 07 bf dc 	add  %fp, -36, %o3
                            
40005ed0:	c2 27 bf e0 	st  %g1, [ %fp + -32 ]
                        
40005ed4:	94 10 00 1d 	mov  %i5, %o2
                                 
40005ed8:	13 10 00 42 	sethi  %hi(0x40010800), %o1
                   
40005edc:	40 00 14 5a 	call  4000b044 <_Thread_queue_Enqueue>
        
40005ee0:	92 12 61 0c 	or  %o1, 0x10c, %o1	! 4001090c <_Thread_queue_Operations_FIFO>

  return _POSIX_Get_by_name_error_table[ error ];
                    
}
                                                                    

                                                                     
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
   
{
                                                                    
  return STATUS_GET_POSIX( status );
                                 
40005ee4:	f0 07 60 4c 	ld  [ %i5 + 0x4c ], %i0
                       
40005ee8:	b1 3e 20 08 	sra  %i0, 8, %i0
                              
   *  according to the POSIX standard. It means that pthread_cond_wait

   *  returns a success status, except for the fact that it was not
  
   *  woken up a pthread_cond_signal() or a pthread_cond_broadcast().

   */
                                                                

                                                                     
  if ( error == EINTR ) {
                                            
40005eec:	80 a6 20 04 	cmp  %i0, 4
                                   
40005ef0:	02 80 00 18 	be  40005f50 <_POSIX_Condition_variables_Wait_support+0x138>
<== NEVER TAKEN
40005ef4:	80 a6 20 01 	cmp  %i0, 1
                                   

                                                                     
  /*
                                                                 
   *  When we get here the dispatch disable level is 0.
              
   */
                                                                

                                                                     
  if ( error != EPERM ) {
                                            
40005ef8:	02 80 00 14 	be  40005f48 <_POSIX_Condition_variables_Wait_support+0x130>
<== NEVER TAKEN
40005efc:	01 00 00 00 	nop 
                                          
    int mutex_error;
                                                 

                                                                     
    mutex_error = pthread_mutex_lock( mutex );
                       
40005f00:	40 00 00 f0 	call  400062c0 <pthread_mutex_lock>
           
40005f04:	90 10 00 19 	mov  %i1, %o0
                                 
    if ( mutex_error != 0 ) {
                                        
40005f08:	80 a2 20 00 	cmp  %o0, 0
                                   
40005f0c:	12 80 00 09 	bne  40005f30 <_POSIX_Condition_variables_Wait_support+0x118>
<== NEVER TAKEN
40005f10:	01 00 00 00 	nop 
                                          
      error = EINVAL;
                                                
    }
                                                                
  }
                                                                  

                                                                     
  return error;
                                                      
}
                                                                    
40005f14:	81 c7 e0 08 	ret 
                                          
40005f18:	81 e8 00 00 	restore 
                                      
  POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
      
40005f1c:	7f ff ff 85 	call  40005d30 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
40005f20:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40005f24:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40005f28:	12 bf ff c7 	bne  40005e44 <_POSIX_Condition_variables_Wait_support+0x2c>
<== NOT EXECUTED
40005f2c:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
}
                                                                    
40005f30:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005f34:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
  queue_context->enqueue_callout = enqueue_callout;
                  
40005f38:	03 10 00 17 	sethi  %hi(0x40005c00), %g1
                   
40005f3c:	82 10 61 cc 	or  %g1, 0x1cc, %g1	! 40005dcc <_POSIX_Condition_variables_Enqueue_no_timeout>

40005f40:	10 bf ff c8 	b  40005e60 <_POSIX_Condition_variables_Wait_support+0x48>

40005f44:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        
40005f48:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005f4c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    error = 0;
                                                       
40005f50:	10 bf ff ec 	b  40005f00 <_POSIX_Condition_variables_Wait_support+0xe8>
<== NOT EXECUTED
40005f54:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40011a78 <_POSIX_Get_by_name_error_table>:
                           
40011a78:	00 00 00 16 00 00 00 5b 00 00 00 02                 .......[....


                                                                     
===============================================================================
40005e88 <_POSIX_Keys_Key_value_allocate>:
                           
  uint32_t max = Configuration.maximum_key_value_pairs;
              
40005e88:	03 10 00 3d 	sethi  %hi(0x4000f400), %g1
                   
40005e8c:	c2 00 60 b0 	ld  [ %g1 + 0xb0 ], %g1	! 4000f4b0 <Configuration+0x10>

    _Objects_Maximum_per_allocation( max ) : 0;
                      
40005e90:	80 a0 60 00 	cmp  %g1, 0
                                   
40005e94:	16 80 00 05 	bge  40005ea8 <_POSIX_Keys_Key_value_allocate+0x20>
<== ALWAYS TAKEN
40005e98:	94 10 20 00 	clr  %o2
                                      
40005e9c:	15 00 00 3f 	sethi  %hi(0xfc00), %o2
                       <== NOT EXECUTED
40005ea0:	94 12 a3 ff 	or  %o2, 0x3ff, %o2	! ffff <_Configuration_Interrupt_stack_size+0xefff>
<== NOT EXECUTED
40005ea4:	94 08 40 0a 	and  %g1, %o2, %o2
                            <== NOT EXECUTED
  return (POSIX_Keys_Key_value_pair *) _Freechain_Get(
               
40005ea8:	13 10 00 2c 	sethi  %hi(0x4000b000), %o1
                   
40005eac:	11 10 00 49 	sethi  %hi(0x40012400), %o0
                   
40005eb0:	96 10 20 24 	mov  0x24, %o3
                                
40005eb4:	92 12 61 cc 	or  %o1, 0x1cc, %o1
                           
40005eb8:	90 12 23 7c 	or  %o0, 0x37c, %o0
                           
40005ebc:	82 13 c0 00 	mov  %o7, %g1
                                 
40005ec0:	40 00 01 4e 	call  400063f8 <_Freechain_Get>
               
40005ec4:	9e 10 40 00 	mov  %g1, %o7
                                 

                                                                     
===============================================================================
40006198 <_POSIX_Message_queue_Delete>:
                              

                                                                     
void _POSIX_Message_queue_Delete(
                                    
  POSIX_Message_queue_Control *the_mq,
                               
  Thread_queue_Context        *queue_context
                         
)
                                                                    
{
                                                                    
40006198:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  if ( !the_mq->linked && the_mq->open_count == 0 ) {
                
4000619c:	c2 0e 20 4c 	ldub  [ %i0 + 0x4c ], %g1
                     
400061a0:	80 a0 60 00 	cmp  %g1, 0
                                   
400061a4:	12 80 00 06 	bne  400061bc <_POSIX_Message_queue_Delete+0x24>

400061a8:	01 00 00 00 	nop 
                                          
400061ac:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1
                       
400061b0:	80 a0 60 00 	cmp  %g1, 0
                                   
400061b4:	02 80 00 07 	be  400061d0 <_POSIX_Message_queue_Delete+0x38>

400061b8:	92 10 00 19 	mov  %i1, %o1
                                 
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400061bc:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400061c0:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400061c4:	01 00 00 00 	nop 
                                          
    _CORE_message_queue_Close( &the_mq->Message_queue, queue_context );

    _POSIX_Message_queue_Free( the_mq );
                             
  } else {
                                                           
    _CORE_message_queue_Release( &the_mq->Message_queue, queue_context );

  }
                                                                  
}
                                                                    
400061c8:	81 c7 e0 08 	ret 
                                          
400061cc:	81 e8 00 00 	restore 
                                      
    _CORE_message_queue_Close( &the_mq->Message_queue, queue_context );

400061d0:	90 06 20 10 	add  %i0, 0x10, %o0
                           
400061d4:	40 00 02 4f 	call  40006b10 <_CORE_message_queue_Close>
    
400061d8:	b2 10 00 18 	mov  %i0, %i1
                                 
  _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );

400061dc:	31 10 00 52 	sethi  %hi(0x40014800), %i0
                   
400061e0:	40 00 0a 1f 	call  40008a5c <_Objects_Free>
                
400061e4:	91 ee 21 d0 	restore  %i0, 0x1d0, %o0
                      

                                                                     
===============================================================================
4000653c <_POSIX_Message_queue_Receive_support>:
                     
  size_t                        msg_len,
                             
  unsigned int                 *msg_prio,
                            
  const struct timespec        *abstime,
                             
  Thread_queue_Enqueue_callout  enqueue_callout
                      
)
                                                                    
{
                                                                    
4000653c:	9d e3 bf 70 	save  %sp, -144, %sp
                          
  return (POSIX_Message_queue_Control *) _Objects_Get(
               
40006540:	15 10 00 52 	sethi  %hi(0x40014800), %o2
                   
40006544:	92 07 bf dc 	add  %fp, -36, %o1
                            
40006548:	94 12 a1 d0 	or  %o2, 0x1d0, %o2
                           
4000654c:	40 00 09 70 	call  40008b0c <_Objects_Get>
                 
40006550:	90 10 00 18 	mov  %i0, %o0
                                 
  Thread_Control              *executing;
                            
  Status_Control               status;
                               

                                                                     
  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
        

                                                                     
  if ( the_mq == NULL ) {
                                            
40006554:	80 a2 20 00 	cmp  %o0, 0
                                   
40006558:	02 80 00 2c 	be  40006608 <_POSIX_Message_queue_Receive_support+0xcc>
<== NEVER TAKEN
4000655c:	01 00 00 00 	nop 
                                          
    rtems_set_errno_and_return_minus_one( EBADF );
                   
  }
                                                                  

                                                                     
  if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) {
                 
40006560:	d8 02 20 68 	ld  [ %o0 + 0x68 ], %o4
                       
40006564:	82 0b 20 03 	and  %o4, 3, %g1
                              
40006568:	80 a0 60 01 	cmp  %g1, 1
                                   
4000656c:	02 80 00 24 	be  400065fc <_POSIX_Message_queue_Receive_support+0xc0>
<== NEVER TAKEN
40006570:	01 00 00 00 	nop 
                                          
    _ISR_lock_ISR_enable( &queue_context.Lock_context.Lock_context );

    rtems_set_errno_and_return_minus_one( EBADF );
                   
  }
                                                                  

                                                                     
  if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
      
40006574:	c2 02 20 28 	ld  [ %o0 + 0x28 ], %g1
                       
40006578:	80 a0 40 1a 	cmp  %g1, %i2
                                 
4000657c:	18 80 00 29 	bgu  40006620 <_POSIX_Message_queue_Receive_support+0xe4>
<== NEVER TAKEN
40006580:	82 10 3f ff 	mov  -1, %g1
                                  
_Thread_queue_Context_set_enqueue_callout(
                           
  Thread_queue_Context         *queue_context,
                       
  Thread_queue_Enqueue_callout  enqueue_callout
                      
)
                                                                    
{
                                                                    
  queue_context->enqueue_callout = enqueue_callout;
                  
40006584:	fa 27 bf e4 	st  %i5, [ %fp + -28 ]
                        

                                                                     
  /*
                                                                 
   *  Now if something goes wrong, we return a "length" of -1
        
   *  to indicate an error.
                                          
   */
                                                                
  length_out = -1;
                                                   
40006588:	c2 27 bf d8 	st  %g1, [ %fp + -40 ]
                        
  queue_context->Timeout.arg = arg;
                                  
4000658c:	f8 27 bf e8 	st  %i4, [ %fp + -24 ]
                        
  _CORE_message_queue_Acquire_critical(
                              
    &the_mq->Message_queue,
                                          
    &queue_context
                                                   
  );
                                                                 

                                                                     
  if ( the_mq->open_count == 0 ) {
                                   
40006590:	c2 02 20 50 	ld  [ %o0 + 0x50 ], %g1
                       
40006594:	80 a0 60 00 	cmp  %g1, 0
                                   
40006598:	02 80 00 19 	be  400065fc <_POSIX_Message_queue_Receive_support+0xc0>
<== NEVER TAKEN
4000659c:	84 02 20 10 	add  %o0, 0x10, %g2
                           
  }
                                                                  

                                                                     
  /*
                                                                 
   *  Now perform the actual message receive
                         
   */
                                                                
  executing = _Thread_Executing;
                                     
400065a0:	fa 01 a0 20 	ld  [ %g6 + 0x20 ], %i5
                       
  status = _CORE_message_queue_Seize(
                                
400065a4:	99 33 20 0e 	srl  %o4, 0xe, %o4
                            
400065a8:	9a 07 bf dc 	add  %fp, -36, %o5
                            
400065ac:	98 1b 20 01 	xor  %o4, 1, %o4
                              
400065b0:	96 07 bf d8 	add  %fp, -40, %o3
                            
400065b4:	98 0b 20 01 	and  %o4, 1, %o4
                              
400065b8:	94 10 00 19 	mov  %i1, %o2
                                 
400065bc:	92 10 00 1d 	mov  %i5, %o1
                                 
400065c0:	40 00 01 8e 	call  40006bf8 <_CORE_message_queue_Seize>
    
400065c4:	90 10 00 02 	mov  %g2, %o0
                                 
    &length_out,
                                                     
    ( the_mq->oflag & O_NONBLOCK ) == 0,
                             
    &queue_context
                                                   
  );
                                                                 

                                                                     
  if ( status != STATUS_SUCCESSFUL ) {
                               
400065c8:	80 92 00 09 	orcc  %o0, %o1, %g0
                           
400065cc:	12 80 00 1e 	bne  40006644 <_POSIX_Message_queue_Receive_support+0x108>
<== NEVER TAKEN
400065d0:	80 a6 e0 00 	cmp  %i3, 0
                                   
    rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );

  }
                                                                  

                                                                     
  if ( msg_prio != NULL ) {
                                          
400065d4:	22 80 00 08 	be,a   400065f4 <_POSIX_Message_queue_Receive_support+0xb8>
<== NEVER TAKEN
400065d8:	f0 07 bf d8 	ld  [ %fp + -40 ], %i0
                        <== NOT EXECUTED
  return (unsigned int) ((priority >= 0) ? priority : -priority);
    
400065dc:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1
                       
400065e0:	85 38 60 1f 	sra  %g1, 0x1f, %g2
                           
400065e4:	82 18 80 01 	xor  %g2, %g1, %g1
                            
400065e8:	82 20 40 02 	sub  %g1, %g2, %g1
                            
    *msg_prio = _POSIX_Message_queue_Priority_from_core(
             
400065ec:	c2 26 c0 00 	st  %g1, [ %i3 ]
                              
      executing->Wait.count
                                          
    );
                                                               
  }
                                                                  

                                                                     
  return length_out;
                                                 
400065f0:	f0 07 bf d8 	ld  [ %fp + -40 ], %i0
                        
}
                                                                    
400065f4:	81 c7 e0 08 	ret 
                                          
400065f8:	81 e8 00 00 	restore 
                                      
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400065fc:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006600:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006604:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBADF );
                   
40006608:	40 00 25 7a 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000660c:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
40006610:	82 10 20 09 	mov  9, %g1
                                   <== NOT EXECUTED
40006614:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006618:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000661c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006620:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006624:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006628:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EMSGSIZE );
                
4000662c:	40 00 25 71 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006630:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
40006634:	82 10 20 7a 	mov  0x7a, %g1
                                <== NOT EXECUTED
40006638:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000663c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006640:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );

40006644:	40 00 25 6b 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006648:	d2 27 bf d4 	st  %o1, [ %fp + -44 ]
                        <== NOT EXECUTED
}
                                                                    

                                                                     
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
   
{
                                                                    
  return STATUS_GET_POSIX( status );
                                 
4000664c:	d2 07 bf d4 	ld  [ %fp + -44 ], %o1
                        <== NOT EXECUTED
40006650:	93 3a 60 08 	sra  %o1, 8, %o1
                              <== NOT EXECUTED
40006654:	d2 22 00 00 	st  %o1, [ %o0 ]
                              <== NOT EXECUTED
40006658:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000665c:	91 e8 3f ff 	restore  %g0, -1, %o0
                         <== NOT EXECUTED

                                                                     
===============================================================================
40006678 <_POSIX_Message_queue_Send_support>:
                        
  size_t                        msg_len,
                             
  unsigned int                  msg_prio,
                            
  const struct timespec        *abstime,
                             
  Thread_queue_Enqueue_callout  enqueue_callout
                      
)
                                                                    
{
                                                                    
40006678:	9d e3 bf 68 	save  %sp, -152, %sp
                          
  /*
                                                                 
   * Validate the priority.
                                          
   * XXX - Do not validate msg_prio is not less than 0.
              
   */
                                                                

                                                                     
  if ( msg_prio > MQ_PRIO_MAX ) {
                                    
4000667c:	80 a6 e0 20 	cmp  %i3, 0x20
                                
40006680:	18 80 00 34 	bgu  40006750 <_POSIX_Message_queue_Send_support+0xd8>
<== NEVER TAKEN
40006684:	92 07 bf dc 	add  %fp, -36, %o1
                            
  return (POSIX_Message_queue_Control *) _Objects_Get(
               
40006688:	15 10 00 52 	sethi  %hi(0x40014800), %o2
                   
4000668c:	90 10 00 18 	mov  %i0, %o0
                                 
40006690:	40 00 09 1f 	call  40008b0c <_Objects_Get>
                 
40006694:	94 12 a1 d0 	or  %o2, 0x1d0, %o2
                           
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
  }
                                                                  

                                                                     
  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
        

                                                                     
  if ( the_mq == NULL ) {
                                            
40006698:	80 a2 20 00 	cmp  %o0, 0
                                   
4000669c:	02 80 00 27 	be  40006738 <_POSIX_Message_queue_Send_support+0xc0>
<== NEVER TAKEN
400066a0:	01 00 00 00 	nop 
                                          
    rtems_set_errno_and_return_minus_one( EBADF );
                   
  }
                                                                  

                                                                     
  if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) {
                 
400066a4:	da 02 20 68 	ld  [ %o0 + 0x68 ], %o5
                       
400066a8:	80 8b 60 03 	btst  3, %o5
                                  
400066ac:	02 80 00 20 	be  4000672c <_POSIX_Message_queue_Send_support+0xb4>
<== NEVER TAKEN
400066b0:	01 00 00 00 	nop 
                                          
  queue_context->enqueue_callout = enqueue_callout;
                  
400066b4:	fa 27 bf e4 	st  %i5, [ %fp + -28 ]
                        
  queue_context->Timeout.arg = arg;
                                  
400066b8:	f8 27 bf e8 	st  %i4, [ %fp + -24 ]
                        
  _CORE_message_queue_Acquire_critical(
                              
    &the_mq->Message_queue,
                                          
    &queue_context
                                                   
  );
                                                                 

                                                                     
  if ( the_mq->open_count == 0 ) {
                                   
400066bc:	c2 02 20 50 	ld  [ %o0 + 0x50 ], %g1
                       
400066c0:	80 a0 60 00 	cmp  %g1, 0
                                   
400066c4:	02 80 00 1a 	be  4000672c <_POSIX_Message_queue_Send_support+0xb4>
<== NEVER TAKEN
400066c8:	84 02 20 10 	add  %o0, 0x10, %g2
                           

                                                                     
  /*
                                                                 
   *  Now perform the actual message receive
                         
   */
                                                                
  executing = _Thread_Executing;
                                     
  status = _CORE_message_queue_Submit(
                               
400066cc:	82 07 bf dc 	add  %fp, -36, %g1
                            
400066d0:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]
                       
400066d4:	9b 33 60 0e 	srl  %o5, 0xe, %o5
                            
400066d8:	d2 01 a0 20 	ld  [ %g6 + 0x20 ], %o1
                       
400066dc:	9a 1b 60 01 	xor  %o5, 1, %o5
                              
400066e0:	98 20 00 1b 	neg  %i3, %o4
                                 
400066e4:	9a 0b 60 01 	and  %o5, 1, %o5
                              
400066e8:	96 10 00 1a 	mov  %i2, %o3
                                 
400066ec:	94 10 00 19 	mov  %i1, %o2
                                 
400066f0:	90 10 00 02 	mov  %g2, %o0
                                 
400066f4:	40 00 01 8d 	call  40006d28 <_CORE_message_queue_Submit>
   
400066f8:	b0 10 20 00 	clr  %i0
                                      

                                                                     
RTEMS_INLINE_ROUTINE int _POSIX_Zero_or_minus_one_plus_errno(
        
  Status_Control status
                                              
)
                                                                    
{
                                                                    
  if ( status == STATUS_SUCCESSFUL ) {
                               
400066fc:	80 92 00 09 	orcc  %o0, %o1, %g0
                           
40006700:	12 80 00 04 	bne  40006710 <_POSIX_Message_queue_Send_support+0x98>
<== NEVER TAKEN
40006704:	01 00 00 00 	nop 
                                          
    _POSIX_Message_queue_Priority_to_core( msg_prio ),
               
    ( the_mq->oflag & O_NONBLOCK ) == 0,
                             
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Zero_or_minus_one_plus_errno( status );
              
}
                                                                    
40006708:	81 c7 e0 08 	ret 
                                          
4000670c:	81 e8 00 00 	restore 
                                      
    return 0;
                                                        
  }
                                                                  

                                                                     
  rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );

40006710:	40 00 25 38 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006714:	d2 27 bf d4 	st  %o1, [ %fp + -44 ]
                        <== NOT EXECUTED
  return STATUS_GET_POSIX( status );
                                 
40006718:	d2 07 bf d4 	ld  [ %fp + -44 ], %o1
                        <== NOT EXECUTED
4000671c:	93 3a 60 08 	sra  %o1, 8, %o1
                              <== NOT EXECUTED
  rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );

40006720:	d2 22 00 00 	st  %o1, [ %o0 ]
                              <== NOT EXECUTED
40006724:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006728:	91 e8 3f ff 	restore  %g0, -1, %o0
                         <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000672c:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006730:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006734:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBADF );
                   
40006738:	40 00 25 2e 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000673c:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
40006740:	82 10 20 09 	mov  9, %g1
                                   <== NOT EXECUTED
40006744:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006748:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000674c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
40006750:	40 00 25 28 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006754:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40006758:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
4000675c:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006760:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006764:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006570 <_POSIX_Mutex_Auto_initialization>:
                         
#include <rtems/posix/posixapi.h>
                                    

                                                                     
#include <string.h>
                                                  

                                                                     
bool _POSIX_Mutex_Auto_initialization( POSIX_Mutex_Control *the_mutex )

{
                                                                    
40006570:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_right;

  zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_parent;

  zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_color;

  zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
      
  zero |= (unsigned long) (the_mutex->Priority_ceiling.priority >> 32);

  zero |= (unsigned long) the_mutex->scheduler;
                      
40006574:	f2 06 20 04 	ld  [ %i0 + 4 ], %i1
                          <== NOT EXECUTED
  zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
      
40006578:	de 06 20 30 	ld  [ %i0 + 0x30 ], %o7
                       <== NOT EXECUTED
4000657c:	da 06 20 34 	ld  [ %i0 + 0x34 ], %o5
                       <== NOT EXECUTED
  zero |= (unsigned long) the_mutex->scheduler;
                      
40006580:	c4 06 00 00 	ld  [ %i0 ], %g2
                              <== NOT EXECUTED
40006584:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2
                          <== NOT EXECUTED
40006588:	d6 06 20 18 	ld  [ %i0 + 0x18 ], %o3
                       <== NOT EXECUTED
4000658c:	f4 06 20 0c 	ld  [ %i0 + 0xc ], %i2
                        <== NOT EXECUTED
40006590:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3
                       <== NOT EXECUTED
40006594:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4
                       <== NOT EXECUTED
40006598:	fa 06 20 20 	ld  [ %i0 + 0x20 ], %i5
                       <== NOT EXECUTED
4000659c:	c8 06 20 24 	ld  [ %i0 + 0x24 ], %g4
                       <== NOT EXECUTED
400065a0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1
                       <== NOT EXECUTED
400065a4:	d8 06 20 2c 	ld  [ %i0 + 0x2c ], %o4
                       <== NOT EXECUTED
400065a8:	c6 06 20 38 	ld  [ %i0 + 0x38 ], %g3
                       <== NOT EXECUTED
400065ac:	84 10 80 19 	or  %g2, %i1, %g2
                             <== NOT EXECUTED
400065b0:	84 10 80 0a 	or  %g2, %o2, %g2
                             <== NOT EXECUTED
400065b4:	84 10 80 0b 	or  %g2, %o3, %g2
                             <== NOT EXECUTED
400065b8:	84 16 80 02 	or  %i2, %g2, %g2
                             <== NOT EXECUTED
400065bc:	84 16 c0 02 	or  %i3, %g2, %g2
                             <== NOT EXECUTED
400065c0:	84 17 00 02 	or  %i4, %g2, %g2
                             <== NOT EXECUTED
400065c4:	84 17 40 02 	or  %i5, %g2, %g2
                             <== NOT EXECUTED
400065c8:	84 11 00 02 	or  %g4, %g2, %g2
                             <== NOT EXECUTED
400065cc:	82 10 40 02 	or  %g1, %g2, %g1
                             <== NOT EXECUTED
400065d0:	82 10 40 0c 	or  %g1, %o4, %g1
                             <== NOT EXECUTED
400065d4:	82 10 40 0d 	or  %g1, %o5, %g1
                             <== NOT EXECUTED
400065d8:	82 10 c0 01 	or  %g3, %g1, %g1
                             <== NOT EXECUTED

                                                                     
  if ( zero != 0 ) {
                                                 
400065dc:	80 90 40 0f 	orcc  %g1, %o7, %g0
                           <== NOT EXECUTED
400065e0:	12 80 00 08 	bne  40006600 <_POSIX_Mutex_Auto_initialization+0x90>
<== NOT EXECUTED
400065e4:	b2 10 20 00 	clr  %i1
                                      <== NOT EXECUTED
    return false;
                                                    
  }
                                                                  

                                                                     
  flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
                 
400065e8:	03 25 87 04 	sethi  %hi(0x961c1000), %g1
                   <== NOT EXECUTED
400065ec:	82 10 63 b8 	or  %g1, 0x3b8, %g1	! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
400065f0:	82 1e 00 01 	xor  %i0, %g1, %g1
                            <== NOT EXECUTED
  flags &= ~POSIX_MUTEX_FLAGS_MASK;
                                  
400065f4:	82 08 7f f8 	and  %g1, -8, %g1
                             <== NOT EXECUTED
  the_mutex->flags = flags;
                                          
400065f8:	c2 26 00 00 	st  %g1, [ %i0 ]
                              <== NOT EXECUTED
  return true;
                                                       
400065fc:	b2 10 20 01 	mov  1, %i1
                                   <== NOT EXECUTED
}
                                                                    
40006600:	b0 0e 60 01 	and  %i1, 1, %i0
                              <== NOT EXECUTED
40006604:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006608:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006338 <_POSIX_Mutex_Lock_support>:
                                
int _POSIX_Mutex_Lock_support(
                                       
  pthread_mutex_t              *mutex,
                               
  const struct timespec        *abstime,
                             
  Thread_queue_Enqueue_callout  enqueue_callout
                      
)
                                                                    
{
                                                                    
40006338:	9d e3 bf 70 	save  %sp, -144, %sp
                          
  Thread_queue_Context  queue_context;
                               
  Thread_Control       *executing;
                                   
  Status_Control        status;
                                      

                                                                     
  the_mutex = _POSIX_Mutex_Get( mutex );
                             
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
4000633c:	80 a6 20 00 	cmp  %i0, 0
                                   
40006340:	02 80 00 3f 	be  4000643c <_POSIX_Mutex_Lock_support+0x104>
<== NEVER TAKEN
40006344:	05 25 87 04 	sethi  %hi(0x961c1000), %g2
                   
40006348:	fa 06 00 00 	ld  [ %i0 ], %i5
                              
4000634c:	82 1e 00 1d 	xor  %i0, %i5, %g1
                            
40006350:	84 10 a3 b8 	or  %g2, 0x3b8, %g2
                           
40006354:	82 18 40 02 	xor  %g1, %g2, %g1
                            
40006358:	80 88 7f f8 	btst  -8, %g1
                                 
4000635c:	12 80 00 33 	bne  40006428 <_POSIX_Mutex_Lock_support+0xf0>
<== NEVER TAKEN
40006360:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006364:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
40006368:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        

                                                                     
  executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
     
  _Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout);

  _Thread_queue_Context_set_timeout_argument( &queue_context, abstime );


                                                                     
  switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
                    
4000636c:	82 8f 60 03 	andcc  %i5, 3, %g1
                            
  queue_context->enqueue_callout = enqueue_callout;
                  
40006370:	f4 27 bf e4 	st  %i2, [ %fp + -28 ]
                        
  queue_context->Timeout.arg = arg;
                                  
40006374:	f2 27 bf e8 	st  %i1, [ %fp + -24 ]
                        
40006378:	02 80 00 34 	be  40006448 <_POSIX_Mutex_Lock_support+0x110>
<== ALWAYS TAKEN
4000637c:	d0 01 a0 20 	ld  [ %g6 + 0x20 ], %o0
                       
40006380:	80 a0 60 02 	cmp  %g1, 2
                                   <== NOT EXECUTED
40006384:	12 80 00 10 	bne  400063c4 <_POSIX_Mutex_Lock_support+0x8c>
<== NOT EXECUTED
40006388:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1
                       <== NOT EXECUTED
{
                                                                    
  Thread_Control *owner;
                                             

                                                                     
  owner = _POSIX_Mutex_Get_owner( the_mutex );
                       

                                                                     
  if ( owner == NULL ) {
                                             
4000638c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006390:	02 80 00 43 	be  4000649c <_POSIX_Mutex_Lock_support+0x164>
<== NOT EXECUTED
40006394:	80 a2 00 01 	cmp  %o0, %g1
                                 <== NOT EXECUTED
      executing,
                                                     
      queue_context
                                                  
    );
                                                               
  }
                                                                  

                                                                     
  if ( owner == executing ) {
                                        
40006398:	02 80 00 18 	be  400063f8 <_POSIX_Mutex_Lock_support+0xc0>
 <== NOT EXECUTED
4000639c:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
    status = _POSIX_Mutex_Lock_nested( the_mutex, flags );
           
    _POSIX_Mutex_Release( the_mutex, queue_context );
                
    return status;
                                                   
  }
                                                                  

                                                                     
  return _POSIX_Mutex_Seize_slow(
                                    
400063a0:	98 07 bf dc 	add  %fp, -36, %o4
                            <== NOT EXECUTED
400063a4:	96 10 00 19 	mov  %i1, %o3
                                 <== NOT EXECUTED
400063a8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400063ac:	13 10 00 42 	sethi  %hi(0x40010800), %o1
                   <== NOT EXECUTED
400063b0:	7f ff ff ca 	call  400062d8 <_POSIX_Mutex_Seize_slow>
      <== NOT EXECUTED
400063b4:	92 12 60 f8 	or  %o1, 0xf8, %o1	! 400108f8 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400063b8:	93 3a 60 08 	sra  %o1, 8, %o1
                              <== NOT EXECUTED
      );
                                                             
      break;
                                                         
  }
                                                                  

                                                                     
  return _POSIX_Get_error( status );
                                 
}
                                                                    
400063bc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400063c0:	91 e8 00 09 	restore  %g0, %o1, %o0
                        <== NOT EXECUTED
  if ( owner == NULL ) {
                                             
400063c4:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
400063c8:	02 80 00 2e 	be  40006480 <_POSIX_Mutex_Lock_support+0x148>
<== NOT EXECUTED
400063cc:	80 a2 00 01 	cmp  %o0, %g1
                                 <== NOT EXECUTED
  if ( owner == executing ) {
                                        
400063d0:	02 80 00 0a 	be  400063f8 <_POSIX_Mutex_Lock_support+0xc0>
 <== NOT EXECUTED
400063d4:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
  return _POSIX_Mutex_Seize_slow(
                                    
400063d8:	98 07 bf dc 	add  %fp, -36, %o4
                            <== NOT EXECUTED
400063dc:	96 10 00 19 	mov  %i1, %o3
                                 <== NOT EXECUTED
400063e0:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400063e4:	13 10 00 42 	sethi  %hi(0x40010800), %o1
                   <== NOT EXECUTED
400063e8:	7f ff ff bc 	call  400062d8 <_POSIX_Mutex_Seize_slow>
      <== NOT EXECUTED
400063ec:	92 12 60 e4 	or  %o1, 0xe4, %o1	! 400108e4 <_Thread_queue_Operations_priority_inherit>
<== NOT EXECUTED
  return _POSIX_Get_error( status );
                                 
400063f0:	10 80 00 0c 	b  40006420 <_POSIX_Mutex_Lock_support+0xe8>
  <== NOT EXECUTED
400063f4:	93 3a 60 08 	sra  %o1, 8, %o1
                              <== NOT EXECUTED
  if ( _POSIX_Mutex_Is_recursive( flags ) ) {
                        
400063f8:	80 8f 60 04 	btst  4, %i5
                                  
400063fc:	02 80 00 06 	be  40006414 <_POSIX_Mutex_Lock_support+0xdc>
 <== ALWAYS TAKEN
40006400:	92 10 20 2d 	mov  0x2d, %o1
                                
    ++the_mutex->Recursive.nest_level;
                               
40006404:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       <== NOT EXECUTED
40006408:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
4000640c:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]
                       <== NOT EXECUTED
40006410:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006414:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006418:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000641c:	01 00 00 00 	nop 
                                          
}
                                                                    
40006420:	81 c7 e0 08 	ret 
                                          
40006424:	91 e8 00 09 	restore  %g0, %o1, %o0
                        
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
40006428:	40 00 00 52 	call  40006570 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4000642c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006430:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006434:	12 bf ff cc 	bne  40006364 <_POSIX_Mutex_Lock_support+0x2c>
<== NOT EXECUTED
40006438:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000643c:	92 10 20 16 	mov  0x16, %o1	! 16 <_TLS_Alignment+0x15>
     <== NOT EXECUTED
}
                                                                    
40006440:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006444:	91 e8 00 09 	restore  %g0, %o1, %o0
                        <== NOT EXECUTED
40006448:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1
                       
  if ( owner == NULL ) {
                                             
4000644c:	80 a0 60 00 	cmp  %g1, 0
                                   
40006450:	02 80 00 0c 	be  40006480 <_POSIX_Mutex_Lock_support+0x148>

40006454:	80 a2 00 01 	cmp  %o0, %g1
                                 
  if ( owner == executing ) {
                                        
40006458:	02 bf ff e8 	be  400063f8 <_POSIX_Mutex_Lock_support+0xc0>
 
4000645c:	94 10 00 08 	mov  %o0, %o2
                                 
  return _POSIX_Mutex_Seize_slow(
                                    
40006460:	98 07 bf dc 	add  %fp, -36, %o4
                            
40006464:	96 10 00 19 	mov  %i1, %o3
                                 
40006468:	90 10 00 18 	mov  %i0, %o0
                                 
4000646c:	13 10 00 42 	sethi  %hi(0x40010800), %o1
                   
40006470:	7f ff ff 9a 	call  400062d8 <_POSIX_Mutex_Seize_slow>
      
40006474:	92 12 61 0c 	or  %o1, 0x10c, %o1	! 4001090c <_Thread_queue_Operations_FIFO>

40006478:	10 bf ff ea 	b  40006420 <_POSIX_Mutex_Lock_support+0xe8>
  
4000647c:	93 3a 60 08 	sra  %o1, 8, %o1
                              
  the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
              
40006480:	d0 26 20 10 	st  %o0, [ %i0 + 0x10 ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006484:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006488:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000648c:	01 00 00 00 	nop 
                                          
40006490:	92 10 20 00 	clr  %o1	! 0 <PROM_START>
                     
40006494:	81 c7 e0 08 	ret 
                                          
40006498:	91 e8 00 09 	restore  %g0, %o1, %o0
                        
  if (
                                                               
4000649c:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1
                       <== NOT EXECUTED
  queue_context->Priority.update_count = 0;
                          
400064a0:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
400064a4:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3
                       <== NOT EXECUTED
400064a8:	c4 00 60 18 	ld  [ %g1 + 0x18 ], %g2
                       <== NOT EXECUTED
400064ac:	80 a0 c0 02 	cmp  %g3, %g2
                                 <== NOT EXECUTED
400064b0:	18 80 00 09 	bgu  400064d4 <_POSIX_Mutex_Lock_support+0x19c>
<== NOT EXECUTED
400064b4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
400064b8:	32 80 00 0c 	bne,a   400064e8 <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
400064bc:	d0 26 20 10 	st  %o0, [ %i0 + 0x10 ]
                       <== NOT EXECUTED
400064c0:	c4 06 20 34 	ld  [ %i0 + 0x34 ], %g2
                       <== NOT EXECUTED
400064c4:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1
                       <== NOT EXECUTED
400064c8:	80 a0 80 01 	cmp  %g2, %g1
                                 <== NOT EXECUTED
400064cc:	28 80 00 07 	bleu,a   400064e8 <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
400064d0:	d0 26 20 10 	st  %o0, [ %i0 + 0x10 ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400064d4:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400064d8:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400064dc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
400064e0:	10 bf ff d8 	b  40006440 <_POSIX_Mutex_Lock_support+0x108>
 <== NOT EXECUTED
400064e4:	92 10 20 16 	mov  0x16, %o1	! 16 <_TLS_Alignment+0x15>
     <== NOT EXECUTED
  _Thread_Priority_add(
                                              
400064e8:	92 06 20 20 	add  %i0, 0x20, %o1
                           <== NOT EXECUTED
400064ec:	40 00 10 94 	call  4000a73c <_Thread_Priority_add>
         <== NOT EXECUTED
400064f0:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
  const ISR_lock_Context *lock_context
                               
)
                                                                    
{
                                                                    
  uint32_t disable_level;
                                            

                                                                     
  disable_level = cpu_self->thread_dispatch_disable_level;
           
400064f4:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       <== NOT EXECUTED
  _Profiling_Thread_dispatch_disable_critical(
                       
    cpu_self,
                                                        
    disable_level,
                                                   
    lock_context
                                                     
  );
                                                                 
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
400064f8:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
 */
                                                                  
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(

  const ISR_lock_Context *lock_context
                               
)
                                                                    
{
                                                                    
  return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );

400064fc:	ba 10 00 06 	mov  %g6, %i5
                                 <== NOT EXECUTED
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
40006500:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006504:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006508:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000650c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Thread_Priority_update( queue_context );
                          
40006510:	40 00 10 9c 	call  4000a780 <_Thread_Priority_update>
      <== NOT EXECUTED
40006514:	90 07 bf dc 	add  %fp, -36, %o0
                            <== NOT EXECUTED
 *
                                                                   
 * @param[in] cpu_self The current processor.
                        
 */
                                                                  
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )

{
                                                                    
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
40006518:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1
                       <== NOT EXECUTED

                                                                     
  if ( disable_level == 1 ) {
                                        
4000651c:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
40006520:	02 80 00 05 	be  40006534 <_POSIX_Mutex_Lock_support+0x1fc>
<== NOT EXECUTED
40006524:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    }
                                                                

                                                                     
    _ISR_Local_enable( level );
                                      
  } else {
                                                           
    _Assert( disable_level > 0 );
                                    
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
40006528:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
4000652c:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]
                       <== NOT EXECUTED
40006530:	30 bf ff bc 	b,a   40006420 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006534:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
40006538:	c4 0f 60 1c 	ldub  [ %i5 + 0x1c ], %g2
                     <== NOT EXECUTED
4000653c:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40006540:	32 80 00 07 	bne,a   4000655c <_POSIX_Mutex_Lock_support+0x224>
<== NOT EXECUTED
40006544:	92 10 00 01 	mov  %g1, %o1
                                 <== NOT EXECUTED
      cpu_self->thread_dispatch_disable_level = 0;
                   
40006548:	c0 27 60 18 	clr  [ %i5 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000654c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006550:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006554:	10 bf ff b3 	b  40006420 <_POSIX_Mutex_Lock_support+0xe8>
  <== NOT EXECUTED
40006558:	92 10 20 00 	clr  %o1	! 0 <PROM_START>
                     <== NOT EXECUTED
      _Thread_Do_dispatch( cpu_self, level );
                        
4000655c:	c2 27 bf d4 	st  %g1, [ %fp + -44 ]
                        <== NOT EXECUTED
40006560:	40 00 10 e4 	call  4000a8f0 <_Thread_Do_dispatch>
          <== NOT EXECUTED
40006564:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
40006568:	10 bf ff f9 	b  4000654c <_POSIX_Mutex_Lock_support+0x214>
 <== NOT EXECUTED
4000656c:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1
                        <== NOT EXECUTED

                                                                     
===============================================================================
400062d8 <_POSIX_Mutex_Seize_slow>:
                                  
  const Thread_queue_Operations *operations,
                         
  Thread_Control                *executing,
                          
  const struct timespec         *abstime,
                            
  Thread_queue_Context          *queue_context
                       
)
                                                                    
{
                                                                    
400062d8:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
       
400062dc:	80 a6 e0 01 	cmp  %i3, 1
                                   
400062e0:	02 80 00 0f 	be  4000631c <_POSIX_Mutex_Seize_slow+0x44>
   <== NEVER TAKEN
400062e4:	82 10 20 01 	mov  1, %g1
                                   
  queue_context->thread_state = thread_state;
                        
400062e8:	c2 27 20 04 	st  %g1, [ %i4 + 4 ]
                          
  queue_context->deadlock_callout = deadlock_callout;
                
400062ec:	03 10 00 2c 	sethi  %hi(0x4000b000), %g1
                   
400062f0:	82 10 60 24 	or  %g1, 0x24, %g1	! 4000b024 <_Thread_queue_Deadlock_status>

400062f4:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       
    );
                                                               
    _Thread_queue_Context_set_deadlock_callout(
                      
      queue_context,
                                                 
      _Thread_queue_Deadlock_status
                                  
    );
                                                               
    _Thread_queue_Enqueue(
                                           
400062f8:	92 10 00 19 	mov  %i1, %o1
                                 
400062fc:	90 06 20 0c 	add  %i0, 0xc, %o0
                            
40006300:	96 10 00 1c 	mov  %i4, %o3
                                 
40006304:	94 10 00 1a 	mov  %i2, %o2
                                 
40006308:	40 00 13 4f 	call  4000b044 <_Thread_queue_Enqueue>
        
4000630c:	b0 10 20 00 	clr  %i0
                                      

                                                                     
RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status(
         
  const Thread_Control *the_thread
                                   
)
                                                                    
{
                                                                    
  return (Status_Control) the_thread->Wait.return_code;
              
40006310:	f2 06 a0 4c 	ld  [ %i2 + 0x4c ], %i1
                       
    return _Thread_Wait_get_status( executing );
                     
  } else {
                                                           
    _POSIX_Mutex_Release( the_mutex, queue_context );
                
    return STATUS_UNAVAILABLE;
                                       
  }
                                                                  
}
                                                                    
40006314:	81 c7 e0 08 	ret 
                                          
40006318:	81 e8 00 00 	restore 
                                      
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000631c:	c2 07 00 00 	ld  [ %i4 ], %g1
                              <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006320:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006324:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006328:	33 00 00 04 	sethi  %hi(0x1000), %i1
                       <== NOT EXECUTED
4000632c:	b2 16 60 0d 	or  %i1, 0xd, %i1	! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
40006330:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006334:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED

                                                                     
===============================================================================
4000db10 <_POSIX_Priority_To_core>:
                                  
Priority_Control _POSIX_Priority_To_core(
                            
  const Scheduler_Control *scheduler,
                                
  int                      posix_priority,
                           
  bool                    *valid
                                     
)
                                                                    
{
                                                                    
4000db10:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  Priority_Control core_posix_priority;
                              
  Priority_Control core_priority;
                                    

                                                                     
  core_posix_priority = (Priority_Control) posix_priority;
           
  core_priority = scheduler->maximum_priority - core_posix_priority;
 
4000db14:	f8 1e 20 40 	ldd  [ %i0 + 0x40 ], %i4
                      
  core_posix_priority = (Priority_Control) posix_priority;
           
4000db18:	83 3e 60 1f 	sra  %i1, 0x1f, %g1
                           
4000db1c:	86 10 00 19 	mov  %i1, %g3
                                 
4000db20:	84 10 00 01 	mov  %g1, %g2
                                 

                                                                     
  *valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
      
    && core_posix_priority < scheduler->maximum_priority );
          
4000db24:	80 a7 00 01 	cmp  %i4, %g1
                                 
4000db28:	18 80 00 05 	bgu  4000db3c <_POSIX_Priority_To_core+0x2c>
  <== NEVER TAKEN
4000db2c:	88 10 20 01 	mov  1, %g4
                                   
4000db30:	02 80 00 11 	be  4000db74 <_POSIX_Priority_To_core+0x64>
   <== ALWAYS TAKEN
4000db34:	80 a7 40 19 	cmp  %i5, %i1
                                 
4000db38:	88 10 20 00 	clr  %g4
                                      <== NOT EXECUTED
4000db3c:	82 20 40 19 	sub  %g1, %i1, %g1
                            <== NOT EXECUTED
4000db40:	83 30 60 1f 	srl  %g1, 0x1f, %g1
                           
4000db44:	82 08 40 04 	and  %g1, %g4, %g1
                            
  *valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
      
4000db48:	c2 2e 80 00 	stb  %g1, [ %i2 ]
                             
  core_priority = scheduler->maximum_priority - core_posix_priority;
 
4000db4c:	b6 a7 40 03 	subcc  %i5, %g3, %i3
                          
  return ( *scheduler->Operations.map_priority )( scheduler, priority );

4000db50:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1
                       
4000db54:	b4 67 00 02 	subx  %i4, %g2, %i2
                           
4000db58:	94 10 00 1b 	mov  %i3, %o2
                                 
4000db5c:	92 10 00 1a 	mov  %i2, %o1
                                 
4000db60:	9f c0 40 00 	call  %g1
                                     
4000db64:	90 10 00 18 	mov  %i0, %o0
                                 

                                                                     
  return _Scheduler_Map_priority( scheduler, core_priority );
        
}
                                                                    
4000db68:	b0 10 00 08 	mov  %o0, %i0
                                 
4000db6c:	81 c7 e0 08 	ret 
                                          
4000db70:	93 e8 00 09 	restore  %g0, %o1, %o1
                        
    && core_posix_priority < scheduler->maximum_priority );
          
4000db74:	38 bf ff f3 	bgu,a   4000db40 <_POSIX_Priority_To_core+0x30>
<== ALWAYS TAKEN
4000db78:	82 20 40 19 	sub  %g1, %i1, %g1
                            
4000db7c:	10 bf ff f0 	b  4000db3c <_POSIX_Priority_To_core+0x2c>
    <== NOT EXECUTED
4000db80:	88 10 20 00 	clr  %g4
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400062f0 <_POSIX_RWLock_Auto_initialization>:
                        
#include <rtems/posix/posixapi.h>
                                    

                                                                     
#include <string.h>
                                                  

                                                                     
bool _POSIX_RWLock_Auto_initialization( POSIX_RWLock_Control *the_rwlock )

{
                                                                    
400062f0:	9d e3 bf 80 	save  %sp, -128, %sp
                          <== NOT EXECUTED
  POSIX_RWLock_Control zero;
                                         

                                                                     
  memset( &zero, 0, sizeof( zero ) );
                                

                                                                     
  if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
   
400062f4:	94 10 20 20 	mov  0x20, %o2
                                <== NOT EXECUTED
  memset( &zero, 0, sizeof( zero ) );
                                
400062f8:	c0 27 bf e0 	clr  [ %fp + -32 ]
                            <== NOT EXECUTED
  if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
   
400062fc:	92 07 bf e0 	add  %fp, -32, %o1
                            <== NOT EXECUTED
  memset( &zero, 0, sizeof( zero ) );
                                
40006300:	c0 27 bf e4 	clr  [ %fp + -28 ]
                            <== NOT EXECUTED
  if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
   
40006304:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  memset( &zero, 0, sizeof( zero ) );
                                
40006308:	c0 27 bf e8 	clr  [ %fp + -24 ]
                            <== NOT EXECUTED
4000630c:	c0 27 bf ec 	clr  [ %fp + -20 ]
                            <== NOT EXECUTED
40006310:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
40006314:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
40006318:	c0 27 bf f8 	clr  [ %fp + -8 ]
                             <== NOT EXECUTED
  if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
   
4000631c:	40 00 21 83 	call  4000e928 <memcmp>
                       <== NOT EXECUTED
40006320:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
40006324:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006328:	12 80 00 07 	bne  40006344 <_POSIX_RWLock_Auto_initialization+0x54>
<== NOT EXECUTED
4000632c:	82 10 20 00 	clr  %g1
                                      <== NOT EXECUTED
    return false;
                                                    
  }
                                                                  

                                                                     
  the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC;
   
40006330:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   <== NOT EXECUTED
40006334:	82 10 62 bd 	or  %g1, 0x2bd, %g1	! 9621dabd <RAM_END+0x55e1dabd>
<== NOT EXECUTED
40006338:	82 1e 00 01 	xor  %i0, %g1, %g1
                            <== NOT EXECUTED
4000633c:	c2 26 00 00 	st  %g1, [ %i0 ]
                              <== NOT EXECUTED
  return true;
                                                       
40006340:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
}
                                                                    
40006344:	b0 08 60 01 	and  %g1, 1, %i0
                              <== NOT EXECUTED
40006348:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000634c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000dbd4 <_POSIX_Thread_Translate_sched_param>:
                      
  int                                  policy,
                       
  const struct sched_param            *param,
                        
  Thread_CPU_budget_algorithms        *budget_algorithm,
             
  Thread_CPU_budget_algorithm_callout *budget_callout
                
)
                                                                    
{
                                                                    
4000dbd4:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
              
4000dbd8:	c0 26 80 00 	clr  [ %i2 ]
                                  
  *budget_callout = NULL;
                                            

                                                                     
  if ( policy == SCHED_OTHER ) {
                                     
4000dbdc:	80 a6 20 00 	cmp  %i0, 0
                                   
4000dbe0:	02 80 00 29 	be  4000dc84 <_POSIX_Thread_Translate_sched_param+0xb0>
<== NEVER TAKEN
4000dbe4:	c0 26 c0 00 	clr  [ %i3 ]
                                  
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
 
    return 0;
                                                        
  }
                                                                  

                                                                     
  if ( policy == SCHED_FIFO ) {
                                      
4000dbe8:	80 a6 20 01 	cmp  %i0, 1
                                   
4000dbec:	02 80 00 2a 	be  4000dc94 <_POSIX_Thread_Translate_sched_param+0xc0>

4000dbf0:	80 a6 20 02 	cmp  %i0, 2
                                   
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
            
    return 0;
                                                        
  }
                                                                  

                                                                     
  if ( policy == SCHED_RR ) {
                                        
4000dbf4:	02 80 00 2d 	be  4000dca8 <_POSIX_Thread_Translate_sched_param+0xd4>
<== ALWAYS TAKEN
4000dbf8:	80 a6 20 04 	cmp  %i0, 4
                                   
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;

    return 0;
                                                        
  }
                                                                  

                                                                     
  if ( policy == SCHED_SPORADIC ) {
                                  
4000dbfc:	12 80 00 29 	bne  4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc00:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    if ( (param->sched_ss_repl_period.tv_sec == 0) &&
                
4000dc04:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2
                          <== NOT EXECUTED
4000dc08:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1
                        <== NOT EXECUTED
4000dc0c:	80 90 80 01 	orcc  %g2, %g1, %g0
                           <== NOT EXECUTED
4000dc10:	32 80 00 07 	bne,a   4000dc2c <_POSIX_Thread_Translate_sched_param+0x58>
<== NOT EXECUTED
4000dc14:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2
                       <== NOT EXECUTED
4000dc18:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1
                       <== NOT EXECUTED
4000dc1c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4000dc20:	02 80 00 20 	be  4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc24:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
         (param->sched_ss_repl_period.tv_nsec == 0) )
                
      return EINVAL;
                                                 

                                                                     
    if ( (param->sched_ss_init_budget.tv_sec == 0) &&
                
4000dc28:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2
                       <== NOT EXECUTED
4000dc2c:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1
                       <== NOT EXECUTED
4000dc30:	80 90 80 01 	orcc  %g2, %g1, %g0
                           <== NOT EXECUTED
4000dc34:	12 80 00 06 	bne  4000dc4c <_POSIX_Thread_Translate_sched_param+0x78>
<== NOT EXECUTED
4000dc38:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000dc3c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1
                       <== NOT EXECUTED
4000dc40:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4000dc44:	02 80 00 17 	be  4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc48:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
         (param->sched_ss_init_budget.tv_nsec == 0) )
                
      return EINVAL;
                                                 

                                                                     
    if ( _Timespec_To_ticks( &param->sched_ss_repl_period ) <
        
4000dc4c:	7f ff ff 1c 	call  4000d8bc <_Timespec_To_ticks>
           <== NOT EXECUTED
4000dc50:	90 06 60 08 	add  %i1, 8, %o0
                              <== NOT EXECUTED
4000dc54:	ba 10 00 08 	mov  %o0, %i5
                                 <== NOT EXECUTED
	 _Timespec_To_ticks( &param->sched_ss_init_budget ) )
               
4000dc58:	7f ff ff 19 	call  4000d8bc <_Timespec_To_ticks>
           <== NOT EXECUTED
4000dc5c:	90 06 60 18 	add  %i1, 0x18, %o0
                           <== NOT EXECUTED
    if ( _Timespec_To_ticks( &param->sched_ss_repl_period ) <
        
4000dc60:	80 a7 40 08 	cmp  %i5, %o0
                                 <== NOT EXECUTED
4000dc64:	0a 80 00 0f 	bcs  4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc68:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
      return EINVAL;
                                                 

                                                                     
    *budget_algorithm  = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
        
4000dc6c:	c2 26 80 00 	st  %g1, [ %i2 ]
                              <== NOT EXECUTED
    *budget_callout = _POSIX_Threads_Sporadic_budget_callout;
        
4000dc70:	03 10 00 31 	sethi  %hi(0x4000c400), %g1
                   <== NOT EXECUTED
4000dc74:	82 10 62 94 	or  %g1, 0x294, %g1	! 4000c694 <_POSIX_Threads_Sporadic_budget_callout>
<== NOT EXECUTED
4000dc78:	c2 26 c0 00 	st  %g1, [ %i3 ]
                              <== NOT EXECUTED
    return 0;
                                                        
  }
                                                                  

                                                                     
  return EINVAL;
                                                     
}
                                                                    
4000dc7c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000dc80:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
 
4000dc84:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
4000dc88:	c2 26 80 00 	st  %g1, [ %i2 ]
                              <== NOT EXECUTED
    return 0;
                                                        
4000dc8c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000dc90:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
            
4000dc94:	c0 26 80 00 	clr  [ %i2 ]
                                  
    return 0;
                                                        
4000dc98:	81 c7 e0 08 	ret 
                                          
4000dc9c:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  return EINVAL;
                                                     
4000dca0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000dca4:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;

4000dca8:	f0 26 80 00 	st  %i0, [ %i2 ]
                              
    return 0;
                                                        
4000dcac:	81 c7 e0 08 	ret 
                                          
4000dcb0:	91 e8 20 00 	restore  %g0, 0, %o0
                          

                                                                     
===============================================================================
4000dbac <_POSIX_Thread_Translate_to_sched_policy>:
                  
#include <rtems/posix/pthreadimpl.h>
                                 

                                                                     
int _POSIX_Thread_Translate_to_sched_policy(
                         
  Thread_CPU_budget_algorithms budget_algorithm
                      
)
                                                                    
{
                                                                    
4000dbac:	82 02 3f ff 	add  %o0, -1, %g1
                             
4000dbb0:	80 a0 60 02 	cmp  %g1, 2
                                   
4000dbb4:	18 80 00 06 	bgu  4000dbcc <_POSIX_Thread_Translate_to_sched_policy+0x20>
<== ALWAYS TAKEN
4000dbb8:	90 10 20 01 	mov  1, %o0
                                   
4000dbbc:	83 28 60 02 	sll  %g1, 2, %g1
                              <== NOT EXECUTED
4000dbc0:	05 10 00 3e 	sethi  %hi(0x4000f800), %g2
                   <== NOT EXECUTED
4000dbc4:	84 10 a3 30 	or  %g2, 0x330, %g2	! 4000fb30 <CSWTCH.1>
     <== NOT EXECUTED
4000dbc8:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0
                        <== NOT EXECUTED
      return SCHED_SPORADIC;
                                         
    default:
                                                         
      _Assert( budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE );

      return SCHED_FIFO;
                                             
  }
                                                                  
}
                                                                    
4000dbcc:	81 c3 e0 08 	retl 
                                         
4000dbd0:	01 00 00 00 	nop 
                                          

                                                                     
===============================================================================
4000fb40 <_POSIX_Threads_Default_attributes>:
                        
4000fb40:	00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00     ................

4000fb50:	00 00 00 01 00 00 00 01 00 00 00 02 00 00 00 00     ................

	...
                                                                 
4000fb8c:	00 00 00 01 00 00 00 01 00 00 00 04 40 00 fb 9c     ............@...

4000fb9c:	ff ff ff ff                                         ....
   

                                                                     
===============================================================================
40005e34 <_POSIX_Threads_Initialize_user_threads_body>:
              
#include <rtems/posix/pthreadimpl.h>
                                 
#include <rtems/posix/priorityimpl.h>
                                
#include <rtems/posix/config.h>
                                      

                                                                     
void _POSIX_Threads_Initialize_user_threads_body(void)
               
{
                                                                    
40005e34:	9d e3 bf 38 	save  %sp, -200, %sp
                          
  uint32_t                            maximum;
                       
  posix_initialization_threads_table *user_threads;
                  
  pthread_t                           thread_id;
                     
  pthread_attr_t                      attr;
                          

                                                                     
  user_threads = Configuration_POSIX_API.User_initialization_threads_table;

40005e38:	03 10 00 43 	sethi  %hi(0x40010c00), %g1
                   
40005e3c:	82 10 61 84 	or  %g1, 0x184, %g1	! 40010d84 <Configuration_POSIX_API>

40005e40:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5
                       
  maximum      = Configuration_POSIX_API.number_of_initialization_threads;


                                                                     
  if ( !user_threads )
                                               
40005e44:	80 a7 60 00 	cmp  %i5, 0
                                   
40005e48:	02 80 00 1f 	be  40005ec4 <_POSIX_Threads_Initialize_user_threads_body+0x90>
<== NEVER TAKEN
40005e4c:	01 00 00 00 	nop 
                                          
  maximum      = Configuration_POSIX_API.number_of_initialization_threads;

40005e50:	f4 00 60 18 	ld  [ %g1 + 0x18 ], %i2
                       
   *
                                                                 
   *  Setting the attributes explicitly is critical, since we don't want

   *  to inherit the idle tasks attributes.
                          
   */
                                                                

                                                                     
  for ( index=0 ; index < maximum ; index++ ) {
                      
40005e54:	80 a6 a0 00 	cmp  %i2, 0
                                   
40005e58:	02 80 00 1b 	be  40005ec4 <_POSIX_Threads_Initialize_user_threads_body+0x90>
<== NEVER TAKEN
40005e5c:	b8 10 20 00 	clr  %i4
                                      
    );
                                                               
    if ( eno != 0 ) {
                                                
      _Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );

    }
                                                                

                                                                     
    if ( _Thread_Global_constructor == 0 ) {
                         
40005e60:	37 10 00 4a 	sethi  %hi(0x40012800), %i3
                   
    eno = pthread_attr_init( &attr );
                                
40005e64:	40 00 18 7e 	call  4000c05c <pthread_attr_init>
            
40005e68:	90 07 bf a0 	add  %fp, -96, %o0
                            
    eno = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );

40005e6c:	92 10 20 02 	mov  2, %o1
                                   
40005e70:	40 00 18 8a 	call  4000c098 <pthread_attr_setinheritsched>
 
40005e74:	90 07 bf a0 	add  %fp, -96, %o0
                            
    eno = pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);

40005e78:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1
                          
40005e7c:	40 00 18 96 	call  4000c0d4 <pthread_attr_setstacksize>
    
40005e80:	90 07 bf a0 	add  %fp, -96, %o0
                            
    eno = pthread_create(
                                            
40005e84:	d4 07 40 00 	ld  [ %i5 ], %o2
                              
40005e88:	96 10 20 00 	clr  %o3
                                      
40005e8c:	92 07 bf a0 	add  %fp, -96, %o1
                            
40005e90:	40 00 18 9d 	call  4000c104 <pthread_create>
               
40005e94:	90 07 bf 9c 	add  %fp, -100, %o0
                           
    if ( eno != 0 ) {
                                                
40005e98:	80 a2 20 00 	cmp  %o0, 0
                                   
40005e9c:	12 80 00 0c 	bne  40005ecc <_POSIX_Threads_Initialize_user_threads_body+0x98>
<== NEVER TAKEN
40005ea0:	c2 06 e1 50 	ld  [ %i3 + 0x150 ], %g1
                      
    if ( _Thread_Global_constructor == 0 ) {
                         
40005ea4:	80 a0 60 00 	cmp  %g1, 0
                                   
40005ea8:	12 80 00 04 	bne  40005eb8 <_POSIX_Threads_Initialize_user_threads_body+0x84>
<== NEVER TAKEN
40005eac:	b8 07 20 01 	inc  %i4
                                      
      _Thread_Global_constructor = thread_id;
                        
40005eb0:	c2 07 bf 9c 	ld  [ %fp + -100 ], %g1
                       
40005eb4:	c2 26 e1 50 	st  %g1, [ %i3 + 0x150 ]
                      
  for ( index=0 ; index < maximum ; index++ ) {
                      
40005eb8:	80 a6 80 1c 	cmp  %i2, %i4
                                 
40005ebc:	12 bf ff ea 	bne  40005e64 <_POSIX_Threads_Initialize_user_threads_body+0x30>
<== NEVER TAKEN
40005ec0:	ba 07 60 08 	add  %i5, 8, %i5
                              
    }
                                                                
  }
                                                                  
}
                                                                    
40005ec4:	81 c7 e0 08 	ret 
                                          
40005ec8:	81 e8 00 00 	restore 
                                      
      _Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );

40005ecc:	40 00 02 70 	call  4000688c <_Internal_error>
              <== NOT EXECUTED
40005ed0:	90 10 20 21 	mov  0x21, %o0
                                <== NOT EXECUTED
40005ed4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000c694 <_POSIX_Threads_Sporadic_budget_callout>:
                   
{
                                                                    
4000c694:	9d e3 bf 78 	save  %sp, -136, %sp
                          <== NOT EXECUTED
4000c698:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
4000c69c:	d2 06 21 5c 	ld  [ %i0 + 0x15c ], %o1
                      <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000c6a0:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
4000c6a4:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        <== NOT EXECUTED
  the_thread->cpu_time_budget = UINT32_MAX;
                          
4000c6a8:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
4000c6ac:	c2 26 20 8c 	st  %g1, [ %i0 + 0x8c ]
                       <== NOT EXECUTED
  if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
  
4000c6b0:	c2 02 60 34 	ld  [ %o1 + 0x34 ], %g1
                       <== NOT EXECUTED
4000c6b4:	80 a0 7f ff 	cmp  %g1, -1
                                  <== NOT EXECUTED
4000c6b8:	02 80 00 09 	be  4000c6dc <_POSIX_Threads_Sporadic_budget_callout+0x48>
<== NOT EXECUTED
4000c6bc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000c6c0:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000c6c4:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000c6c8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Thread_Priority_update( &queue_context );
                         
4000c6cc:	40 00 03 33 	call  4000d398 <_Thread_Priority_update>
      <== NOT EXECUTED
4000c6d0:	90 07 bf dc 	add  %fp, -36, %o0
                            <== NOT EXECUTED
}
                                                                    
4000c6d4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c6d8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    _Thread_Priority_add(
                                            
4000c6dc:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
4000c6e0:	40 00 03 24 	call  4000d370 <_Thread_Priority_add>
         <== NOT EXECUTED
4000c6e4:	92 02 60 28 	add  %o1, 0x28, %o1
                           <== NOT EXECUTED
    _Thread_Priority_remove(
                                         
4000c6e8:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
4000c6ec:	92 06 20 20 	add  %i0, 0x20, %o1
                           <== NOT EXECUTED
4000c6f0:	40 00 03 25 	call  4000d384 <_Thread_Priority_remove>
      <== NOT EXECUTED
4000c6f4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000c6f8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000c6fc:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000c700:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Thread_Priority_update( &queue_context );
                         
4000c704:	40 00 03 25 	call  4000d398 <_Thread_Priority_update>
      <== NOT EXECUTED
4000c708:	90 07 bf dc 	add  %fp, -36, %o0
                            <== NOT EXECUTED
}
                                                                    
4000c70c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c710:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000c5e0 <_POSIX_Threads_Sporadic_timer>:
                            
{
                                                                    
4000c5e0:	9d e3 bf 78 	save  %sp, -136, %sp
                          <== NOT EXECUTED
  queue_context->Priority.update_count = 0;
                          
4000c5e4:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
  api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer );

4000c5e8:	ba 06 3f f8 	add  %i0, -8, %i5
                             <== NOT EXECUTED
  the_thread = api->Sporadic.thread;
                                 
4000c5ec:	f8 06 3f f8 	ld  [ %i0 + -8 ], %i4
                         <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000c5f0:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );

4000c5f4:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        <== NOT EXECUTED
  if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
   
4000c5f8:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1
                       <== NOT EXECUTED
4000c5fc:	80 a0 7f ff 	cmp  %g1, -1
                                  <== NOT EXECUTED
4000c600:	02 80 00 0b 	be  4000c62c <_POSIX_Threads_Sporadic_timer+0x4c>
<== NOT EXECUTED
4000c604:	92 07 20 20 	add  %i4, 0x20, %o1
                           <== NOT EXECUTED
    _Thread_Priority_add(
                                            
4000c608:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
4000c60c:	40 00 03 59 	call  4000d370 <_Thread_Priority_add>
         <== NOT EXECUTED
4000c610:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
    _Thread_Priority_remove(
                                         
4000c614:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
4000c618:	92 06 20 20 	add  %i0, 0x20, %o1
                           <== NOT EXECUTED
4000c61c:	40 00 03 5a 	call  4000d384 <_Thread_Priority_remove>
      <== NOT EXECUTED
4000c620:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
4000c624:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
4000c628:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]
                       <== NOT EXECUTED
  _Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
            
4000c62c:	b6 07 60 08 	add  %i5, 8, %i3
                              <== NOT EXECUTED
4000c630:	11 10 00 4a 	sethi  %hi(0x40012800), %o0
                   <== NOT EXECUTED
4000c634:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
4000c638:	7f ff f9 30 	call  4000aaf8 <_Watchdog_Remove>
             <== NOT EXECUTED
4000c63c:	90 12 21 38 	or  %o0, 0x138, %o0
                           <== NOT EXECUTED
    _Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
       
4000c640:	40 00 04 9f 	call  4000d8bc <_Timespec_To_ticks>
           <== NOT EXECUTED
4000c644:	90 07 60 50 	add  %i5, 0x50, %o0
                           <== NOT EXECUTED
  the_thread->cpu_time_budget =
                                      
4000c648:	d0 27 20 8c 	st  %o0, [ %i4 + 0x8c ]
                       <== NOT EXECUTED
  _Watchdog_Per_CPU_insert_ticks(
                                    
4000c64c:	b8 10 00 06 	mov  %g6, %i4
                                 <== NOT EXECUTED
4000c650:	40 00 04 9b 	call  4000d8bc <_Timespec_To_ticks>
           <== NOT EXECUTED
4000c654:	90 07 60 40 	add  %i5, 0x40, %o0
                           <== NOT EXECUTED
  expire = ticks + cpu->Watchdog.ticks;
                              
4000c658:	d4 1f 20 30 	ldd  [ %i4 + 0x30 ], %o2
                      <== NOT EXECUTED
  _Watchdog_Insert(header, the_watchdog, expire);
                    
4000c65c:	86 82 c0 08 	addcc  %o3, %o0, %g3
                          <== NOT EXECUTED
4000c660:	84 42 a0 00 	addx  %o2, 0, %g2
                             <== NOT EXECUTED
4000c664:	96 10 00 03 	mov  %g3, %o3
                                 <== NOT EXECUTED
4000c668:	94 10 00 02 	mov  %g2, %o2
                                 <== NOT EXECUTED
4000c66c:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
4000c670:	7f ff f8 fa 	call  4000aa58 <_Watchdog_Insert>
             <== NOT EXECUTED
4000c674:	90 07 20 38 	add  %i4, 0x38, %o0
                           <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000c678:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000c67c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000c680:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Thread_Priority_update( &queue_context );
                         
4000c684:	40 00 03 45 	call  4000d398 <_Thread_Priority_update>
      <== NOT EXECUTED
4000c688:	90 07 bf dc 	add  %fp, -36, %o0
                            <== NOT EXECUTED
}
                                                                    
4000c68c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c690:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000f29c <_POSIX_signals_Abnormal_termination_handler>:
              

                                                                     
sigset_t  _POSIX_signals_Pending;
                                    

                                                                     
void _POSIX_signals_Abnormal_termination_handler(
                    
  int signo RTEMS_UNUSED )
                                           
{
                                                                    
4000f29c:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  exit( 1 );
                                                         
4000f2a0:	40 00 02 59 	call  4000fc04 <exit>
                         <== NOT EXECUTED
4000f2a4:	90 10 20 01 	mov  1, %o0
                                   <== NOT EXECUTED
4000f2a8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000fb6c <_POSIX_signals_Clear_process_signals>:
                     
  _Assert( _ISR_Get_level() != 0 );
                                  

                                                                     
  clear_signal = true;
                                               
  mask         = signo_to_mask( signo );
                             

                                                                     
  if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
    
4000fb6c:	83 2a 20 01 	sll  %o0, 1, %g1
                              <== NOT EXECUTED
4000fb70:	05 10 00 53 	sethi  %hi(0x40014c00), %g2
                   <== NOT EXECUTED
4000fb74:	82 00 40 08 	add  %g1, %o0, %g1
                            <== NOT EXECUTED
4000fb78:	84 10 a3 90 	or  %g2, 0x390, %g2
                           <== NOT EXECUTED
4000fb7c:	83 28 60 02 	sll  %g1, 2, %g1
                              <== NOT EXECUTED
4000fb80:	c4 00 80 01 	ld  [ %g2 + %g1 ], %g2
                        <== NOT EXECUTED
4000fb84:	90 02 3f ff 	add  %o0, -1, %o0
                             <== NOT EXECUTED
4000fb88:	80 a0 a0 02 	cmp  %g2, 2
                                   <== NOT EXECUTED
4000fb8c:	84 10 20 01 	mov  1, %g2
                                   <== NOT EXECUTED
4000fb90:	02 80 00 07 	be  4000fbac <_POSIX_signals_Clear_process_signals+0x40>
<== NOT EXECUTED
4000fb94:	91 28 80 08 	sll  %g2, %o0, %o0
                            <== NOT EXECUTED
    if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
      
      clear_signal = false;
                                          
  }
                                                                  

                                                                     
  if ( clear_signal ) {
                                              
    _POSIX_signals_Pending &= ~mask;
                                 
4000fb98:	03 10 00 54 	sethi  %hi(0x40015000), %g1
                   <== NOT EXECUTED
4000fb9c:	c4 00 61 1c 	ld  [ %g1 + 0x11c ], %g2	! 4001511c <_POSIX_signals_Pending>
<== NOT EXECUTED
4000fba0:	90 28 80 08 	andn  %g2, %o0, %o0
                           <== NOT EXECUTED
  }
                                                                  
}
                                                                    
4000fba4:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
4000fba8:	d0 20 61 1c 	st  %o0, [ %g1 + 0x11c ]
                      <== NOT EXECUTED
  return _Chain_Immutable_head( the_chain )->next;
                   
4000fbac:	05 10 00 54 	sethi  %hi(0x40015000), %g2
                   <== NOT EXECUTED
4000fbb0:	84 10 a1 20 	or  %g2, 0x120, %g2	! 40015120 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
    if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
      
4000fbb4:	c6 00 80 01 	ld  [ %g2 + %g1 ], %g3
                        <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
4000fbb8:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
4000fbbc:	82 00 40 02 	add  %g1, %g2, %g1
                            <== NOT EXECUTED
4000fbc0:	80 a0 c0 01 	cmp  %g3, %g1
                                 <== NOT EXECUTED
4000fbc4:	02 bf ff f6 	be  4000fb9c <_POSIX_signals_Clear_process_signals+0x30>
<== NOT EXECUTED
4000fbc8:	03 10 00 54 	sethi  %hi(0x40015000), %g1
                   <== NOT EXECUTED
}
                                                                    
4000fbcc:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
4000fbd0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000fa18 <_POSIX_signals_Clear_signals>:
                             
  siginfo_t          *info,
                                          
  bool                is_global,
                                     
  bool                check_blocked,
                                 
  bool                do_signals_acquire_release
                     
)
                                                                    
{
                                                                    
4000fa18:	9d e3 bf 98 	save  %sp, -104, %sp
                          <== NOT EXECUTED
4000fa1c:	84 10 20 01 	mov  1, %g2
                                   <== NOT EXECUTED
4000fa20:	86 06 7f ff 	add  %i1, -1, %g3
                             <== NOT EXECUTED
   */
                                                                

                                                                     
  if ( check_blocked )
                                               
    signals_unblocked = api->signals_unblocked;
                      
  else
                                                               
    signals_unblocked = SIGNAL_ALL_MASK;
                             
4000fa24:	88 10 3f ff 	mov  -1, %g4
                                  <== NOT EXECUTED
  if ( check_blocked )
                                               
4000fa28:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
4000fa2c:	02 80 00 03 	be  4000fa38 <_POSIX_signals_Clear_signals+0x20>
<== NOT EXECUTED
4000fa30:	85 28 80 03 	sll  %g2, %g3, %g2
                            <== NOT EXECUTED
    signals_unblocked = api->signals_unblocked;
                      
4000fa34:	c8 06 20 68 	ld  [ %i0 + 0x68 ], %g4
                       <== NOT EXECUTED

                                                                     
  /* XXX is this right for siginfo type signals? */
                  
  /* XXX are we sure they can be cleared the same way? */
            

                                                                     
  if ( do_signals_acquire_release ) {
                                
4000fa38:	80 a7 60 00 	cmp  %i5, 0
                                   <== NOT EXECUTED
4000fa3c:	02 80 00 04 	be  4000fa4c <_POSIX_signals_Clear_signals+0x34>
<== NOT EXECUTED
4000fa40:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000fa44:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    _Thread_queue_Context_initialize( &queue_context );
              
    _POSIX_signals_Acquire( &queue_context );
                        
  }
                                                                  

                                                                     
    if ( is_global ) {
                                               
4000fa48:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
4000fa4c:	22 80 00 10 	be,a   4000fa8c <_POSIX_signals_Clear_signals+0x74>
<== NOT EXECUTED
4000fa50:	f8 06 20 6c 	ld  [ %i0 + 0x6c ], %i4
                       <== NOT EXECUTED
       if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) {
  
4000fa54:	07 10 00 54 	sethi  %hi(0x40015000), %g3
                   <== NOT EXECUTED
4000fa58:	c6 00 e1 1c 	ld  [ %g3 + 0x11c ], %g3	! 4001511c <_POSIX_signals_Pending>
<== NOT EXECUTED
4000fa5c:	84 08 80 03 	and  %g2, %g3, %g2
                            <== NOT EXECUTED
4000fa60:	80 88 80 04 	btst  %g2, %g4
                                <== NOT EXECUTED
4000fa64:	12 80 00 12 	bne  4000faac <_POSIX_signals_Clear_signals+0x94>
<== NOT EXECUTED
4000fa68:	86 10 20 00 	clr  %g3
                                      <== NOT EXECUTED
        api->signals_pending &= ~mask;
                               
        do_callout = true;
                                           
      }
                                                              
    }
                                                                

                                                                     
  if ( do_signals_acquire_release ) {
                                
4000fa6c:	80 a7 60 00 	cmp  %i5, 0
                                   <== NOT EXECUTED
4000fa70:	22 80 00 05 	be,a   4000fa84 <_POSIX_signals_Clear_signals+0x6c>
<== NOT EXECUTED
4000fa74:	b0 08 e0 01 	and  %g3, 1, %i0
                              <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000fa78:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000fa7c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    _POSIX_signals_Release( &queue_context );
                        
  }
                                                                  

                                                                     
  return do_callout;
                                                 
}
                                                                    
4000fa80:	b0 08 e0 01 	and  %g3, 1, %i0
                              <== NOT EXECUTED
4000fa84:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000fa88:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      if ( mask & (api->signals_pending & signals_unblocked) ) {
     
4000fa8c:	b6 0f 00 02 	and  %i4, %g2, %i3
                            <== NOT EXECUTED
4000fa90:	80 8e c0 04 	btst  %i3, %g4
                                <== NOT EXECUTED
4000fa94:	02 bf ff f6 	be  4000fa6c <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4000fa98:	86 10 20 00 	clr  %g3
                                      <== NOT EXECUTED
        api->signals_pending &= ~mask;
                               
4000fa9c:	84 2f 00 02 	andn  %i4, %g2, %g2
                           <== NOT EXECUTED
        do_callout = true;
                                           
4000faa0:	86 10 20 01 	mov  1, %g3
                                   <== NOT EXECUTED
        api->signals_pending &= ~mask;
                               
4000faa4:	10 bf ff f2 	b  4000fa6c <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4000faa8:	c4 26 20 6c 	st  %g2, [ %i0 + 0x6c ]
                       <== NOT EXECUTED
         if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {

4000faac:	85 2e 60 01 	sll  %i1, 1, %g2
                              <== NOT EXECUTED
4000fab0:	07 10 00 53 	sethi  %hi(0x40014c00), %g3
                   <== NOT EXECUTED
4000fab4:	84 00 80 19 	add  %g2, %i1, %g2
                            <== NOT EXECUTED
4000fab8:	86 10 e3 90 	or  %g3, 0x390, %g3
                           <== NOT EXECUTED
4000fabc:	85 28 a0 02 	sll  %g2, 2, %g2
                              <== NOT EXECUTED
4000fac0:	c6 00 c0 02 	ld  [ %g3 + %g2 ], %g3
                        <== NOT EXECUTED
4000fac4:	80 a0 e0 02 	cmp  %g3, 2
                                   <== NOT EXECUTED
4000fac8:	22 80 00 08 	be,a   4000fae8 <_POSIX_signals_Clear_signals+0xd0>
<== NOT EXECUTED
4000facc:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         <== NOT EXECUTED
4000fad0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         <== NOT EXECUTED
         _POSIX_signals_Clear_process_signals( signo );
              
4000fad4:	40 00 00 26 	call  4000fb6c <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4000fad8:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
         do_callout = true;
                                          
4000fadc:	86 10 20 01 	mov  1, %g3
                                   <== NOT EXECUTED
4000fae0:	10 bf ff e3 	b  4000fa6c <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4000fae4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
             _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );

4000fae8:	07 10 00 54 	sethi  %hi(0x40015000), %g3
                   <== NOT EXECUTED
4000faec:	86 10 e1 20 	or  %g3, 0x120, %g3	! 40015120 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
  return _Chain_Immutable_head( the_chain )->next;
                   
4000faf0:	f8 00 80 03 	ld  [ %g2 + %g3 ], %i4
                        <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
4000faf4:	88 00 a0 04 	add  %g2, 4, %g4
                              <== NOT EXECUTED
4000faf8:	88 01 00 03 	add  %g4, %g3, %g4
                            <== NOT EXECUTED
  if ( !_Chain_Is_empty(the_chain))
                                  
4000fafc:	80 a7 00 04 	cmp  %i4, %g4
                                 <== NOT EXECUTED
4000fb00:	02 80 00 17 	be  4000fb5c <_POSIX_signals_Clear_signals+0x144>
<== NOT EXECUTED
4000fb04:	b6 00 80 03 	add  %g2, %g3, %i3
                            <== NOT EXECUTED
  new_first = old_first->next;
                                       
4000fb08:	c8 07 00 00 	ld  [ %i4 ], %g4
                              <== NOT EXECUTED
  head->next = new_first;
                                            
4000fb0c:	c8 20 80 03 	st  %g4, [ %g2 + %g3 ]
                        <== NOT EXECUTED
           _POSIX_signals_Clear_process_signals( signo );
            
4000fb10:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
4000fb14:	40 00 00 16 	call  4000fb6c <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4000fb18:	f6 21 20 04 	st  %i3, [ %g4 + 4 ]
                          <== NOT EXECUTED
             *info = psiginfo->Info;
                                 
4000fb1c:	c4 07 20 08 	ld  [ %i4 + 8 ], %g2
                          <== NOT EXECUTED
4000fb20:	c4 26 80 00 	st  %g2, [ %i2 ]
                              <== NOT EXECUTED
4000fb24:	c4 07 20 0c 	ld  [ %i4 + 0xc ], %g2
                        <== NOT EXECUTED
4000fb28:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]
                          <== NOT EXECUTED
  old_last = tail->previous;
                                         
4000fb2c:	05 10 00 54 	sethi  %hi(0x40015000), %g2
                   <== NOT EXECUTED
4000fb30:	c6 07 20 10 	ld  [ %i4 + 0x10 ], %g3
                       <== NOT EXECUTED
4000fb34:	c6 26 a0 08 	st  %g3, [ %i2 + 8 ]
                          <== NOT EXECUTED
4000fb38:	84 10 a1 10 	or  %g2, 0x110, %g2
                           <== NOT EXECUTED
4000fb3c:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3
                          <== NOT EXECUTED
  the_node->next = tail;
                                             
4000fb40:	88 00 a0 04 	add  %g2, 4, %g4
                              <== NOT EXECUTED
4000fb44:	c8 27 00 00 	st  %g4, [ %i4 ]
                              <== NOT EXECUTED
  tail->previous = the_node;
                                         
4000fb48:	f8 20 a0 08 	st  %i4, [ %g2 + 8 ]
                          <== NOT EXECUTED
  old_last->next = the_node;
                                         
4000fb4c:	f8 20 c0 00 	st  %i4, [ %g3 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
4000fb50:	c6 27 20 04 	st  %g3, [ %i4 + 4 ]
                          <== NOT EXECUTED
4000fb54:	10 bf ff df 	b  4000fad0 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4000fb58:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
           _POSIX_signals_Clear_process_signals( signo );
            
4000fb5c:	40 00 00 04 	call  4000fb6c <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4000fb60:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
4000fb64:	10 bf ff db 	b  4000fad0 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4000fb68:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED

                                                                     
===============================================================================
40011e68 <_POSIX_signals_Default_vectors>:
                           
40011e68:	00 00 00 00 ff ff ff ff 00 00 00 01 00 00 00 00     ................

40011e78:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011e88:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011e98:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011ea8:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011eb8:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011ec8:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011ed8:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011ee8:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011ef8:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011f08:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011f18:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011f28:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011f38:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011f48:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011f58:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011f68:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011f78:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011f88:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011f98:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011fa8:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...

40011fb8:	00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00     ........@.......

40011fc8:	ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff     ....@...........

40011fd8:	40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c     @...........@...


                                                                     
===============================================================================
4000ee6c <_POSIX_signals_Send>:
                                      
int _POSIX_signals_Send(
                                             
  pid_t               pid,
                                           
  int                 sig,
                                           
  const union sigval *value
                                          
)
                                                                    
{
                                                                    
4000ee6c:	9d e3 bf 88 	save  %sp, -120, %sp
                          <== NOT EXECUTED
  Per_CPU_Control             *cpu_self;
                             

                                                                     
  /*
                                                                 
   *  Only supported for the "calling process" (i.e. this node).
     
   */
                                                                
  if ( pid != getpid() )
                                             
4000ee70:	7f ff f9 05 	call  4000d284 <getpid>
                       <== NOT EXECUTED
4000ee74:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000ee78:	80 a2 00 18 	cmp  %o0, %i0
                                 <== NOT EXECUTED
4000ee7c:	12 80 00 e7 	bne  4000f218 <_POSIX_signals_Send+0x3ac>
     <== NOT EXECUTED
4000ee80:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ESRCH );
                   

                                                                     
  /*
                                                                 
   *  Validate the signal passed.
                                    
   */
                                                                
  if ( !sig )
                                                        
4000ee84:	02 80 00 df 	be  4000f200 <_POSIX_signals_Send+0x394>
      <== NOT EXECUTED
4000ee88:	b8 06 7f ff 	add  %i1, -1, %i4
                             <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );
                  

                                                                     
  if ( !is_valid_signo(sig) )
                                        
4000ee8c:	80 a7 20 1f 	cmp  %i4, 0x1f
                                <== NOT EXECUTED
4000ee90:	18 80 00 dc 	bgu  4000f200 <_POSIX_signals_Send+0x394>
     <== NOT EXECUTED
4000ee94:	bb 2e 60 01 	sll  %i1, 1, %i5
                              <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );
                  

                                                                     
  /*
                                                                 
   *  If the signal is being ignored, then we are out of here.
       
   */
                                                                
  if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
         
4000ee98:	37 10 00 53 	sethi  %hi(0x40014c00), %i3
                   <== NOT EXECUTED
4000ee9c:	ba 07 40 19 	add  %i5, %i1, %i5
                            <== NOT EXECUTED
4000eea0:	b6 16 e3 90 	or  %i3, 0x390, %i3
                           <== NOT EXECUTED
4000eea4:	83 2f 60 02 	sll  %i5, 2, %g1
                              <== NOT EXECUTED
4000eea8:	82 06 c0 01 	add  %i3, %g1, %g1
                            <== NOT EXECUTED
4000eeac:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1
                          <== NOT EXECUTED
4000eeb0:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4000eeb4:	02 80 00 56 	be  4000f00c <_POSIX_signals_Send+0x1a0>
      <== NOT EXECUTED
4000eeb8:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  /*
                                                                 
   *  P1003.1c/Draft 10, p. 33 says that certain signals should always

   *  be directed to the executing thread such as those caused by hardware

   *  faults.
                                                        
   */
                                                                
  if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
     
4000eebc:	82 06 7f fc 	add  %i1, -4, %g1
                             <== NOT EXECUTED
4000eec0:	80 88 7f fb 	btst  -5, %g1
                                 <== NOT EXECUTED
4000eec4:	02 80 00 46 	be  4000efdc <_POSIX_signals_Send+0x170>
      <== NOT EXECUTED
4000eec8:	80 a6 60 0b 	cmp  %i1, 0xb
                                 <== NOT EXECUTED
4000eecc:	02 80 00 44 	be  4000efdc <_POSIX_signals_Send+0x170>
      <== NOT EXECUTED
4000eed0:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED

                                                                     
  /*
                                                                 
   *  Build up a siginfo structure
                                   
   */
                                                                
  siginfo = &siginfo_struct;
                                         
  siginfo->si_signo = sig;
                                           
4000eed4:	f2 27 bf f4 	st  %i1, [ %fp + -12 ]
                        <== NOT EXECUTED

                                                                     
static inline sigset_t signo_to_mask(
                                
  uint32_t sig
                                                       
)
                                                                    
{
                                                                    
  return 1u << (sig - 1);
                                            
4000eed8:	b9 28 40 1c 	sll  %g1, %i4, %i4
                            <== NOT EXECUTED
  siginfo->si_code = SI_USER;
                                        
  if ( !value ) {
                                                    
4000eedc:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4000eee0:	02 80 00 99 	be  4000f144 <_POSIX_signals_Send+0x2d8>
      <== NOT EXECUTED
4000eee4:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]
                         <== NOT EXECUTED
    siginfo->si_value.sival_int = 0;
                                 
  } else {
                                                           
    siginfo->si_value = *value;
                                      
4000eee8:	c2 06 80 00 	ld  [ %i2 ], %g1
                              <== NOT EXECUTED
4000eeec:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         <== NOT EXECUTED
  return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );

4000eef0:	b4 10 00 06 	mov  %g6, %i2
                                 <== NOT EXECUTED
  disable_level = cpu_self->thread_dispatch_disable_level;
           
4000eef4:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       <== NOT EXECUTED
  return cpu->executing;
                                             
4000eef8:	d0 01 a0 20 	ld  [ %g6 + 0x20 ], %o0
                       <== NOT EXECUTED
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
4000eefc:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
   *  get it an execute it as soon as the dispatcher executes.
       
   */
                                                                
  the_thread = _Per_CPU_Get_executing( cpu_self );
                   

                                                                     
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
  if ( _POSIX_signals_Is_interested( api, mask ) ) {
                 
4000ef00:	c4 02 21 5c 	ld  [ %o0 + 0x15c ], %g2
                      <== NOT EXECUTED
4000ef04:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       <== NOT EXECUTED
4000ef08:	c2 00 a0 68 	ld  [ %g2 + 0x68 ], %g1
                       <== NOT EXECUTED
4000ef0c:	80 8f 00 01 	btst  %i4, %g1
                                <== NOT EXECUTED
4000ef10:	12 80 00 1a 	bne  4000ef78 <_POSIX_signals_Send+0x10c>
     <== NOT EXECUTED
4000ef14:	03 10 00 4d 	sethi  %hi(0x40013400), %g1
                   <== NOT EXECUTED
   *  There is no requirement on the order of threads pending on a sigwait().

   */
                                                                

                                                                     
  /* XXX violation of visibility -- need to define thread queue support */


                                                                     
  heads = _POSIX_signals_Wait_queue.Queue.heads;
                     
4000ef18:	c4 00 60 dc 	ld  [ %g1 + 0xdc ], %g2	! 400134dc <_POSIX_signals_Wait_queue>
<== NOT EXECUTED
  if ( heads != NULL ) {
                                             
4000ef1c:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000ef20:	02 80 00 3d 	be  4000f014 <_POSIX_signals_Send+0x1a8>
      <== NOT EXECUTED
4000ef24:	17 10 00 46 	sethi  %hi(0x40011800), %o3
                   <== NOT EXECUTED
  return _Chain_Immutable_head( the_chain )->next;
                   
4000ef28:	c2 00 80 00 	ld  [ %g2 ], %g1
                              <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
4000ef2c:	84 00 a0 04 	add  %g2, 4, %g2
                              <== NOT EXECUTED
    Chain_Control *the_chain = &heads->Heads.Fifo;
                   

                                                                     
    for ( the_node = _Chain_First( the_chain );
                      
4000ef30:	80 a0 40 02 	cmp  %g1, %g2
                                 <== NOT EXECUTED
4000ef34:	32 80 00 0d 	bne,a   4000ef68 <_POSIX_signals_Send+0xfc>
   <== NOT EXECUTED
4000ef38:	d0 00 7f f8 	ld  [ %g1 + -8 ], %o0
                         <== NOT EXECUTED
4000ef3c:	10 80 00 37 	b  4000f018 <_POSIX_signals_Send+0x1ac>
       <== NOT EXECUTED
4000ef40:	9e 10 3f ff 	mov  -1, %o7
                                  <== NOT EXECUTED

                                                                     
      /*
                                                             
       * Is this thread is blocked waiting for another signal but has

       * not blocked this one?
                                       
       */
                                                            
      if (api->signals_unblocked & mask)
                             
4000ef44:	c6 01 20 68 	ld  [ %g4 + 0x68 ], %g3
                       <== NOT EXECUTED
4000ef48:	80 8f 00 03 	btst  %i4, %g3
                                <== NOT EXECUTED
4000ef4c:	12 80 00 0c 	bne  4000ef7c <_POSIX_signals_Send+0x110>
     <== NOT EXECUTED
4000ef50:	94 07 bf f4 	add  %fp, -12, %o2
                            <== NOT EXECUTED
          the_node = the_node->next ) {
                              
4000ef54:	c2 00 40 00 	ld  [ %g1 ], %g1
                              <== NOT EXECUTED
    for ( the_node = _Chain_First( the_chain );
                      
4000ef58:	80 a0 40 02 	cmp  %g1, %g2
                                 <== NOT EXECUTED
4000ef5c:	02 80 00 2e 	be  4000f014 <_POSIX_signals_Send+0x1a8>
      <== NOT EXECUTED
4000ef60:	17 10 00 46 	sethi  %hi(0x40011800), %o3
                   <== NOT EXECUTED
4000ef64:	d0 00 7f f8 	ld  [ %g1 + -8 ], %o0
                         <== NOT EXECUTED
      if (the_thread->Wait.option & mask)
                            
4000ef68:	c6 02 20 48 	ld  [ %o0 + 0x48 ], %g3
                       <== NOT EXECUTED
4000ef6c:	80 8f 00 03 	btst  %i4, %g3
                                <== NOT EXECUTED
4000ef70:	02 bf ff f5 	be  4000ef44 <_POSIX_signals_Send+0xd8>
       <== NOT EXECUTED
4000ef74:	c8 02 21 5c 	ld  [ %o0 + 0x15c ], %g4
                      <== NOT EXECUTED

                                                                     
  /*
                                                                 
   *  Returns true if the signal was synchronously given to a thread
 
   *  blocked waiting for the signal.
                                
   */
                                                                
  if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
 
4000ef78:	94 07 bf f4 	add  %fp, -12, %o2
                            <== NOT EXECUTED
4000ef7c:	40 00 01 60 	call  4000f4fc <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4000ef80:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
4000ef84:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000ef88:	12 80 00 1b 	bne  4000eff4 <_POSIX_signals_Send+0x188>
     <== NOT EXECUTED
4000ef8c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
  /*
                                                                 
   *  We may have woken up a thread but we definitely need to post the

   *  signal to the process wide information set.
                    
   */
                                                                
  _POSIX_signals_Set_process_signals( mask );
                        
4000ef90:	40 00 00 f0 	call  4000f350 <_POSIX_signals_Set_process_signals>
<== NOT EXECUTED
4000ef94:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000ef98:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  return psr;
                                                        
4000ef9c:	86 10 00 01 	mov  %g1, %g3
                                 <== NOT EXECUTED

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  _POSIX_signals_Acquire( &queue_context );
                          

                                                                     
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
      
4000efa0:	bb 2f 60 02 	sll  %i5, 2, %i5
                              <== NOT EXECUTED
4000efa4:	c4 06 c0 1d 	ld  [ %i3 + %i5 ], %g2
                        <== NOT EXECUTED
4000efa8:	80 a0 a0 02 	cmp  %g2, 2
                                   <== NOT EXECUTED
4000efac:	02 80 00 6c 	be  4000f15c <_POSIX_signals_Send+0x2f0>
      <== NOT EXECUTED
4000efb0:	09 10 00 54 	sethi  %hi(0x40015000), %g4
                   <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000efb4:	82 10 00 03 	mov  %g3, %g1
                                 <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000efb8:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000efbc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
4000efc0:	c2 06 a0 18 	ld  [ %i2 + 0x18 ], %g1
                       <== NOT EXECUTED
  if ( disable_level == 1 ) {
                                        
4000efc4:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4000efc8:	02 80 00 7f 	be  4000f1c4 <_POSIX_signals_Send+0x358>
      <== NOT EXECUTED
4000efcc:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
4000efd0:	c2 26 a0 18 	st  %g1, [ %i2 + 0x18 ]
                       <== NOT EXECUTED

                                                                     
  _POSIX_signals_Release( &queue_context );
                          
  DEBUG_STEP("\n");
                                                  
  _Thread_Dispatch_enable( cpu_self );
                               
  return 0;
                                                          
}
                                                                    
4000efd4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000efd8:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
      return pthread_kill( pthread_self(), sig );
                    
4000efdc:	7f ff fb 6c 	call  4000dd8c <pthread_self>
                 <== NOT EXECUTED
4000efe0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000efe4:	40 00 02 2a 	call  4000f88c <pthread_kill>
                 <== NOT EXECUTED
4000efe8:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
4000efec:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000eff0:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
4000eff4:	c2 06 a0 18 	ld  [ %i2 + 0x18 ], %g1
                       <== NOT EXECUTED
  if ( disable_level == 1 ) {
                                        
4000eff8:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4000effc:	02 80 00 72 	be  4000f1c4 <_POSIX_signals_Send+0x358>
      <== NOT EXECUTED
4000f000:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    return 0;
                                                        
4000f004:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
4000f008:	c2 26 a0 18 	st  %g1, [ %i2 + 0x18 ]
                       <== NOT EXECUTED
4000f00c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f010:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    for ( the_node = _Chain_First( the_chain );
                      
4000f014:	9e 10 3f ff 	mov  -1, %o7
                                  <== NOT EXECUTED
4000f018:	94 10 3f ff 	mov  -1, %o2
                                  <== NOT EXECUTED
4000f01c:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
4000f020:	98 10 20 02 	mov  2, %o4
                                   <== NOT EXECUTED
 */
                                                                  
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
       
  States_Control the_states
                                          
)
                                                                    
{
                                                                    
   return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
             
4000f024:	13 04 00 00 	sethi  %hi(0x10000000), %o1
                   <== NOT EXECUTED
4000f028:	96 12 e2 84 	or  %o3, 0x284, %o3
                           <== NOT EXECUTED
    if ( !_Objects_Information_table[ the_api ] )
                    
4000f02c:	83 2b 20 02 	sll  %o4, 2, %g1
                              <== NOT EXECUTED
4000f030:	c2 02 c0 01 	ld  [ %o3 + %g1 ], %g1
                        <== NOT EXECUTED
4000f034:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4000f038:	02 80 00 39 	be  4000f11c <_POSIX_signals_Send+0x2b0>
      <== NOT EXECUTED
4000f03c:	80 a3 20 03 	cmp  %o4, 3
                                   <== NOT EXECUTED
    the_info = _Objects_Information_table[ the_api ][ 1 ];
           
4000f040:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1
                          <== NOT EXECUTED
    if ( !the_info )
                                                 
4000f044:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4000f048:	02 80 00 35 	be  4000f11c <_POSIX_signals_Send+0x2b0>
      <== NOT EXECUTED
4000f04c:	80 a3 20 03 	cmp  %o4, 3
                                   <== NOT EXECUTED
    maximum = the_info->maximum;
                                     
4000f050:	f0 10 60 10 	lduh  [ %g1 + 0x10 ], %i0
                     <== NOT EXECUTED
    for ( index = 1 ; index <= maximum ; index++ ) {
                 
4000f054:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
4000f058:	02 80 00 30 	be  4000f118 <_POSIX_signals_Send+0x2ac>
      <== NOT EXECUTED
4000f05c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1
                       <== NOT EXECUTED
4000f060:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
4000f064:	b1 2e 20 02 	sll  %i0, 2, %i0
                              <== NOT EXECUTED
4000f068:	b0 06 00 01 	add  %i0, %g1, %i0
                            <== NOT EXECUTED
      the_thread = (Thread_Control *) object_table[ index ];
         
4000f06c:	c4 00 40 00 	ld  [ %g1 ], %g2
                              <== NOT EXECUTED
      if ( !the_thread )
                                             
4000f070:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f074:	22 80 00 26 	be,a   4000f10c <_POSIX_signals_Send+0x2a0>
   <== NOT EXECUTED
4000f078:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
4000f07c:	c6 00 a0 38 	ld  [ %g2 + 0x38 ], %g3
                       <== NOT EXECUTED
4000f080:	c8 00 e0 18 	ld  [ %g3 + 0x18 ], %g4
                       <== NOT EXECUTED
      if ( _Thread_Get_priority( the_thread ) > interested_priority )

4000f084:	80 a1 00 0f 	cmp  %g4, %o7
                                 <== NOT EXECUTED
4000f088:	18 80 00 20 	bgu  4000f108 <_POSIX_signals_Send+0x29c>
     <== NOT EXECUTED
4000f08c:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3
                       <== NOT EXECUTED
4000f090:	02 80 00 29 	be  4000f134 <_POSIX_signals_Send+0x2c8>
      <== NOT EXECUTED
4000f094:	80 a0 c0 0a 	cmp  %g3, %o2
                                 <== NOT EXECUTED
      if ( !_POSIX_signals_Is_interested( api, mask ) )
              
4000f098:	da 00 a1 5c 	ld  [ %g2 + 0x15c ], %o5
                      <== NOT EXECUTED
4000f09c:	da 03 60 68 	ld  [ %o5 + 0x68 ], %o5
                       <== NOT EXECUTED
4000f0a0:	80 8f 00 0d 	btst  %i4, %o5
                                <== NOT EXECUTED
4000f0a4:	02 80 00 19 	be  4000f108 <_POSIX_signals_Send+0x29c>
      <== NOT EXECUTED
4000f0a8:	80 a3 c0 04 	cmp  %o7, %g4
                                 <== NOT EXECUTED
      if ( _Thread_Get_priority( the_thread ) < interested_priority ) {

4000f0ac:	38 80 00 15 	bgu,a   4000f100 <_POSIX_signals_Send+0x294>
  <== NOT EXECUTED
4000f0b0:	9e 10 00 04 	mov  %g4, %o7
                                 <== NOT EXECUTED
4000f0b4:	02 80 00 26 	be  4000f14c <_POSIX_signals_Send+0x2e0>
      <== NOT EXECUTED
4000f0b8:	80 a2 80 03 	cmp  %o2, %g3
                                 <== NOT EXECUTED
      if ( interested && !_States_Is_ready( interested->current_state ) ) {

4000f0bc:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000f0c0:	22 80 00 13 	be,a   4000f10c <_POSIX_signals_Send+0x2a0>
   <== NOT EXECUTED
4000f0c4:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
4000f0c8:	da 02 20 1c 	ld  [ %o0 + 0x1c ], %o5
                       <== NOT EXECUTED
4000f0cc:	80 a3 60 00 	cmp  %o5, 0
                                   <== NOT EXECUTED
4000f0d0:	22 80 00 0f 	be,a   4000f10c <_POSIX_signals_Send+0x2a0>
   <== NOT EXECUTED
4000f0d4:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
        if ( _States_Is_ready( the_thread->current_state ) ) {
       
4000f0d8:	e0 00 a0 1c 	ld  [ %g2 + 0x1c ], %l0
                       <== NOT EXECUTED
4000f0dc:	80 a4 20 00 	cmp  %l0, 0
                                   <== NOT EXECUTED
4000f0e0:	02 80 00 07 	be  4000f0fc <_POSIX_signals_Send+0x290>
      <== NOT EXECUTED
4000f0e4:	80 8b 40 09 	btst  %o5, %o1
                                <== NOT EXECUTED
        if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {

4000f0e8:	32 80 00 09 	bne,a   4000f10c <_POSIX_signals_Send+0x2a0>
  <== NOT EXECUTED
4000f0ec:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
          if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {

4000f0f0:	80 8c 00 09 	btst  %l0, %o1
                                <== NOT EXECUTED
4000f0f4:	22 80 00 06 	be,a   4000f10c <_POSIX_signals_Send+0x2a0>
   <== NOT EXECUTED
4000f0f8:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
4000f0fc:	9e 10 00 04 	mov  %g4, %o7
                                 <== NOT EXECUTED
4000f100:	94 10 00 03 	mov  %g3, %o2
                                 <== NOT EXECUTED
4000f104:	90 10 00 02 	mov  %g2, %o0
                                 <== NOT EXECUTED
4000f108:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
    for ( index = 1 ; index <= maximum ; index++ ) {
                 
4000f10c:	80 a6 00 01 	cmp  %i0, %g1
                                 <== NOT EXECUTED
4000f110:	32 bf ff d8 	bne,a   4000f070 <_POSIX_signals_Send+0x204>
  <== NOT EXECUTED
4000f114:	c4 00 40 00 	ld  [ %g1 ], %g2
                              <== NOT EXECUTED
  for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {

4000f118:	80 a3 20 03 	cmp  %o4, 3
                                   <== NOT EXECUTED
4000f11c:	12 bf ff c4 	bne  4000f02c <_POSIX_signals_Send+0x1c0>
     <== NOT EXECUTED
4000f120:	98 10 20 03 	mov  3, %o4
                                   <== NOT EXECUTED
  if ( interested ) {
                                                
4000f124:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000f128:	12 bf ff 95 	bne  4000ef7c <_POSIX_signals_Send+0x110>
     <== NOT EXECUTED
4000f12c:	94 07 bf f4 	add  %fp, -12, %o2
                            <== NOT EXECUTED
4000f130:	30 bf ff 98 	b,a   4000ef90 <_POSIX_signals_Send+0x124>
    <== NOT EXECUTED
      if ( _Thread_Get_priority( the_thread ) > interested_priority )

4000f134:	28 bf ff da 	bleu,a   4000f09c <_POSIX_signals_Send+0x230>
 <== NOT EXECUTED
4000f138:	da 00 a1 5c 	ld  [ %g2 + 0x15c ], %o5
                      <== NOT EXECUTED
4000f13c:	10 bf ff f4 	b  4000f10c <_POSIX_signals_Send+0x2a0>
       <== NOT EXECUTED
4000f140:	82 00 60 04 	add  %g1, 4, %g1
                              <== NOT EXECUTED
4000f144:	10 bf ff 6b 	b  4000eef0 <_POSIX_signals_Send+0x84>
        <== NOT EXECUTED
4000f148:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
      if ( _Thread_Get_priority( the_thread ) < interested_priority ) {

4000f14c:	08 bf ff dd 	bleu  4000f0c0 <_POSIX_signals_Send+0x254>
    <== NOT EXECUTED
4000f150:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000f154:	10 bf ff eb 	b  4000f100 <_POSIX_signals_Send+0x294>
       <== NOT EXECUTED
4000f158:	9e 10 00 04 	mov  %g4, %o7
                                 <== NOT EXECUTED
  return _Chain_Immutable_head( the_chain )->next;
                   
4000f15c:	c4 01 21 10 	ld  [ %g4 + 0x110 ], %g2
                      <== NOT EXECUTED
4000f160:	b8 11 21 10 	or  %g4, 0x110, %i4
                           <== NOT EXECUTED
  if ( !_Chain_Is_empty(the_chain))
                                  
4000f164:	b6 07 20 04 	add  %i4, 4, %i3
                              <== NOT EXECUTED
4000f168:	80 a0 80 1b 	cmp  %g2, %i3
                                 <== NOT EXECUTED
4000f16c:	02 80 00 31 	be  4000f230 <_POSIX_signals_Send+0x3c4>
      <== NOT EXECUTED
4000f170:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  new_first = old_first->next;
                                       
4000f174:	c2 00 80 00 	ld  [ %g2 ], %g1
                              <== NOT EXECUTED
  new_first->previous = head;
                                        
4000f178:	f8 20 60 04 	st  %i4, [ %g1 + 4 ]
                          <== NOT EXECUTED
    psiginfo->Info = *siginfo;
                                       
4000f17c:	f6 07 bf fc 	ld  [ %fp + -4 ], %i3
                         <== NOT EXECUTED
4000f180:	f2 07 bf f8 	ld  [ %fp + -8 ], %i1
                         <== NOT EXECUTED
  head->next = new_first;
                                            
4000f184:	c2 21 21 10 	st  %g1, [ %g4 + 0x110 ]
                      <== NOT EXECUTED
    _Chain_Append_unprotected(
                                       
4000f188:	03 10 00 54 	sethi  %hi(0x40015000), %g1
                   <== NOT EXECUTED
    psiginfo->Info = *siginfo;
                                       
4000f18c:	c8 07 bf f4 	ld  [ %fp + -12 ], %g4
                        <== NOT EXECUTED
4000f190:	c8 20 a0 08 	st  %g4, [ %g2 + 8 ]
                          <== NOT EXECUTED
    _Chain_Append_unprotected(
                                       
4000f194:	82 10 61 20 	or  %g1, 0x120, %g1
                           <== NOT EXECUTED
    psiginfo->Info = *siginfo;
                                       
4000f198:	f2 20 a0 0c 	st  %i1, [ %g2 + 0xc ]
                        <== NOT EXECUTED
    _Chain_Append_unprotected(
                                       
4000f19c:	b8 07 40 01 	add  %i5, %g1, %i4
                            <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
4000f1a0:	ba 07 60 04 	add  %i5, 4, %i5
                              <== NOT EXECUTED
  old_last = tail->previous;
                                         
4000f1a4:	c8 07 20 08 	ld  [ %i4 + 8 ], %g4
                          <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
4000f1a8:	ba 07 40 01 	add  %i5, %g1, %i5
                            <== NOT EXECUTED
    psiginfo->Info = *siginfo;
                                       
4000f1ac:	f6 20 a0 10 	st  %i3, [ %g2 + 0x10 ]
                       <== NOT EXECUTED
  the_node->next = tail;
                                             
4000f1b0:	fa 20 80 00 	st  %i5, [ %g2 ]
                              <== NOT EXECUTED
  tail->previous = the_node;
                                         
4000f1b4:	c4 27 20 08 	st  %g2, [ %i4 + 8 ]
                          <== NOT EXECUTED
  old_last->next = the_node;
                                         
4000f1b8:	c4 21 00 00 	st  %g2, [ %g4 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
4000f1bc:	10 bf ff 7e 	b  4000efb4 <_POSIX_signals_Send+0x148>
       <== NOT EXECUTED
4000f1c0:	c8 20 a0 04 	st  %g4, [ %g2 + 4 ]
                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f1c4:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
4000f1c8:	c4 0e a0 1c 	ldub  [ %i2 + 0x1c ], %g2
                     <== NOT EXECUTED
4000f1cc:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f1d0:	12 80 00 07 	bne  4000f1ec <_POSIX_signals_Send+0x380>
     <== NOT EXECUTED
4000f1d4:	92 10 00 01 	mov  %g1, %o1
                                 <== NOT EXECUTED
      cpu_self->thread_dispatch_disable_level = 0;
                   
4000f1d8:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f1dc:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f1e0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  return 0;
                                                          
4000f1e4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f1e8:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
      _Thread_Do_dispatch( cpu_self, level );
                        
4000f1ec:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]
                        <== NOT EXECUTED
4000f1f0:	7f ff fd f3 	call  4000e9bc <_Thread_Do_dispatch>
          <== NOT EXECUTED
4000f1f4:	90 10 00 1a 	mov  %i2, %o0
                                 <== NOT EXECUTED
4000f1f8:	10 bf ff f9 	b  4000f1dc <_POSIX_signals_Send+0x370>
       <== NOT EXECUTED
4000f1fc:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1
                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
4000f200:	40 00 02 7c 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000f204:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
4000f208:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
4000f20c:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000f210:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f214:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ESRCH );
                   
4000f218:	40 00 02 76 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000f21c:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
4000f220:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
4000f224:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000f228:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f22c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
4000f230:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f234:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
4000f238:	c2 06 a0 18 	ld  [ %i2 + 0x18 ], %g1
                       <== NOT EXECUTED
  if ( disable_level == 1 ) {
                                        
4000f23c:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4000f240:	02 80 00 09 	be  4000f264 <_POSIX_signals_Send+0x3f8>
      <== NOT EXECUTED
4000f244:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
4000f248:	c2 26 a0 18 	st  %g1, [ %i2 + 0x18 ]
                       <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( EAGAIN );
                
4000f24c:	40 00 02 69 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000f250:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
4000f254:	82 10 20 0b 	mov  0xb, %g1
                                 <== NOT EXECUTED
4000f258:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000f25c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f260:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f264:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
4000f268:	c4 0e a0 1c 	ldub  [ %i2 + 0x1c ], %g2
                     <== NOT EXECUTED
4000f26c:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f270:	12 80 00 06 	bne  4000f288 <_POSIX_signals_Send+0x41c>
     <== NOT EXECUTED
4000f274:	92 10 00 01 	mov  %g1, %o1
                                 <== NOT EXECUTED
      cpu_self->thread_dispatch_disable_level = 0;
                   
4000f278:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f27c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f280:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000f284:	30 bf ff f2 	b,a   4000f24c <_POSIX_signals_Send+0x3e0>
    <== NOT EXECUTED
      _Thread_Do_dispatch( cpu_self, level );
                        
4000f288:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]
                        <== NOT EXECUTED
4000f28c:	7f ff fd cc 	call  4000e9bc <_Thread_Do_dispatch>
          <== NOT EXECUTED
4000f290:	90 10 00 1a 	mov  %i2, %o0
                                 <== NOT EXECUTED
4000f294:	10 bf ff fa 	b  4000f27c <_POSIX_signals_Send+0x410>
       <== NOT EXECUTED
4000f298:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1
                        <== NOT EXECUTED

                                                                     
===============================================================================
4000f350 <_POSIX_signals_Set_process_signals>:
                       
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f350:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
{
                                                                    
  Thread_queue_Context queue_context;
                                

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  _POSIX_signals_Acquire( &queue_context );
                          
    _POSIX_signals_Pending |= mask;
                                  
4000f354:	07 10 00 54 	sethi  %hi(0x40015000), %g3
                   <== NOT EXECUTED
4000f358:	c4 00 e1 1c 	ld  [ %g3 + 0x11c ], %g2	! 4001511c <_POSIX_signals_Pending>
<== NOT EXECUTED
4000f35c:	90 10 80 08 	or  %g2, %o0, %o0
                             <== NOT EXECUTED
4000f360:	d0 20 e1 1c 	st  %o0, [ %g3 + 0x11c ]
                      <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f364:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f368:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _POSIX_signals_Release( &queue_context );
                          
}
                                                                    
4000f36c:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
4000f370:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000f4fc <_POSIX_signals_Unblock_thread>:
                            
bool _POSIX_signals_Unblock_thread(
                                  
  Thread_Control  *the_thread,
                                       
  int              signo,
                                            
  siginfo_t       *info
                                              
)
                                                                    
{
                                                                    
4000f4fc:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  POSIX_API_Control  *api;
                                           
  sigset_t            mask;
                                          
  siginfo_t          *the_info = NULL;
                               

                                                                     
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
4000f500:	fa 06 21 5c 	ld  [ %i0 + 0x15c ], %i5
                      <== NOT EXECUTED

                                                                     
  /*
                                                                 
   *  Is the thread is specifically waiting for a signal?
            
   */
                                                                

                                                                     
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {

4000f504:	c6 06 20 1c 	ld  [ %i0 + 0x1c ], %g3
                       <== NOT EXECUTED
4000f508:	05 04 00 01 	sethi  %hi(0x10000400), %g2
                   <== NOT EXECUTED
4000f50c:	88 10 20 01 	mov  1, %g4
                                   <== NOT EXECUTED
4000f510:	82 06 7f ff 	add  %i1, -1, %g1
                             <== NOT EXECUTED
4000f514:	b8 08 c0 02 	and  %g3, %g2, %i4
                            <== NOT EXECUTED
4000f518:	83 29 00 01 	sll  %g4, %g1, %g1
                            <== NOT EXECUTED
4000f51c:	80 a7 00 02 	cmp  %i4, %g2
                                 <== NOT EXECUTED
4000f520:	02 80 00 19 	be  4000f584 <_POSIX_signals_Unblock_thread+0x88>
<== NOT EXECUTED
4000f524:	b6 07 60 70 	add  %i5, 0x70, %i3
                           <== NOT EXECUTED
  }
                                                                  

                                                                     
  /*
                                                                 
   *  Thread is not waiting due to a sigwait.
                        
   */
                                                                
  if ( api->signals_unblocked & mask ) {
                             
4000f528:	c4 07 60 68 	ld  [ %i5 + 0x68 ], %g2
                       <== NOT EXECUTED
4000f52c:	80 88 40 02 	btst  %g1, %g2
                                <== NOT EXECUTED
4000f530:	02 80 00 05 	be  4000f544 <_POSIX_signals_Unblock_thread+0x48>
<== NOT EXECUTED
4000f534:	03 04 00 00 	sethi  %hi(0x10000000), %g1
                   <== NOT EXECUTED
     *      it is not blocked, THEN
                                  
     *        we need to dispatch at the end of this ISR.
            
     *    + Any other combination, do nothing.
                       
     */
                                                              

                                                                     
    if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {

4000f538:	80 88 c0 01 	btst  %g3, %g1
                                <== NOT EXECUTED
4000f53c:	12 80 00 4b 	bne  4000f668 <_POSIX_signals_Unblock_thread+0x16c>
<== NOT EXECUTED
4000f540:	82 10 24 0d 	mov  0x40d, %g1
                               <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f544:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  action->handler = handler;
                                         
4000f548:	05 10 00 3d 	sethi  %hi(0x4000f400), %g2
                   <== NOT EXECUTED
4000f54c:	84 10 a0 10 	or  %g2, 0x10, %g2	! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f550:	c4 27 60 78 	st  %g2, [ %i5 + 0x78 ]
                       <== NOT EXECUTED
 cpu_self->dispatch_necessary = true;
                                
4000f554:	86 10 20 01 	mov  1, %g3
                                   <== NOT EXECUTED
4000f558:	c6 29 a0 1c 	stb  %g3, [ %g6 + 0x1c ]
                      <== NOT EXECUTED
  if ( _Chain_Is_node_off_chain( the_node ) ) {
                      
4000f55c:	c4 07 60 70 	ld  [ %i5 + 0x70 ], %g2
                       <== NOT EXECUTED
4000f560:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f564:	22 80 00 1a 	be,a   4000f5cc <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
4000f568:	c4 06 20 e8 	ld  [ %i0 + 0xe8 ], %g2
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f56c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f570:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      the_thread->Wait.return_code = STATUS_INTERRUPTED;
             
      _Thread_queue_Extract_with_proxy( the_thread );
                
    }
                                                                
  }
                                                                  
  return _POSIX_signals_Unblock_thread_done( the_thread, api, false );

4000f574:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>
                     <== NOT EXECUTED
}
                                                                    
4000f578:	b0 0e 20 01 	and  %i0, 1, %i0
                              <== NOT EXECUTED
4000f57c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f580:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {

4000f584:	c4 06 20 48 	ld  [ %i0 + 0x48 ], %g2
                       <== NOT EXECUTED
4000f588:	80 88 40 02 	btst  %g1, %g2
                                <== NOT EXECUTED
4000f58c:	32 80 00 16 	bne,a   4000f5e4 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
4000f590:	82 10 24 0d 	mov  0x40d, %g1
                               <== NOT EXECUTED
4000f594:	c4 07 60 68 	ld  [ %i5 + 0x68 ], %g2
                       <== NOT EXECUTED
4000f598:	80 88 40 02 	btst  %g1, %g2
                                <== NOT EXECUTED
4000f59c:	12 80 00 12 	bne  4000f5e4 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
4000f5a0:	82 10 24 0d 	mov  0x40d, %g1
                               <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f5a4:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
4000f5a8:	05 10 00 3d 	sethi  %hi(0x4000f400), %g2
                   <== NOT EXECUTED
4000f5ac:	84 10 a0 10 	or  %g2, 0x10, %g2	! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f5b0:	c4 27 60 78 	st  %g2, [ %i5 + 0x78 ]
                       <== NOT EXECUTED
4000f5b4:	c8 29 a0 1c 	stb  %g4, [ %g6 + 0x1c ]
                      <== NOT EXECUTED
4000f5b8:	c4 07 60 70 	ld  [ %i5 + 0x70 ], %g2
                       <== NOT EXECUTED
4000f5bc:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f5c0:	12 bf ff eb 	bne  4000f56c <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4000f5c4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  old_last = tail->previous;
                                         
4000f5c8:	c4 06 20 e8 	ld  [ %i0 + 0xe8 ], %g2
                       <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
4000f5cc:	86 06 20 e4 	add  %i0, 0xe4, %g3
                           <== NOT EXECUTED
  the_node->next = tail;
                                             
4000f5d0:	c6 27 60 70 	st  %g3, [ %i5 + 0x70 ]
                       <== NOT EXECUTED
  tail->previous = the_node;
                                         
4000f5d4:	f6 26 20 e8 	st  %i3, [ %i0 + 0xe8 ]
                       <== NOT EXECUTED
  old_last->next = the_node;
                                         
4000f5d8:	f6 20 80 00 	st  %i3, [ %g2 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
4000f5dc:	10 bf ff e4 	b  4000f56c <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4000f5e0:	c4 27 60 74 	st  %g2, [ %i5 + 0x74 ]
                       <== NOT EXECUTED
      the_thread->Wait.return_code = STATUS_INTERRUPTED;
             
4000f5e4:	c2 26 20 4c 	st  %g1, [ %i0 + 0x4c ]
                       <== NOT EXECUTED
      if ( !info ) {
                                                 
4000f5e8:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4000f5ec:	02 80 00 2e 	be  4000f6a4 <_POSIX_signals_Unblock_thread+0x1a8>
<== NOT EXECUTED
4000f5f0:	c2 06 20 40 	ld  [ %i0 + 0x40 ], %g1
                       <== NOT EXECUTED
        *the_info = *info;
                                           
4000f5f4:	c4 06 80 00 	ld  [ %i2 ], %g2
                              <== NOT EXECUTED
4000f5f8:	c4 20 40 00 	st  %g2, [ %g1 ]
                              <== NOT EXECUTED
4000f5fc:	c4 06 a0 04 	ld  [ %i2 + 4 ], %g2
                          <== NOT EXECUTED
4000f600:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]
                          <== NOT EXECUTED
4000f604:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2
                          <== NOT EXECUTED
4000f608:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]
                          <== NOT EXECUTED
      _Thread_queue_Extract_with_proxy( the_thread );
                
4000f60c:	7f ff fd 46 	call  4000eb24 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4000f610:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4000f614:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
4000f618:	05 10 00 3d 	sethi  %hi(0x4000f400), %g2
                   <== NOT EXECUTED
4000f61c:	84 10 a0 10 	or  %g2, 0x10, %g2	! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f620:	c4 27 60 78 	st  %g2, [ %i5 + 0x78 ]
                       <== NOT EXECUTED
4000f624:	86 10 20 01 	mov  1, %g3
                                   <== NOT EXECUTED
4000f628:	c6 29 a0 1c 	stb  %g3, [ %g6 + 0x1c ]
                      <== NOT EXECUTED
  if ( _Chain_Is_node_off_chain( the_node ) ) {
                      
4000f62c:	c4 07 60 70 	ld  [ %i5 + 0x70 ], %g2
                       <== NOT EXECUTED
4000f630:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f634:	12 80 00 07 	bne  4000f650 <_POSIX_signals_Unblock_thread+0x154>
<== NOT EXECUTED
4000f638:	86 06 20 e4 	add  %i0, 0xe4, %g3
                           <== NOT EXECUTED
  old_last = tail->previous;
                                         
4000f63c:	c4 06 20 e8 	ld  [ %i0 + 0xe8 ], %g2
                       <== NOT EXECUTED
  the_node->next = tail;
                                             
4000f640:	c6 27 60 70 	st  %g3, [ %i5 + 0x70 ]
                       <== NOT EXECUTED
  tail->previous = the_node;
                                         
4000f644:	f6 26 20 e8 	st  %i3, [ %i0 + 0xe8 ]
                       <== NOT EXECUTED
  old_last->next = the_node;
                                         
4000f648:	f6 20 80 00 	st  %i3, [ %g2 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
4000f64c:	c4 27 60 74 	st  %g2, [ %i5 + 0x74 ]
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f650:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f654:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      return _POSIX_signals_Unblock_thread_done( the_thread, api, true );

4000f658:	b0 10 20 01 	mov  1, %i0	! 1 <_TLS_Alignment>
              <== NOT EXECUTED
}
                                                                    
4000f65c:	b0 0e 20 01 	and  %i0, 1, %i0
                              <== NOT EXECUTED
4000f660:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f664:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      the_thread->Wait.return_code = STATUS_INTERRUPTED;
             
4000f668:	c2 26 20 4c 	st  %g1, [ %i0 + 0x4c ]
                       <== NOT EXECUTED
      _Thread_queue_Extract_with_proxy( the_thread );
                
4000f66c:	7f ff fd 2e 	call  4000eb24 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4000f670:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f674:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
4000f678:	05 10 00 3d 	sethi  %hi(0x4000f400), %g2
                   <== NOT EXECUTED
4000f67c:	84 10 a0 10 	or  %g2, 0x10, %g2	! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f680:	c4 27 60 78 	st  %g2, [ %i5 + 0x78 ]
                       <== NOT EXECUTED
4000f684:	86 10 20 01 	mov  1, %g3
                                   <== NOT EXECUTED
4000f688:	c6 29 a0 1c 	stb  %g3, [ %g6 + 0x1c ]
                      <== NOT EXECUTED
  if ( _Chain_Is_node_off_chain( the_node ) ) {
                      
4000f68c:	c4 07 60 70 	ld  [ %i5 + 0x70 ], %g2
                       <== NOT EXECUTED
4000f690:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f694:	12 bf ff b6 	bne  4000f56c <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4000f698:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  old_last = tail->previous;
                                         
4000f69c:	10 bf ff cc 	b  4000f5cc <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
4000f6a0:	c4 06 20 e8 	ld  [ %i0 + 0xe8 ], %g2
                       <== NOT EXECUTED
        the_info->si_code = SI_USER;
                                 
4000f6a4:	84 10 20 01 	mov  1, %g2
                                   <== NOT EXECUTED
        the_info->si_signo = signo;
                                  
4000f6a8:	f2 20 40 00 	st  %i1, [ %g1 ]
                              <== NOT EXECUTED
        the_info->si_code = SI_USER;
                                 
4000f6ac:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]
                          <== NOT EXECUTED
4000f6b0:	10 bf ff d7 	b  4000f60c <_POSIX_signals_Unblock_thread+0x110>
<== NOT EXECUTED
4000f6b4:	c0 20 60 08 	clr  [ %g1 + 8 ]
                              <== NOT EXECUTED

                                                                     
===============================================================================
40005c38 <clock_gettime>:
                                            

                                                                     
int clock_gettime(
                                                   
  clockid_t        clock_id,
                                         
  struct timespec *tp
                                                
)
                                                                    
{
                                                                    
40005c38:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  if ( !tp )
                                                         
40005c3c:	80 a6 60 00 	cmp  %i1, 0
                                   
40005c40:	02 80 00 1f 	be  40005cbc <clock_gettime+0x84>
             <== NEVER TAKEN
40005c44:	80 a6 20 01 	cmp  %i0, 1
                                   
    rtems_set_errno_and_return_minus_one( EINVAL );
                  

                                                                     
  if ( clock_id == CLOCK_REALTIME ) {
                                
40005c48:	02 80 00 18 	be  40005ca8 <clock_gettime+0x70>
             <== ALWAYS TAKEN
40005c4c:	82 06 3f fe 	add  %i0, -2, %g1
                             
    return 0;
                                                        
  }
                                                                  
#endif
                                                               

                                                                     
#ifdef _POSIX_CPUTIME
                                                
  if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
                      
40005c50:	80 88 7f fd 	btst  -3, %g1
                                 <== NOT EXECUTED
40005c54:	02 80 00 0a 	be  40005c7c <clock_gettime+0x44>
             <== NOT EXECUTED
40005c58:	80 a6 20 03 	cmp  %i0, 3
                                   <== NOT EXECUTED
    return 0;
                                                        
  }
                                                                  
#endif
                                                               

                                                                     
#ifdef _POSIX_THREAD_CPUTIME
                                         
  if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
                         
40005c5c:	02 80 00 0d 	be  40005c90 <clock_gettime+0x58>
             <== NOT EXECUTED
40005c60:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOSYS );
                  
#endif
                                                               

                                                                     
  rtems_set_errno_and_return_minus_one( EINVAL );
                    
40005c64:	40 00 22 5f 	call  4000e5e0 <__errno>
                      <== NOT EXECUTED
40005c68:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
40005c6c:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40005c70:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED

                                                                     
  return 0;
                                                          
}
                                                                    
40005c74:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005c78:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    _Timecounter_Nanouptime( tp );
                                   
40005c7c:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
40005c80:	40 00 09 2a 	call  40008128 <_Timecounter_Nanouptime>
      <== NOT EXECUTED
40005c84:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
    return 0;
                                                        
40005c88:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005c8c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOSYS );
                  
40005c90:	40 00 22 54 	call  4000e5e0 <__errno>
                      <== NOT EXECUTED
40005c94:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40005c98:	82 10 20 58 	mov  0x58, %g1
                                <== NOT EXECUTED
40005c9c:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40005ca0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005ca4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  _Timecounter_Nanotime( tod );
                                      
40005ca8:	90 10 00 19 	mov  %i1, %o0
                                 
40005cac:	40 00 09 5a 	call  40008214 <_Timecounter_Nanotime>
        
40005cb0:	b0 10 20 00 	clr  %i0
                                      
    return 0;
                                                        
40005cb4:	81 c7 e0 08 	ret 
                                          
40005cb8:	81 e8 00 00 	restore 
                                      
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
40005cbc:	40 00 22 49 	call  4000e5e0 <__errno>
                      <== NOT EXECUTED
40005cc0:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40005cc4:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40005cc8:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40005ccc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005cd0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40005e80 <clock_nanosleep>:
                                          
  if ( clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC ) {
 
40005e80:	80 a2 20 01 	cmp  %o0, 1
                                   
40005e84:	02 80 00 04 	be  40005e94 <clock_nanosleep+0x14>
           <== ALWAYS TAKEN
40005e88:	80 a2 20 04 	cmp  %o0, 4
                                   
40005e8c:	12 80 00 05 	bne  40005ea0 <clock_nanosleep+0x20>
          <== NOT EXECUTED
40005e90:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40005e94:	82 13 c0 00 	mov  %o7, %g1
                                 
40005e98:	7f ff ff 8c 	call  40005cc8 <clock_nanosleep.part.6>
       
40005e9c:	9e 10 40 00 	mov  %g1, %o7
                                 
    }
                                                                
  }
                                                                  

                                                                     
  return eno;
                                                        
}
                                                                    
40005ea0:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005ea4:	90 10 20 86 	mov  0x86, %o0
                                <== NOT EXECUTED

                                                                     
===============================================================================
4000d6c4 <kill>:
                                                     
int kill(
                                                            
  pid_t pid,
                                                         
  int   sig
                                                          
)
                                                                    
{
                                                                    
  return _POSIX_signals_Send( pid, sig, NULL );
                      
4000d6c4:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
4000d6c8:	82 13 c0 00 	mov  %o7, %g1
                                 <== NOT EXECUTED
4000d6cc:	40 00 05 e8 	call  4000ee6c <_POSIX_signals_Send>
          <== NOT EXECUTED
4000d6d0:	9e 10 40 00 	mov  %g1, %o7
                                 <== NOT EXECUTED

                                                                     
===============================================================================
40006110 <mq_close>:
                                                 
 */
                                                                  

                                                                     
int mq_close(
                                                        
  mqd_t  mqdes
                                                       
)
                                                                    
{
                                                                    
40006110:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  _RTEMS_Lock_allocator();
                                           
40006114:	40 00 02 46 	call  40006a2c <_RTEMS_Lock_allocator>
        
40006118:	01 00 00 00 	nop 
                                          
  Objects_Id            id,
                                          
  Thread_queue_Context *queue_context
                                
)
                                                                    
{
                                                                    
  _Thread_queue_Context_initialize( queue_context );
                 
  return (POSIX_Message_queue_Control *) _Objects_Get(
               
4000611c:	92 07 bf dc 	add  %fp, -36, %o1
                            
40006120:	15 10 00 52 	sethi  %hi(0x40014800), %o2
                   
40006124:	90 10 00 18 	mov  %i0, %o0
                                 
40006128:	40 00 0a 79 	call  40008b0c <_Objects_Get>
                 
4000612c:	94 12 a1 d0 	or  %o2, 0x1d0, %o2
                           
  Thread_queue_Context         queue_context;
                        

                                                                     
  _Objects_Allocator_lock();
                                         
  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
        

                                                                     
  if ( the_mq == NULL ) {
                                            
40006130:	84 92 20 00 	orcc  %o0, 0, %g2
                             
40006134:	02 80 00 11 	be  40006178 <mq_close+0x68>
                  <== NEVER TAKEN
40006138:	01 00 00 00 	nop 
                                          
  _CORE_message_queue_Acquire_critical(
                              
    &the_mq->Message_queue,
                                          
    &queue_context
                                                   
  );
                                                                 

                                                                     
  if ( the_mq->open_count == 0 ) {
                                   
4000613c:	c2 00 a0 50 	ld  [ %g2 + 0x50 ], %g1
                       
40006140:	80 a0 60 00 	cmp  %g1, 0
                                   
40006144:	02 80 00 0a 	be  4000616c <mq_close+0x5c>
                  <== NEVER TAKEN
40006148:	82 00 7f ff 	add  %g1, -1, %g1
                             
    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );

    _Objects_Allocator_unlock();
                                     
    rtems_set_errno_and_return_minus_one( EBADF );
                   
  }
                                                                  

                                                                     
  the_mq->open_count -= 1;
                                           
4000614c:	c2 20 a0 50 	st  %g1, [ %g2 + 0x50 ]
                       
  _POSIX_Message_queue_Delete( the_mq, &queue_context );
             
40006150:	92 07 bf dc 	add  %fp, -36, %o1
                            
40006154:	40 00 00 11 	call  40006198 <_POSIX_Message_queue_Delete>
  
40006158:	b0 10 20 00 	clr  %i0
                                      
  _RTEMS_Unlock_allocator();
                                         
4000615c:	40 00 02 39 	call  40006a40 <_RTEMS_Unlock_allocator>
      
40006160:	01 00 00 00 	nop 
                                          

                                                                     
  _Objects_Allocator_unlock();
                                       
  return 0;
                                                          
}
                                                                    
40006164:	81 c7 e0 08 	ret 
                                          
40006168:	81 e8 00 00 	restore 
                                      
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000616c:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006170:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006174:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006178:	40 00 02 32 	call  40006a40 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
4000617c:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBADF );
                   
40006180:	40 00 26 9c 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006184:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006188:	82 10 20 09 	mov  9, %g1	! 9 <_TLS_Alignment+0x8>
          <== NOT EXECUTED
4000618c:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006190:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006194:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006210 <mq_notify>:
                                                

                                                                     
int mq_notify(
                                                       
  mqd_t                  mqdes,
                                      
  const struct sigevent *notification
                                
)
                                                                    
{
                                                                    
40006210:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  return (POSIX_Message_queue_Control *) _Objects_Get(
               
40006214:	15 10 00 52 	sethi  %hi(0x40014800), %o2
                   
40006218:	92 07 bf dc 	add  %fp, -36, %o1
                            
4000621c:	94 12 a1 d0 	or  %o2, 0x1d0, %o2
                           
40006220:	40 00 0a 3b 	call  40008b0c <_Objects_Get>
                 
40006224:	90 10 00 18 	mov  %i0, %o0
                                 
  POSIX_Message_queue_Control *the_mq;
                               
  Thread_queue_Context         queue_context;
                        

                                                                     
  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
        

                                                                     
  if ( the_mq == NULL ) {
                                            
40006228:	80 a2 20 00 	cmp  %o0, 0
                                   
4000622c:	02 80 00 2f 	be  400062e8 <mq_notify+0xd8>
                 <== NEVER TAKEN
40006230:	01 00 00 00 	nop 
                                          
  _CORE_message_queue_Acquire_critical(
                              
    &the_mq->Message_queue,
                                          
    &queue_context
                                                   
  );
                                                                 

                                                                     
  if ( the_mq->open_count == 0 ) {
                                   
40006234:	c2 02 20 50 	ld  [ %o0 + 0x50 ], %g1
                       
40006238:	80 a0 60 00 	cmp  %g1, 0
                                   
4000623c:	02 80 00 28 	be  400062dc <mq_notify+0xcc>
                 <== NEVER TAKEN
40006240:	80 a6 60 00 	cmp  %i1, 0
                                   
    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );

    rtems_set_errno_and_return_minus_one( EBADF );
                   
  }
                                                                  

                                                                     
  if ( notification != NULL ) {
                                      
40006244:	22 80 00 18 	be,a   400062a4 <mq_notify+0x94>
              <== NEVER TAKEN
40006248:	c0 22 20 3c 	clr  [ %o0 + 0x3c ]
                           <== NOT EXECUTED
    if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {

4000624c:	c2 02 20 3c 	ld  [ %o0 + 0x3c ], %g1
                       
40006250:	80 a0 60 00 	cmp  %g1, 0
                                   
40006254:	12 80 00 19 	bne  400062b8 <mq_notify+0xa8>
                <== NEVER TAKEN
40006258:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );

      rtems_set_errno_and_return_minus_one( EBUSY );
                 
    }
                                                                

                                                                     
    the_mq->notification = *notification;
                            
4000625c:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
40006260:	c2 22 20 54 	st  %g1, [ %o0 + 0x54 ]
                       <== NOT EXECUTED
40006264:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1
                          <== NOT EXECUTED
40006268:	c2 22 20 58 	st  %g1, [ %o0 + 0x58 ]
                       <== NOT EXECUTED
4000626c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1
                          <== NOT EXECUTED
40006270:	c2 22 20 5c 	st  %g1, [ %o0 + 0x5c ]
                       <== NOT EXECUTED
40006274:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1
                        <== NOT EXECUTED
40006278:	c2 22 20 60 	st  %g1, [ %o0 + 0x60 ]
                       <== NOT EXECUTED
4000627c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1
                       <== NOT EXECUTED
40006280:	c2 22 20 64 	st  %g1, [ %o0 + 0x64 ]
                       <== NOT EXECUTED
40006284:	03 10 00 18 	sethi  %hi(0x40006000), %g1
                   <== NOT EXECUTED
40006288:	82 10 61 e8 	or  %g1, 0x1e8, %g1	! 400061e8 <_POSIX_Message_queue_Notify_handler>
<== NOT EXECUTED
4000628c:	c2 22 20 3c 	st  %g1, [ %o0 + 0x3c ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006290:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006294:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006298:	01 00 00 00 	nop 
                                          
    _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL );
  
  }
                                                                  

                                                                     
  _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );

  return 0;
                                                          
}
                                                                    
4000629c:	81 c7 e0 08 	ret 
                                          
400062a0:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400062a4:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400062a8:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400062ac:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
400062b0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400062b4:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400062b8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400062bc:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400062c0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( EBUSY );
                 
400062c4:	40 00 26 4b 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
400062c8:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
400062cc:	82 10 20 10 	mov  0x10, %g1
                                <== NOT EXECUTED
400062d0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400062d4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400062d8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400062dc:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400062e0:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400062e4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBADF );
                   
400062e8:	40 00 26 42 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
400062ec:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
400062f0:	82 10 20 09 	mov  9, %g1
                                   <== NOT EXECUTED
400062f4:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400062f8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400062fc:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006338 <mq_open>:
                                                  
  int         oflag,
                                                 
  ...
                                                                
  /* mode_t mode, */
                                                 
  /* struct mq_attr  attr */
                                         
)
                                                                    
{
                                                                    
40006338:	9d e3 bf 90 	save  %sp, -112, %sp
                          
        _POSIX_Get_by_name_error( error ),
                           
        MQ_OPEN_FAILED
                                               
      );
                                                             
    }
                                                                

                                                                     
    va_start( ap, oflag );
                                           
4000633c:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]
                       
  const char                *name,
                                   
  size_t                    *name_length_p,
                          
  Objects_Get_by_name_error *error
                                   
)
                                                                    
{
                                                                    
  return (POSIX_Message_queue_Control *) _Objects_Get_by_name(
       
40006340:	37 10 00 52 	sethi  %hi(0x40014800), %i3
                   
40006344:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]
                       
40006348:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]
                       
  _RTEMS_Lock_allocator();
                                           
4000634c:	40 00 01 b8 	call  40006a2c <_RTEMS_Lock_allocator>
        
40006350:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]
                       
40006354:	96 07 bf f8 	add  %fp, -8, %o3
                             
40006358:	94 07 bf f4 	add  %fp, -12, %o2
                            
4000635c:	92 10 00 18 	mov  %i0, %o1
                                 
40006360:	40 00 0a 50 	call  40008ca0 <_Objects_Get_by_name>
         
40006364:	90 16 e1 d0 	or  %i3, 0x1d0, %o0
                           
  if ( the_mq == NULL ) {
                                            
40006368:	80 a2 20 00 	cmp  %o0, 0
                                   
4000636c:	02 80 00 0e 	be  400063a4 <mq_open+0x6c>
                   
40006370:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1
                         

                                                                     
    /*
                                                               
     * Check for existence with creation.
                            
     */
                                                              

                                                                     
    if ( ( oflag & ( O_CREAT | O_EXCL ) ) == ( O_CREAT | O_EXCL ) ) {

40006374:	b2 0e 6a 00 	and  %i1, 0xa00, %i1
                          
40006378:	80 a6 6a 00 	cmp  %i1, 0xa00
                               
4000637c:	02 80 00 44 	be  4000648c <mq_open+0x154>
                  <== NEVER TAKEN
40006380:	01 00 00 00 	nop 
                                          
      _Objects_Allocator_unlock();
                                   
      rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED );
    
    }
                                                                

                                                                     
    the_mq->open_count += 1;
                                         
40006384:	c2 02 20 50 	ld  [ %o0 + 0x50 ], %g1
                       
40006388:	82 00 60 01 	inc  %g1
                                      
4000638c:	c2 22 20 50 	st  %g1, [ %o0 + 0x50 ]
                       
    status = the_mq->Object.id;
                                      
40006390:	f0 02 20 08 	ld  [ %o0 + 8 ], %i0
                          
  _RTEMS_Unlock_allocator();
                                         
40006394:	40 00 01 ab 	call  40006a40 <_RTEMS_Unlock_allocator>
      
40006398:	01 00 00 00 	nop 
                                          
  }
                                                                  

                                                                     
  _Objects_Allocator_unlock();
                                       
  return status;
                                                     
}
                                                                    
4000639c:	81 c7 e0 08 	ret 
                                          
400063a0:	81 e8 00 00 	restore 
                                      
    if ( error != OBJECTS_GET_BY_NAME_NO_OBJECT || ( oflag & O_CREAT ) == 0 ) {

400063a4:	80 a0 60 02 	cmp  %g1, 2
                                   
400063a8:	12 80 00 2e 	bne  40006460 <mq_open+0x128>
                 <== NEVER TAKEN
400063ac:	80 8e 62 00 	btst  0x200, %i1
                              
400063b0:	02 80 00 2c 	be  40006460 <mq_open+0x128>
                  <== NEVER TAKEN
400063b4:	82 07 a0 4c 	add  %fp, 0x4c, %g1
                           
    va_start( ap, oflag );
                                           
400063b8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         
    attr = va_arg( ap, const struct mq_attr * );
                     
400063bc:	f8 07 a0 50 	ld  [ %fp + 0x50 ], %i4
                       
    if ( attr == NULL ) {
                                            
400063c0:	80 a7 20 00 	cmp  %i4, 0
                                   
400063c4:	22 80 00 48 	be,a   400064e4 <mq_open+0x1ac>
               <== NEVER TAKEN
400063c8:	39 10 00 46 	sethi  %hi(0x40011800), %i4
                   <== NOT EXECUTED
  if ( attr->mq_maxmsg <= 0 ){
                                       
400063cc:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1	! 40011804 <IMFS_device_handlers+0x20>

400063d0:	80 a0 60 00 	cmp  %g1, 0
                                   
400063d4:	04 80 00 36 	ble  400064ac <mq_open+0x174>
                 <== NEVER TAKEN
400063d8:	f4 07 bf f4 	ld  [ %fp + -12 ], %i2
                        
  if ( attr->mq_msgsize <= 0 ){
                                      
400063dc:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1
                          
400063e0:	80 a0 60 00 	cmp  %g1, 0
                                   
400063e4:	04 80 00 32 	ble  400064ac <mq_open+0x174>
                 <== NEVER TAKEN
400063e8:	01 00 00 00 	nop 
                                          
  return (POSIX_Message_queue_Control *)
                             
400063ec:	40 00 08 9c 	call  4000865c <_Objects_Allocate_unprotected>

400063f0:	90 16 e1 d0 	or  %i3, 0x1d0, %o0
                           
  if ( !the_mq ) {
                                                   
400063f4:	ba 92 20 00 	orcc  %o0, 0, %i5
                             
400063f8:	02 80 00 3e 	be  400064f0 <mq_open+0x1b8>
                  <== NEVER TAKEN
400063fc:	92 10 00 1a 	mov  %i2, %o1
                                 
  name = _Workspace_String_duplicate( name_arg, name_len );
          
40006400:	40 00 17 fa 	call  4000c3e8 <_Workspace_String_duplicate>
  
40006404:	90 10 00 18 	mov  %i0, %o0
                                 
  if ( !name ) {
                                                     
40006408:	b4 92 20 00 	orcc  %o0, 0, %i2
                             
4000640c:	02 80 00 3e 	be  40006504 <mq_open+0x1cc>
                  <== NEVER TAKEN
40006410:	82 10 20 01 	mov  1, %g1
                                   
  the_mq->open_count = 1;
                                            
40006414:	c2 27 60 50 	st  %g1, [ %i5 + 0x50 ]
                       
    !_CORE_message_queue_Initialize(
                                 
40006418:	92 10 20 00 	clr  %o1
                                      
  the_mq->linked = true;
                                             
4000641c:	c2 2f 60 4c 	stb  %g1, [ %i5 + 0x4c ]
                      
    !_CORE_message_queue_Initialize(
                                 
40006420:	90 07 60 10 	add  %i5, 0x10, %o0
                           
  the_mq->oflag = oflag;
                                             
40006424:	f2 27 60 68 	st  %i1, [ %i5 + 0x68 ]
                       
    !_CORE_message_queue_Initialize(
                                 
40006428:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3
                          
4000642c:	40 00 01 c3 	call  40006b38 <_CORE_message_queue_Initialize>

40006430:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2
                          
  if (
                                                               
40006434:	80 a2 20 00 	cmp  %o0, 0
                                   
40006438:	02 80 00 22 	be  400064c0 <mq_open+0x188>
                  <== NEVER TAKEN
4000643c:	92 10 00 1d 	mov  %i5, %o1
                                 
  information->local_table[ index ] = the_object;
                    
40006440:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1
                      
    the_object->name.name_p = name;
                                  
40006444:	f4 27 60 0c 	st  %i2, [ %i5 + 0xc ]
                        
  information->local_table[ index ] = the_object;
                    
40006448:	b6 16 e1 d0 	or  %i3, 0x1d0, %i3
                           
4000644c:	c4 06 e0 1c 	ld  [ %i3 + 0x1c ], %g2
                       
40006450:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0
                          
40006454:	83 28 60 02 	sll  %g1, 2, %g1
                              
40006458:	10 bf ff cf 	b  40006394 <mq_open+0x5c>
                    
4000645c:	fa 20 80 01 	st  %i5, [ %g2 + %g1 ]
                        
  _RTEMS_Unlock_allocator();
                                         
40006460:	40 00 01 78 	call  40006a40 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006464:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
      rtems_set_errno_and_return_value(
                              
40006468:	40 00 25 e2 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000646c:	fa 07 bf f8 	ld  [ %fp + -8 ], %i5
                         <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error(
                   
  Objects_Get_by_name_error error
                                    
)
                                                                    
{
                                                                    
  _Assert( (size_t) error < RTEMS_ARRAY_SIZE( _POSIX_Get_by_name_error_table ) );

  return _POSIX_Get_by_name_error_table[ error ];
                    
40006470:	bb 2f 60 02 	sll  %i5, 2, %i5
                              <== NOT EXECUTED
40006474:	03 10 00 46 	sethi  %hi(0x40011800), %g1
                   <== NOT EXECUTED
40006478:	82 10 62 78 	or  %g1, 0x278, %g1	! 40011a78 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
4000647c:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1
                        <== NOT EXECUTED
40006480:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006484:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006488:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
4000648c:	40 00 01 6d 	call  40006a40 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006490:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
      rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED );
    
40006494:	40 00 25 d7 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006498:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000649c:	82 10 20 11 	mov  0x11, %g1	! 11 <_TLS_Alignment+0x10>
     <== NOT EXECUTED
400064a0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400064a4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400064a8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_value( EINVAL, MQ_OPEN_FAILED );
      
400064ac:	40 00 25 d1 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
400064b0:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400064b4:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
400064b8:	10 bf ff b7 	b  40006394 <mq_open+0x5c>
                    <== NOT EXECUTED
400064bc:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
  _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );

400064c0:	40 00 09 67 	call  40008a5c <_Objects_Free>
                <== NOT EXECUTED
400064c4:	90 16 e1 d0 	or  %i3, 0x1d0, %o0
                           <== NOT EXECUTED
    _Workspace_Free( name );
                                         
400064c8:	40 00 17 b3 	call  4000c394 <_Workspace_Free>
              <== NOT EXECUTED
400064cc:	90 10 00 1a 	mov  %i2, %o0
                                 <== NOT EXECUTED
    rtems_set_errno_and_return_value( ENOSPC, MQ_OPEN_FAILED );
      
400064d0:	40 00 25 c8 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
400064d4:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400064d8:	82 10 20 1c 	mov  0x1c, %g1
                                <== NOT EXECUTED
400064dc:	10 bf ff ae 	b  40006394 <mq_open+0x5c>
                    <== NOT EXECUTED
400064e0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
    status = _POSIX_Message_queue_Create( name, name_len, oflag, attr );

400064e4:	f4 07 bf f4 	ld  [ %fp + -12 ], %i2
                        <== NOT EXECUTED
      attr = &_POSIX_Message_queue_Default_attributes;
               
400064e8:	10 bf ff c1 	b  400063ec <mq_open+0xb4>
                    <== NOT EXECUTED
400064ec:	b8 17 22 68 	or  %i4, 0x268, %i4
                           <== NOT EXECUTED
    rtems_set_errno_and_return_value( ENFILE, MQ_OPEN_FAILED );
      
400064f0:	40 00 25 c0 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
400064f4:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400064f8:	82 10 20 17 	mov  0x17, %g1
                                <== NOT EXECUTED
400064fc:	10 bf ff a6 	b  40006394 <mq_open+0x5c>
                    <== NOT EXECUTED
40006500:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006504:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED
40006508:	40 00 09 55 	call  40008a5c <_Objects_Free>
                <== NOT EXECUTED
4000650c:	90 16 e1 d0 	or  %i3, 0x1d0, %o0
                           <== NOT EXECUTED
    rtems_set_errno_and_return_value( ENOMEM, MQ_OPEN_FAILED );
      
40006510:	40 00 25 b8 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
40006514:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40006518:	82 10 20 0c 	mov  0xc, %g1
                                 <== NOT EXECUTED
4000651c:	10 bf ff 9e 	b  40006394 <mq_open+0x5c>
                    <== NOT EXECUTED
40006520:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED

                                                                     
===============================================================================
40006790 <mq_unlink>:
                                                
 */
                                                                  

                                                                     
int mq_unlink(
                                                       
  const char *name
                                                   
)
                                                                    
{
                                                                    
40006790:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  _RTEMS_Lock_allocator();
                                           
40006794:	40 00 00 a6 	call  40006a2c <_RTEMS_Lock_allocator>
        
40006798:	39 10 00 52 	sethi  %hi(0x40014800), %i4
                   
  return (POSIX_Message_queue_Control *) _Objects_Get_by_name(
       
4000679c:	96 07 bf d8 	add  %fp, -40, %o3
                            
400067a0:	94 10 20 00 	clr  %o2
                                      
400067a4:	92 10 00 18 	mov  %i0, %o1
                                 
400067a8:	40 00 09 3e 	call  40008ca0 <_Objects_Get_by_name>
         
400067ac:	90 17 21 d0 	or  %i4, 0x1d0, %o0
                           
  Thread_queue_Context         queue_context;
                        

                                                                     
  _Objects_Allocator_lock();
                                         

                                                                     
  the_mq = _POSIX_Message_queue_Get_by_name( name, NULL, &error );
   
  if ( the_mq == NULL ) {
                                            
400067b0:	ba 92 20 00 	orcc  %o0, 0, %i5
                             
400067b4:	02 80 00 0f 	be  400067f0 <mq_unlink+0x60>
                 <== NEVER TAKEN
400067b8:	92 10 00 1d 	mov  %i5, %o1
                                 
  _Objects_Namespace_remove( 
                                        
400067bc:	40 00 09 2f 	call  40008c78 <_Objects_Namespace_remove>
    
400067c0:	90 17 21 d0 	or  %i4, 0x1d0, %o0
                           
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

400067c4:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  Thread_queue_Control *the_thread_queue,
                            
  Thread_queue_Context *queue_context
                                
)
                                                                    
{
                                                                    
  (void) the_thread_queue;
                                           
  _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );

400067c8:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        

                                                                     
  _POSIX_Message_queue_Namespace_remove( the_mq );
                   

                                                                     
  _CORE_message_queue_Acquire( &the_mq->Message_queue, &queue_context );


                                                                     
  the_mq->linked = false;
                                            
400067cc:	c0 2f 60 4c 	clrb  [ %i5 + 0x4c ]
                          
  _POSIX_Message_queue_Delete( the_mq, &queue_context );
             
400067d0:	92 07 bf dc 	add  %fp, -36, %o1
                            
400067d4:	90 10 00 1d 	mov  %i5, %o0
                                 
400067d8:	7f ff fe 70 	call  40006198 <_POSIX_Message_queue_Delete>
  
400067dc:	b0 10 20 00 	clr  %i0
                                      
  _RTEMS_Unlock_allocator();
                                         
400067e0:	40 00 00 98 	call  40006a40 <_RTEMS_Unlock_allocator>
      
400067e4:	01 00 00 00 	nop 
                                          

                                                                     
  _Objects_Allocator_unlock();
                                       
  return 0;
                                                          
}
                                                                    
400067e8:	81 c7 e0 08 	ret 
                                          
400067ec:	81 e8 00 00 	restore 
                                      
400067f0:	40 00 00 94 	call  40006a40 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
400067f4:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) );

400067f8:	40 00 24 fe 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
400067fc:	fa 07 bf d8 	ld  [ %fp + -40 ], %i5
                        <== NOT EXECUTED
  return _POSIX_Get_by_name_error_table[ error ];
                    
40006800:	bb 2f 60 02 	sll  %i5, 2, %i5
                              <== NOT EXECUTED
40006804:	03 10 00 46 	sethi  %hi(0x40011800), %g1
                   <== NOT EXECUTED
40006808:	82 10 62 78 	or  %g1, 0x278, %g1	! 40011a78 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
4000680c:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1
                        <== NOT EXECUTED
40006810:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006814:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006818:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40005e78 <nanosleep>:
                                                
{
                                                                    
40005e78:	9d e3 bf a0 	save  %sp, -96, %sp
                           
40005e7c:	92 10 20 00 	clr  %o1
                                      
40005e80:	94 10 00 18 	mov  %i0, %o2
                                 
40005e84:	96 10 00 19 	mov  %i1, %o3
                                 
40005e88:	7f ff ff 8e 	call  40005cc0 <clock_nanosleep.part.6>
       
40005e8c:	90 10 20 01 	mov  1, %o0
                                   
  if ( eno != 0 ) {
                                                  
40005e90:	b0 92 20 00 	orcc  %o0, 0, %i0
                             
40005e94:	12 80 00 04 	bne  40005ea4 <nanosleep+0x2c>
                <== NEVER TAKEN
40005e98:	01 00 00 00 	nop 
                                          
}
                                                                    
40005e9c:	81 c7 e0 08 	ret 
                                          
40005ea0:	81 e8 00 00 	restore 
                                      
    rtems_set_errno_and_return_minus_one( eno );
                     
40005ea4:	40 00 21 2b 	call  4000e350 <__errno>
                      <== NOT EXECUTED
40005ea8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40005eac:	f0 22 00 00 	st  %i0, [ %o0 ]
                              <== NOT EXECUTED
}
                                                                    
40005eb0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005eb4:	91 e8 3f ff 	restore  %g0, -1, %o0
                         <== NOT EXECUTED

                                                                     
===============================================================================
4000c05c <pthread_attr_init>:
                                        
 * 16.1.1 Thread Creation Attributes, P1003.1c/Draft 10, p, 140
      
 */
                                                                  
int pthread_attr_init(
                                               
  pthread_attr_t  *attr
                                              
)
                                                                    
{
                                                                    
4000c05c:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  if ( !attr )
                                                       
4000c060:	82 96 20 00 	orcc  %i0, 0, %g1
                             
4000c064:	02 80 00 0b 	be  4000c090 <pthread_attr_init+0x34>
         <== NEVER TAKEN
4000c068:	94 10 20 60 	mov  0x60, %o2
                                
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Copy_attributes(
            
  pthread_attr_t        *dst_attr,
                                   
  const pthread_attr_t  *src_attr
                                    
)
                                                                    
{
                                                                    
  *dst_attr = *src_attr;
                                             
4000c06c:	90 10 00 01 	mov  %g1, %o0
                                 
4000c070:	13 10 00 3e 	sethi  %hi(0x4000f800), %o1
                   
    return EINVAL;
                                                   

                                                                     
  _POSIX_Threads_Initialize_attributes( attr );
                      

                                                                     
  return 0;
                                                          
4000c074:	b0 10 20 00 	clr  %i0
                                      
4000c078:	40 00 07 64 	call  4000de08 <memcpy>
                       
4000c07c:	92 12 63 40 	or  %o1, 0x340, %o1
                           
  _Assert(
                                                           
    dst_attr->affinitysetsize == sizeof(dst_attr->affinitysetpreallocated)

  );
                                                                 
  dst_attr->affinityset = &dst_attr->affinitysetpreallocated;
        
4000c080:	84 02 20 5c 	add  %o0, 0x5c, %g2
                           
4000c084:	c4 22 20 58 	st  %g2, [ %o0 + 0x58 ]
                       
4000c088:	81 c7 e0 08 	ret 
                                          
4000c08c:	81 e8 00 00 	restore 
                                      
}
                                                                    
4000c090:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c094:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
4000c098 <pthread_attr_setinheritsched>:
                             
int pthread_attr_setinheritsched(
                                    
  pthread_attr_t  *attr,
                                             
  int              inheritsched
                                      
)
                                                                    
{
                                                                    
  if ( !attr || !attr->is_initialized )
                              
4000c098:	82 92 20 00 	orcc  %o0, 0, %g1
                             
4000c09c:	02 80 00 0c 	be  4000c0cc <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000c0a0:	90 10 20 16 	mov  0x16, %o0
                                
4000c0a4:	c4 00 40 00 	ld  [ %g1 ], %g2
                              
4000c0a8:	80 a0 a0 00 	cmp  %g2, 0
                                   
4000c0ac:	02 80 00 08 	be  4000c0cc <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000c0b0:	84 02 7f ff 	add  %o1, -1, %g2
                             
    return EINVAL;
                                                   

                                                                     
  switch ( inheritsched ) {
                                          
4000c0b4:	80 a0 a0 01 	cmp  %g2, 1
                                   
4000c0b8:	18 80 00 05 	bgu  4000c0cc <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000c0bc:	90 10 20 86 	mov  0x86, %o0
                                
    case PTHREAD_INHERIT_SCHED:
                                      
    case PTHREAD_EXPLICIT_SCHED:
                                     
      attr->inheritsched = inheritsched;
                             
4000c0c0:	d2 20 60 10 	st  %o1, [ %g1 + 0x10 ]
                       
      return 0;
                                                      
4000c0c4:	81 c3 e0 08 	retl 
                                         
4000c0c8:	90 10 20 00 	clr  %o0
                                      

                                                                     
    default:
                                                         
      return ENOTSUP;
                                                
  }
                                                                  
}
                                                                    
4000c0cc:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
4000c0d0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40006a10 <pthread_attr_setschedparam>:
                               
int pthread_attr_setschedparam(
                                      
  pthread_attr_t           *attr,
                                    
  const struct sched_param *param
                                    
)
                                                                    
{
                                                                    
  if ( !attr || !attr->is_initialized || !param )
                    
40006a10:	82 92 20 00 	orcc  %o0, 0, %g1
                             
40006a14:	02 80 00 16 	be  40006a6c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40006a18:	01 00 00 00 	nop 
                                          
40006a1c:	c4 00 40 00 	ld  [ %g1 ], %g2
                              
40006a20:	80 a0 a0 00 	cmp  %g2, 0
                                   
40006a24:	02 80 00 12 	be  40006a6c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40006a28:	80 a2 60 00 	cmp  %o1, 0
                                   
40006a2c:	02 80 00 10 	be  40006a6c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40006a30:	01 00 00 00 	nop 
                                          
    return EINVAL;
                                                   

                                                                     
  attr->schedparam = *param;
                                         
40006a34:	c4 1a 40 00 	ldd  [ %o1 ], %g2
                             
40006a38:	c4 38 60 18 	std  %g2, [ %g1 + 0x18 ]
                      
  return 0;
                                                          
40006a3c:	90 10 20 00 	clr  %o0
                                      
  attr->schedparam = *param;
                                         
40006a40:	c4 1a 60 08 	ldd  [ %o1 + 8 ], %g2
                         
40006a44:	c4 38 60 20 	std  %g2, [ %g1 + 0x20 ]
                      
40006a48:	c4 1a 60 10 	ldd  [ %o1 + 0x10 ], %g2
                      
40006a4c:	c4 38 60 28 	std  %g2, [ %g1 + 0x28 ]
                      
40006a50:	c4 1a 60 18 	ldd  [ %o1 + 0x18 ], %g2
                      
40006a54:	c4 38 60 30 	std  %g2, [ %g1 + 0x30 ]
                      
40006a58:	c4 1a 60 20 	ldd  [ %o1 + 0x20 ], %g2
                      
40006a5c:	c4 38 60 38 	std  %g2, [ %g1 + 0x38 ]
                      
40006a60:	c4 1a 60 28 	ldd  [ %o1 + 0x28 ], %g2
                      
  return 0;
                                                          
40006a64:	81 c3 e0 08 	retl 
                                         
40006a68:	c4 38 60 40 	std  %g2, [ %g1 + 0x40 ]
                      
}
                                                                    
40006a6c:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40006a70:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED

                                                                     
===============================================================================
40006a74 <pthread_attr_setschedpolicy>:
                              
int pthread_attr_setschedpolicy(
                                     
  pthread_attr_t  *attr,
                                             
  int              policy
                                            
)
                                                                    
{
                                                                    
  if ( !attr || !attr->is_initialized )
                              
40006a74:	82 92 20 00 	orcc  %o0, 0, %g1
                             
40006a78:	02 80 00 10 	be  40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006a7c:	90 10 20 16 	mov  0x16, %o0
                                
40006a80:	c4 00 40 00 	ld  [ %g1 ], %g2
                              
40006a84:	80 a0 a0 00 	cmp  %g2, 0
                                   
40006a88:	02 80 00 0c 	be  40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006a8c:	80 a2 60 04 	cmp  %o1, 4
                                   
    case SCHED_SPORADIC:
                                             
      attr->schedpolicy = policy;
                                    
      return 0;
                                                      

                                                                     
    default:
                                                         
      return ENOTSUP;
                                                
40006a90:	18 80 00 0a 	bgu  40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006a94:	90 10 20 86 	mov  0x86, %o0
                                
40006a98:	84 10 20 01 	mov  1, %g2
                                   
40006a9c:	85 28 80 09 	sll  %g2, %o1, %g2
                            
40006aa0:	80 88 a0 17 	btst  0x17, %g2
                               
40006aa4:	02 80 00 05 	be  40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006aa8:	01 00 00 00 	nop 
                                          
      attr->schedpolicy = policy;
                                    
40006aac:	d2 20 60 14 	st  %o1, [ %g1 + 0x14 ]
                       
      return 0;
                                                      
40006ab0:	81 c3 e0 08 	retl 
                                         
40006ab4:	90 10 20 00 	clr  %o0
                                      
  }
                                                                  
}
                                                                    
40006ab8:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40006abc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000c0d4 <pthread_attr_setstacksize>:
                                
int pthread_attr_setstacksize(
                                       
  pthread_attr_t  *attr,
                                             
  size_t           stacksize
                                         
)
                                                                    
{
                                                                    
  if ( !attr || !attr->is_initialized )
                              
4000c0d4:	82 92 20 00 	orcc  %o0, 0, %g1
                             
4000c0d8:	02 80 00 09 	be  4000c0fc <pthread_attr_setstacksize+0x28>
 <== NEVER TAKEN
4000c0dc:	90 10 20 16 	mov  0x16, %o0
                                
4000c0e0:	c4 00 40 00 	ld  [ %g1 ], %g2
                              
4000c0e4:	80 a0 a0 00 	cmp  %g2, 0
                                   
4000c0e8:	02 80 00 05 	be  4000c0fc <pthread_attr_setstacksize+0x28>
 <== NEVER TAKEN
4000c0ec:	01 00 00 00 	nop 
                                          
    return EINVAL;
                                                   

                                                                     
  attr->stacksize = stacksize;
                                       
4000c0f0:	d2 20 60 08 	st  %o1, [ %g1 + 8 ]
                          
  return 0;
                                                          
4000c0f4:	81 c3 e0 08 	retl 
                                         
4000c0f8:	90 10 20 00 	clr  %o0
                                      
}
                                                                    
4000c0fc:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
4000c100:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40005d58 <pthread_barrier_destroy>:
                                  
int pthread_barrier_destroy( pthread_barrier_t *_barrier )
           
{
                                                                    
  POSIX_Barrier_Control *barrier;
                                    
  Thread_queue_Context   queue_context;
                              

                                                                     
  POSIX_BARRIER_VALIDATE_OBJECT( _barrier );
                         
40005d58:	84 92 20 00 	orcc  %o0, 0, %g2
                             
40005d5c:	02 80 00 12 	be  40005da4 <pthread_barrier_destroy+0x4c>
   <== NEVER TAKEN
40005d60:	03 07 3c 0d 	sethi  %hi(0x1cf03400), %g1
                   
40005d64:	c6 00 80 00 	ld  [ %g2 ], %g3
                              
40005d68:	82 10 63 73 	or  %g1, 0x373, %g1
                           
40005d6c:	82 18 80 01 	xor  %g2, %g1, %g1
                            
40005d70:	80 a0 40 03 	cmp  %g1, %g3
                                 
40005d74:	12 80 00 0d 	bne  40005da8 <pthread_barrier_destroy+0x50>
  <== NEVER TAKEN
40005d78:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005d7c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
  barrier = _POSIX_Barrier_Get( _barrier );
                          

                                                                     
  _POSIX_Barrier_Queue_acquire( barrier, &queue_context );
           

                                                                     
  if ( barrier->waiting_threads != 0 ) {
                             
40005d80:	c6 00 a0 1c 	ld  [ %g2 + 0x1c ], %g3
                       
40005d84:	80 a0 e0 00 	cmp  %g3, 0
                                   
40005d88:	12 80 00 0a 	bne  40005db0 <pthread_barrier_destroy+0x58>
  <== NEVER TAKEN
40005d8c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    _POSIX_Barrier_Queue_release( barrier, &queue_context );
         
    return EBUSY;
                                                    
  }
                                                                  

                                                                     
  barrier->flags = 0;
                                                
40005d90:	c0 20 80 00 	clr  [ %g2 ]
                                  <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005d94:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005d98:	01 00 00 00 	nop 
                                          
  _POSIX_Barrier_Queue_release( barrier, &queue_context );
           
  return 0;
                                                          
40005d9c:	81 c3 e0 08 	retl 
                                         
40005da0:	90 10 20 00 	clr  %o0	! 0 <PROM_START>
                     
  POSIX_BARRIER_VALIDATE_OBJECT( _barrier );
                         
40005da4:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED
}
                                                                    
40005da8:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005dac:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40005db0:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005db4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    return EBUSY;
                                                    
40005db8:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005dbc:	90 10 20 10 	mov  0x10, %o0	! 10 <_TLS_Alignment+0xf>
      <== NOT EXECUTED

                                                                     
===============================================================================
40005dc0 <pthread_barrier_init>:
                                     
   */
                                                                
  if ( barrier == NULL ) {
                                           
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( count == 0 ) {
                                                
40005dc0:	82 92 20 00 	orcc  %o0, 0, %g1
                             
40005dc4:	02 80 00 19 	be  40005e28 <pthread_barrier_init+0x68>
      <== NEVER TAKEN
40005dc8:	80 a2 a0 00 	cmp  %o2, 0
                                   
40005dcc:	02 80 00 17 	be  40005e28 <pthread_barrier_init+0x68>
      <== NEVER TAKEN
40005dd0:	80 a2 60 00 	cmp  %o1, 0
                                   
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( attr != NULL ) {
                                              
40005dd4:	22 80 00 0b 	be,a   40005e00 <pthread_barrier_init+0x40>
   
40005dd8:	d4 20 60 18 	st  %o2, [ %g1 + 0x18 ]
                       
    /*
                                                               
     * Now start error checking the attributes that we are going to use

     */
                                                              
    if ( !attr->is_initialized )
                                     
40005ddc:	c4 02 40 00 	ld  [ %o1 ], %g2
                              
40005de0:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005de4:	02 80 00 12 	be  40005e2c <pthread_barrier_init+0x6c>
      <== NEVER TAKEN
40005de8:	90 10 20 16 	mov  0x16, %o0
                                
      return EINVAL;
                                                 

                                                                     
    if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
        
40005dec:	c4 02 60 04 	ld  [ %o1 + 4 ], %g2
                          
40005df0:	80 a0 a0 01 	cmp  %g2, 1
                                   
40005df4:	18 80 00 0e 	bgu  40005e2c <pthread_barrier_init+0x6c>
     <== NEVER TAKEN
40005df8:	01 00 00 00 	nop 
                                          
      return EINVAL;
                                                 
    }
                                                                
  }
                                                                  

                                                                     
  barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
        
  barrier->count = count;
                                            
40005dfc:	d4 20 60 18 	st  %o2, [ %g1 + 0x18 ]
                       
  barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
        
40005e00:	05 07 3c 0d 	sethi  %hi(0x1cf03400), %g2
                   
  barrier->waiting_threads = 0;
                                      
40005e04:	c0 20 60 1c 	clr  [ %g1 + 0x1c ]
                           
  barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
        
40005e08:	84 10 a3 73 	or  %g2, 0x373, %g2
                           
)
                                                                    
{
                                                                    
#if defined(RTEMS_SMP)
                                               
  _SMP_ticket_lock_Initialize( &queue->Lock );
                       
#endif
                                                               
  queue->heads = NULL;
                                               
40005e0c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]
                            
40005e10:	84 18 40 02 	xor  %g1, %g2, %g2
                            
  _Thread_queue_Queue_initialize( &barrier->Queue.Queue, NULL );
     
  return 0;
                                                          
40005e14:	90 10 20 00 	clr  %o0
                                      
  barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
        
40005e18:	c4 20 40 00 	st  %g2, [ %g1 ]
                              
  queue->owner = NULL;
                                               
40005e1c:	c0 20 60 10 	clr  [ %g1 + 0x10 ]
                           
  return 0;
                                                          
40005e20:	81 c3 e0 08 	retl 
                                         
40005e24:	c0 20 60 14 	clr  [ %g1 + 0x14 ]
                           
    return EINVAL;
                                                   
40005e28:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED
}
                                                                    
40005e2c:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005e30:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40005ea0 <pthread_barrier_wait>:
                                     

                                                                     
#include <rtems/posix/barrierimpl.h>
                                 
#include <rtems/posix/posixapi.h>
                                    

                                                                     
int pthread_barrier_wait( pthread_barrier_t *_barrier )
              
{
                                                                    
40005ea0:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_Barrier_Control *barrier;
                                    
  Thread_queue_Context   queue_context;
                              
  Thread_Control        *executing;
                                  
  unsigned int           waiting_threads;
                            

                                                                     
  POSIX_BARRIER_VALIDATE_OBJECT( _barrier );
                         
40005ea4:	84 96 20 00 	orcc  %i0, 0, %g2
                             
40005ea8:	02 80 00 1e 	be  40005f20 <pthread_barrier_wait+0x80>
      <== NEVER TAKEN
40005eac:	03 07 3c 0d 	sethi  %hi(0x1cf03400), %g1
                   
40005eb0:	c6 00 80 00 	ld  [ %g2 ], %g3
                              
40005eb4:	82 10 63 73 	or  %g1, 0x373, %g1
                           
40005eb8:	82 18 80 01 	xor  %g2, %g1, %g1
                            
40005ebc:	80 a0 40 03 	cmp  %g1, %g3
                                 
40005ec0:	12 80 00 16 	bne  40005f18 <pthread_barrier_wait+0x78>
     <== NEVER TAKEN
40005ec4:	b0 10 20 16 	mov  0x16, %i0
                                <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005ec8:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
)
                                                                    
{
                                                                    
#if defined( RTEMS_SMP )
                                             
  context->Lock_context.isr_level = level;
                           
#else
                                                                
  context->isr_level = level;
                                        
40005ecc:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        
40005ed0:	90 00 a0 0c 	add  %g2, 0xc, %o0
                            

                                                                     
  barrier = _POSIX_Barrier_Get( _barrier );
                          

                                                                     
  executing = _POSIX_Barrier_Queue_acquire( barrier, &queue_context );

  waiting_threads = barrier->waiting_threads;
                        
40005ed4:	c2 00 a0 1c 	ld  [ %g2 + 0x1c ], %g1
                       
  ++waiting_threads;
                                                 

                                                                     
  if ( waiting_threads == barrier->count ) {
                         
40005ed8:	c6 00 a0 18 	ld  [ %g2 + 0x18 ], %g3
                       
  ++waiting_threads;
                                                 
40005edc:	82 00 60 01 	inc  %g1
                                      
  if ( waiting_threads == barrier->count ) {
                         
40005ee0:	80 a0 c0 01 	cmp  %g3, %g1
                                 
40005ee4:	02 80 00 11 	be  40005f28 <pthread_barrier_wait+0x88>
      
40005ee8:	d4 01 a0 20 	ld  [ %g6 + 0x20 ], %o2
                       
      _Thread_queue_Flush_default_filter,
                            
      &queue_context
                                                 
    );
                                                               
    return PTHREAD_BARRIER_SERIAL_THREAD;
                            
  } else {
                                                           
    barrier->waiting_threads = waiting_threads;
                      
40005eec:	c2 20 a0 1c 	st  %g1, [ %g2 + 0x1c ]
                       
  queue_context->thread_state = thread_state;
                        
40005ef0:	82 10 28 00 	mov  0x800, %g1
                               
40005ef4:	c2 27 bf e0 	st  %g1, [ %fp + -32 ]
                        
  queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;

40005ef8:	03 10 00 28 	sethi  %hi(0x4000a000), %g1
                   
40005efc:	82 10 63 5c 	or  %g1, 0x35c, %g1	! 4000a35c <_Thread_queue_Enqueue_do_nothing_extra>

    _Thread_queue_Context_set_thread_state(
                          
      &queue_context,
                                                
      STATES_WAITING_FOR_BARRIER
                                     
    );
                                                               
    _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );

    _Thread_queue_Enqueue(
                                           
40005f00:	96 07 bf dc 	add  %fp, -36, %o3
                            
40005f04:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        
40005f08:	13 10 00 3e 	sethi  %hi(0x4000f800), %o1
                   
      &barrier->Queue.Queue,
                                         
      POSIX_BARRIER_TQ_OPERATIONS,
                                   
      executing,
                                                     
      &queue_context
                                                 
    );
                                                               
    return 0;
                                                        
40005f0c:	b0 10 20 00 	clr  %i0
                                      
    _Thread_queue_Enqueue(
                                           
40005f10:	40 00 11 19 	call  4000a374 <_Thread_queue_Enqueue>
        
40005f14:	92 12 62 64 	or  %o1, 0x264, %o1
                           
    return 0;
                                                        
40005f18:	81 c7 e0 08 	ret 
                                          
40005f1c:	81 e8 00 00 	restore 
                                      
  }
                                                                  
}
                                                                    
40005f20:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005f24:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
    barrier->waiting_threads = 0;
                                    
40005f28:	c0 20 a0 1c 	clr  [ %g2 + 0x1c ]
                           
    _Thread_queue_Flush_critical(
                                    
40005f2c:	96 07 bf dc 	add  %fp, -36, %o3
                            
40005f30:	15 10 00 29 	sethi  %hi(0x4000a400), %o2
                   
40005f34:	13 10 00 3e 	sethi  %hi(0x4000f800), %o1
                   
40005f38:	94 12 a3 10 	or  %o2, 0x310, %o2
                           
40005f3c:	92 12 62 64 	or  %o1, 0x264, %o1
                           
40005f40:	40 00 11 f6 	call  4000a718 <_Thread_queue_Flush_critical>
 
40005f44:	b0 10 3f ff 	mov  -1, %i0
                                  
    return PTHREAD_BARRIER_SERIAL_THREAD;
                            
40005f48:	81 c7 e0 08 	ret 
                                          
40005f4c:	81 e8 00 00 	restore 
                                      

                                                                     
===============================================================================
40005b18 <pthread_barrierattr_init>:
                                 

                                                                     
int pthread_barrierattr_init(
                                        
  pthread_barrierattr_t *attr
                                        
)
                                                                    
{
                                                                    
  if ( !attr )
                                                       
40005b18:	82 92 20 00 	orcc  %o0, 0, %g1
                             
40005b1c:	02 80 00 06 	be  40005b34 <pthread_barrierattr_init+0x1c>
  <== NEVER TAKEN
40005b20:	84 10 20 01 	mov  1, %g2
                                   
    return EINVAL;
                                                   

                                                                     
  attr->is_initialized = true;
                                       
  attr->process_shared = PTHREAD_PROCESS_PRIVATE;
                    
40005b24:	c0 20 60 04 	clr  [ %g1 + 4 ]
                              
  return 0;
                                                          
40005b28:	90 10 20 00 	clr  %o0
                                      
40005b2c:	81 c3 e0 08 	retl 
                                         
40005b30:	c4 20 40 00 	st  %g2, [ %g1 ]
                              
}
                                                                    
40005b34:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005b38:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED

                                                                     
===============================================================================
40005b50 <pthread_cond_destroy>:
                                     
/**
                                                                  
 *  11.4.2 Initializing and Destroying a Condition Variable,
         
 *         P1003.1c/Draft 10, p. 87
                                  
 */
                                                                  
int pthread_cond_destroy( pthread_cond_t *cond )
                     
{
                                                                    
40005b50:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_Condition_variables_Control *the_cond;
                       
  unsigned long                      flags;
                          
  Thread_queue_Context               queue_context;
                  

                                                                     
  the_cond = _POSIX_Condition_variables_Get( cond );
                 
  POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
      
40005b54:	80 a6 20 00 	cmp  %i0, 0
                                   
40005b58:	02 80 00 1e 	be  40005bd0 <pthread_cond_destroy+0x80>
      <== NEVER TAKEN
40005b5c:	05 06 37 ec 	sethi  %hi(0x18dfb000), %g2
                   
40005b60:	c2 06 00 00 	ld  [ %i0 ], %g1
                              
40005b64:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40005b68:	84 10 a1 fe 	or  %g2, 0x1fe, %g2
                           
40005b6c:	82 18 40 02 	xor  %g1, %g2, %g1
                            
40005b70:	80 88 7f fe 	btst  -2, %g1
                                 
40005b74:	12 80 00 12 	bne  40005bbc <pthread_cond_destroy+0x6c>
     <== NEVER TAKEN
40005b78:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005b7c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  _POSIX_Condition_variables_Acquire( the_cond, &queue_context );
    

                                                                     
  if ( !_Thread_queue_Is_empty( &the_cond->Queue.Queue ) ) {
         
40005b80:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2
                        
40005b84:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005b88:	02 80 00 06 	be  40005ba0 <pthread_cond_destroy+0x50>
      <== ALWAYS TAKEN
40005b8c:	01 00 00 00 	nop 
                                          
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005b90:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005b94:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    _POSIX_Condition_variables_Release( the_cond, &queue_context );
  
    return EBUSY;
                                                    
40005b98:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005b9c:	91 e8 20 10 	restore  %g0, 0x10, %o0
                       <== NOT EXECUTED
40005ba0:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005ba4:	01 00 00 00 	nop 
                                          

                                                                     
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Destroy(
        
  POSIX_Condition_variables_Control *the_cond
                        
)
                                                                    
{
                                                                    
  the_cond->flags = ~the_cond->flags;
                                
40005ba8:	c2 06 00 00 	ld  [ %i0 ], %g1
                              
40005bac:	82 38 00 01 	xnor  %g0, %g1, %g1
                           
40005bb0:	c2 26 00 00 	st  %g1, [ %i0 ]
                              
  }
                                                                  

                                                                     
  _POSIX_Condition_variables_Release( the_cond, &queue_context );
    
  _POSIX_Condition_variables_Destroy( the_cond );
                    
  return 0;
                                                          
}
                                                                    
40005bb4:	81 c7 e0 08 	ret 
                                          
40005bb8:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
      
40005bbc:	40 00 00 2e 	call  40005c74 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
40005bc0:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40005bc4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40005bc8:	12 bf ff ed 	bne  40005b7c <pthread_cond_destroy+0x2c>
     <== NOT EXECUTED
40005bcc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40005bd0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005bd4:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
40005bd8 <pthread_cond_init>:
                                        
{
                                                                    
  POSIX_Condition_variables_Control *the_cond;
                       

                                                                     
  the_cond = _POSIX_Condition_variables_Get( cond );
                 

                                                                     
  if ( the_cond == NULL ) {
                                          
40005bd8:	82 92 20 00 	orcc  %o0, 0, %g1
                             
40005bdc:	02 80 00 1a 	be  40005c44 <pthread_cond_init+0x6c>
         <== NEVER TAKEN
40005be0:	80 a2 60 00 	cmp  %o1, 0
                                   
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( attr == NULL ) {
                                              
40005be4:	22 80 00 1b 	be,a   40005c50 <pthread_cond_init+0x78>
      <== ALWAYS TAKEN
40005be8:	13 10 00 3e 	sethi  %hi(0x4000f800), %o1
                   
    attr = &_POSIX_Condition_variables_Default_attributes;
           
  }
                                                                  

                                                                     
  if ( !attr->is_initialized ) {
                                     
40005bec:	c4 02 40 00 	ld  [ %o1 ], %g2
                              
40005bf0:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005bf4:	02 80 00 15 	be  40005c48 <pthread_cond_init+0x70>
         <== NEVER TAKEN
40005bf8:	90 10 20 16 	mov  0x16, %o0
                                
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
          
40005bfc:	c4 02 60 10 	ld  [ %o1 + 0x10 ], %g2
                       
40005c00:	80 a0 a0 01 	cmp  %g2, 1
                                   
40005c04:	18 80 00 11 	bgu  40005c48 <pthread_cond_init+0x70>
        <== NEVER TAKEN
40005c08:	05 06 37 ec 	sethi  %hi(0x18dfb000), %g2
                   
40005c0c:	c6 02 60 08 	ld  [ %o1 + 8 ], %g3
                          
40005c10:	c8 02 60 0c 	ld  [ %o1 + 0xc ], %g4
                        
)
                                                                    
{
                                                                    
#if defined(RTEMS_SMP)
                                               
  _SMP_ticket_lock_Initialize( &queue->Lock );
                       
#endif
                                                               
  queue->heads = NULL;
                                               
40005c14:	c0 20 60 0c 	clr  [ %g1 + 0xc ]
                            
  queue->owner = NULL;
                                               
40005c18:	c0 20 60 10 	clr  [ %g1 + 0x10 ]
                           
  flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
    
40005c1c:	84 10 a1 fe 	or  %g2, 0x1fe, %g2
                           
  queue->name = name;
                                                
40005c20:	c0 20 60 14 	clr  [ %g1 + 0x14 ]
                           
40005c24:	84 18 40 02 	xor  %g1, %g2, %g2
                            
  the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
              
40005c28:	c0 20 60 18 	clr  [ %g1 + 0x18 ]
                           
  if ( the_attr->clock == CLOCK_MONOTONIC ) {
                        
40005c2c:	80 a0 e0 00 	cmp  %g3, 0
                                   
40005c30:	02 80 00 0a 	be  40005c58 <pthread_cond_init+0x80>
         <== ALWAYS TAKEN
40005c34:	84 08 bf fe 	and  %g2, -2, %g2
                             
  the_cond->flags = flags;
                                           
40005c38:	c4 20 40 00 	st  %g2, [ %g1 ]
                              <== NOT EXECUTED
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  _POSIX_Condition_variables_Initialize( the_cond, attr );
           
  return 0;
                                                          
40005c3c:	81 c3 e0 08 	retl 
                                         
40005c40:	90 10 20 00 	clr  %o0
                                      
    return EINVAL;
                                                   
40005c44:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED
}
                                                                    
40005c48:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005c4c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    attr = &_POSIX_Condition_variables_Default_attributes;
           
40005c50:	10 bf ff e7 	b  40005bec <pthread_cond_init+0x14>
          
40005c54:	92 12 63 40 	or  %o1, 0x340, %o1
                           
  if ( the_attr->clock == CLOCK_MONOTONIC ) {
                        
40005c58:	80 a1 20 04 	cmp  %g4, 4
                                   
40005c5c:	32 bf ff f8 	bne,a   40005c3c <pthread_cond_init+0x64>
     <== ALWAYS TAKEN
40005c60:	c4 20 40 00 	st  %g2, [ %g1 ]
                              
    flags |= POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC;
              
40005c64:	84 10 a0 01 	or  %g2, 1, %g2
                               <== NOT EXECUTED
  return 0;
                                                          
40005c68:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
40005c6c:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005c70:	c4 20 40 00 	st  %g2, [ %g1 ]
                              <== NOT EXECUTED

                                                                     
===============================================================================
40005cfc <pthread_cond_timedwait>:
                                   
  pthread_cond_t        *cond,
                                       
  pthread_mutex_t       *mutex,
                                      
  const struct timespec *abstime
                                     
)
                                                                    
{
                                                                    
  if ( abstime == NULL ) {
                                           
40005cfc:	80 a2 a0 00 	cmp  %o2, 0
                                   
40005d00:	02 80 00 05 	be  40005d14 <pthread_cond_timedwait+0x18>
    <== NEVER TAKEN
40005d04:	01 00 00 00 	nop 
                                          
    return EINVAL; /* not specified */
                               
  }
                                                                  
  return _POSIX_Condition_variables_Wait_support(
                    
40005d08:	82 13 c0 00 	mov  %o7, %g1
                                 
40005d0c:	40 00 00 22 	call  40005d94 <_POSIX_Condition_variables_Wait_support>

40005d10:	9e 10 40 00 	mov  %g1, %o7
                                 
    cond,
                                                            
    mutex,
                                                           
    abstime
                                                          
  );
                                                                 
}
                                                                    
40005d14:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
40005d18:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED

                                                                     
===============================================================================
4000c104 <pthread_create>:
                                           
  pthread_t              *thread,
                                    
  const pthread_attr_t   *attr,
                                      
  void                 *(*start_routine)( void * ),
                  
  void                   *arg
                                        
)
                                                                    
{
                                                                    
4000c104:	9d e3 bf 20 	save  %sp, -224, %sp
                          
  Thread_Entry_information entry = {
                                 
4000c108:	03 10 00 35 	sethi  %hi(0x4000d400), %g1
                   
4000c10c:	82 10 61 f0 	or  %g1, 0x1f0, %g1	! 4000d5f0 <_Thread_Entry_adaptor_pointer>

4000c110:	f4 27 bf c8 	st  %i2, [ %fp + -56 ]
                        
  size_t                              stacksize;
                     
  Objects_Name                        name;
                          
  int                                 error;
                         
  ISR_lock_Context                    lock_context;
                  

                                                                     
  if ( !start_routine )
                                              
4000c114:	80 a6 a0 00 	cmp  %i2, 0
                                   
  Thread_Entry_information entry = {
                                 
4000c118:	c2 27 bf c4 	st  %g1, [ %fp + -60 ]
                        
  int                                 schedpolicy = SCHED_RR;
        
4000c11c:	82 10 20 02 	mov  2, %g1
                                   
  Thread_Entry_information entry = {
                                 
4000c120:	f6 27 bf cc 	st  %i3, [ %fp + -52 ]
                        
  if ( !start_routine )
                                              
4000c124:	02 80 00 b0 	be  4000c3e4 <pthread_create+0x2e0>
           <== NEVER TAKEN
4000c128:	c2 27 bf bc 	st  %g1, [ %fp + -68 ]
                        
    return EFAULT;
                                                   

                                                                     
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
     
4000c12c:	80 a6 60 00 	cmp  %i1, 0
                                   
4000c130:	22 80 00 a5 	be,a   4000c3c4 <pthread_create+0x2c0>
        
4000c134:	33 10 00 3e 	sethi  %hi(0x4000f800), %i1
                   

                                                                     
  if ( !the_attr->is_initialized )
                                   
4000c138:	c2 06 40 00 	ld  [ %i1 ], %g1
                              
4000c13c:	80 a0 60 00 	cmp  %g1, 0
                                   
4000c140:	02 80 00 9e 	be  4000c3b8 <pthread_create+0x2b4>
           <== NEVER TAKEN
4000c144:	03 10 00 43 	sethi  %hi(0x40010c00), %g1
                   
   *  stack space if it is allowed to allocate it itself.
            
   *
                                                                 
   *  NOTE: If the user provides the stack we will let it drop below
 
   *        twice the minimum.
                                       
   */
                                                                
  if ( the_attr->stackaddr != NULL ) {
                               
4000c148:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2
                          
4000c14c:	e6 06 60 08 	ld  [ %i1 + 8 ], %l3
                          
4000c150:	80 a0 a0 00 	cmp  %g2, 0
                                   
4000c154:	02 80 00 9e 	be  4000c3cc <pthread_create+0x2c8>
           <== ALWAYS TAKEN
4000c158:	c2 00 61 80 	ld  [ %g1 + 0x180 ], %g1
                      
    if ( !_Stack_Is_enough(the_attr->stacksize) ) {
                  
4000c15c:	80 a0 40 13 	cmp  %g1, %l3
                                 <== NOT EXECUTED
4000c160:	18 80 00 97 	bgu  4000c3bc <pthread_create+0x2b8>
          <== NOT EXECUTED
4000c164:	a0 10 20 16 	mov  0x16, %l0
                                <== NOT EXECUTED
   *  If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread

   *  inherits scheduling attributes from the creating thread.   If it is

   *  PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the

   *  attributes structure.
                                          
   */
                                                                
  switch ( the_attr->inheritsched ) {
                                
4000c168:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1
                       
4000c16c:	80 a0 60 01 	cmp  %g1, 1
                                   
4000c170:	02 80 00 a1 	be  4000c3f4 <pthread_create+0x2f0>
           
4000c174:	e4 01 a0 20 	ld  [ %g6 + 0x20 ], %l2
                       
4000c178:	80 a0 60 02 	cmp  %g1, 2
                                   
4000c17c:	12 80 00 90 	bne  4000c3bc <pthread_create+0x2b8>
          <== NEVER TAKEN
4000c180:	a0 10 20 16 	mov  0x16, %l0
                                
      );
                                                             
      _Assert( error == 0 );
                                         
      break;
                                                         

                                                                     
    case PTHREAD_EXPLICIT_SCHED:
                                     
      schedpolicy = the_attr->schedpolicy;
                           
4000c184:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1
                       
      schedparam  = the_attr->schedparam;
                            
4000c188:	d4 1e 60 18 	ldd  [ %i1 + 0x18 ], %o2
                      
4000c18c:	f4 1e 60 20 	ldd  [ %i1 + 0x20 ], %i2
                      
4000c190:	f8 1e 60 28 	ldd  [ %i1 + 0x28 ], %i4
                      
4000c194:	c4 1e 60 30 	ldd  [ %i1 + 0x30 ], %g2
                      
4000c198:	d0 1e 60 38 	ldd  [ %i1 + 0x38 ], %o0
                      
4000c19c:	e0 1e 60 40 	ldd  [ %i1 + 0x40 ], %l0
                      
      schedpolicy = the_attr->schedpolicy;
                           
4000c1a0:	c2 27 bf bc 	st  %g1, [ %fp + -68 ]
                        
      schedparam  = the_attr->schedparam;
                            
4000c1a4:	d4 3f bf d0 	std  %o2, [ %fp + -48 ]
                       
4000c1a8:	f4 3f bf d8 	std  %i2, [ %fp + -40 ]
                       
4000c1ac:	f8 3f bf e0 	std  %i4, [ %fp + -32 ]
                       
4000c1b0:	c4 3f bf e8 	std  %g2, [ %fp + -24 ]
                       
4000c1b4:	d0 3f bf f0 	std  %o0, [ %fp + -16 ]
                       
4000c1b8:	e0 3f bf f8 	std  %l0, [ %fp + -8 ]
                        
  /*
                                                                 
   *  Check the contentionscope since rtems only supports PROCESS wide

   *  contention (i.e. no system wide contention).
                   
   */
                                                                
  if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
          
    return ENOTSUP;
                                                  
4000c1bc:	a0 10 20 86 	mov  0x86, %l0
                                
  if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
          
4000c1c0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1
                        
4000c1c4:	80 a0 60 00 	cmp  %g1, 0
                                   
4000c1c8:	12 80 00 7d 	bne  4000c3bc <pthread_create+0x2b8>
          <== NEVER TAKEN
4000c1cc:	d0 07 bf bc 	ld  [ %fp + -68 ], %o0
                        

                                                                     
  error = _POSIX_Thread_Translate_sched_param(
                       
4000c1d0:	96 07 bf b8 	add  %fp, -72, %o3
                            
4000c1d4:	94 07 bf b4 	add  %fp, -76, %o2
                            
4000c1d8:	40 00 06 7f 	call  4000dbd4 <_POSIX_Thread_Translate_sched_param>

4000c1dc:	92 07 bf d0 	add  %fp, -48, %o1
                            
    schedpolicy,
                                                     
    &schedparam,
                                                     
    &budget_algorithm,
                                               
    &budget_callout
                                                  
  );
                                                                 
  if ( error != 0 ) {
                                                
4000c1e0:	a0 92 20 00 	orcc  %o0, 0, %l0
                             
4000c1e4:	32 80 00 82 	bne,a   4000c3ec <pthread_create+0x2e8>
       <== NEVER TAKEN
4000c1e8:	b0 10 00 10 	mov  %l0, %i0
                                 <== NOT EXECUTED
    return error;
                                                    
  }
                                                                  

                                                                     
  normal_prio = schedparam.sched_priority;
                           
4000c1ec:	f6 07 bf d0 	ld  [ %fp + -48 ], %i3
                        

                                                                     
  scheduler = _Thread_Scheduler_get_home( executing );
               

                                                                     
  core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );

4000c1f0:	92 10 00 1b 	mov  %i3, %o1
                                 
4000c1f4:	94 07 bf b3 	add  %fp, -77, %o2
                            
4000c1f8:	29 10 00 3c 	sethi  %hi(0x4000f000), %l4
                   
4000c1fc:	40 00 06 45 	call  4000db10 <_POSIX_Priority_To_core>
      
4000c200:	90 15 22 a0 	or  %l4, 0x2a0, %o0	! 4000f2a0 <_Scheduler_Table>

  if ( !valid ) {
                                                    
4000c204:	c2 0f bf b3 	ldub  [ %fp + -77 ], %g1
                      
  core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );

4000c208:	b8 10 00 08 	mov  %o0, %i4
                                 
  if ( !valid ) {
                                                    
4000c20c:	80 a0 60 00 	cmp  %g1, 0
                                   
4000c210:	02 80 00 6a 	be  4000c3b8 <pthread_create+0x2b4>
           <== NEVER TAKEN
4000c214:	ba 10 00 09 	mov  %o1, %i5
                                 
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( schedpolicy == SCHED_SPORADIC ) {
                             
4000c218:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1
                        
4000c21c:	80 a0 60 04 	cmp  %g1, 4
                                   
4000c220:	22 80 00 02 	be,a   4000c228 <pthread_create+0x124>
        <== NEVER TAKEN
4000c224:	f6 07 bf d4 	ld  [ %fp + -44 ], %i3
                        <== NOT EXECUTED
    low_prio = schedparam.sched_ss_low_priority;
                     
  } else {
                                                           
    low_prio = normal_prio;
                                          
  }
                                                                  

                                                                     
  core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );

4000c228:	92 10 00 1b 	mov  %i3, %o1
                                 
4000c22c:	94 07 bf b3 	add  %fp, -77, %o2
                            
4000c230:	40 00 06 38 	call  4000db10 <_POSIX_Priority_To_core>
      
4000c234:	90 15 22 a0 	or  %l4, 0x2a0, %o0
                           
  if ( !valid ) {
                                                    
4000c238:	c2 0f bf b3 	ldub  [ %fp + -77 ], %g1
                      
  core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );

4000c23c:	b4 10 00 08 	mov  %o0, %i2
                                 
  if ( !valid ) {
                                                    
4000c240:	80 a0 60 00 	cmp  %g1, 0
                                   
4000c244:	02 80 00 5d 	be  4000c3b8 <pthread_create+0x2b4>
           <== NEVER TAKEN
4000c248:	b6 10 00 09 	mov  %o1, %i3
                                 
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( the_attr->affinityset == NULL ) {
                             
4000c24c:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1
                       
4000c250:	80 a0 60 00 	cmp  %g1, 0
                                   
4000c254:	22 80 00 5a 	be,a   4000c3bc <pthread_create+0x2b8>
        <== NEVER TAKEN
4000c258:	a0 10 20 16 	mov  0x16, %l0
                                <== NOT EXECUTED
  _RTEMS_Lock_allocator();
                                           
4000c25c:	7f ff e7 7a 	call  40006044 <_RTEMS_Lock_allocator>
        
4000c260:	2b 10 00 4a 	sethi  %hi(0x40012800), %l5
                   

                                                                     
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void)
   
{
                                                                    
  _Objects_Allocator_lock();
                                         

                                                                     
  _Thread_Kill_zombies();
                                            
4000c264:	7f ff f8 33 	call  4000a330 <_Thread_Kill_zombies>
         
4000c268:	01 00 00 00 	nop 
                                          

                                                                     
  return (Thread_Control *)
                                          
4000c26c:	7f ff ed 7e 	call  40007864 <_Objects_Allocate_unprotected>

4000c270:	90 15 62 08 	or  %l5, 0x208, %o0
                           
   *  Allocate the thread control block.
                             
   *
                                                                 
   *  NOTE:  Global threads are not currently supported.
             
   */
                                                                
  the_thread = _POSIX_Threads_Allocate();
                            
  if ( !the_thread ) {
                                               
4000c274:	a2 92 20 00 	orcc  %o0, 0, %l1
                             
4000c278:	02 80 00 66 	be  4000c410 <pthread_create+0x30c>
           <== NEVER TAKEN
4000c27c:	82 07 bf ac 	add  %fp, -84, %g1
                            

                                                                     
  /*
                                                                 
   *  Initialize the core thread for this task.
                      
   */
                                                                
  name.name_p = NULL;   /* posix threads don't have a name by default */

  status = _Thread_Initialize(
                                       
4000c280:	c2 23 a0 74 	st  %g1, [ %sp + 0x74 ]
                       
4000c284:	9a 10 20 01 	mov  1, %o5
                                   
4000c288:	c2 07 bf b8 	ld  [ %fp + -72 ], %g1
                        
4000c28c:	f8 3f bf a0 	std  %i4, [ %fp + -96 ]
                       
4000c290:	98 10 00 13 	mov  %l3, %o4
                                 
4000c294:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]
                       
4000c298:	94 15 22 a0 	or  %l4, 0x2a0, %o2
                           
4000c29c:	c2 07 bf b4 	ld  [ %fp + -76 ], %g1
                        
4000c2a0:	c2 23 a0 68 	st  %g1, [ %sp + 0x68 ]
                       
4000c2a4:	82 10 20 01 	mov  1, %g1
                                   
4000c2a8:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]
                       
4000c2ac:	92 10 00 11 	mov  %l1, %o1
                                 
4000c2b0:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1
                        
4000c2b4:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]
                       
4000c2b8:	90 15 62 08 	or  %l5, 0x208, %o0
                           
4000c2bc:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1
                        
4000c2c0:	c0 27 bf ac 	clr  [ %fp + -84 ]
                            
4000c2c4:	c0 23 a0 70 	clr  [ %sp + 0x70 ]
                           
4000c2c8:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]
                       
4000c2cc:	7f ff f3 53 	call  40009018 <_Thread_Initialize>
           
4000c2d0:	d6 06 60 04 	ld  [ %i1 + 4 ], %o3
                          
    budget_algorithm,
                                                
    budget_callout,
                                                  
    0,                    /* isr level */
                            
    name                  /* posix threads don't have a name */
      
  );
                                                                 
  if ( !status ) {
                                                   
4000c2d4:	80 a2 20 00 	cmp  %o0, 0
                                   
4000c2d8:	02 80 00 52 	be  4000c420 <pthread_create+0x31c>
           <== NEVER TAKEN
4000c2dc:	92 10 00 11 	mov  %l1, %o1
                                 
    _POSIX_Threads_Free( the_thread );
                               
    _Objects_Allocator_unlock();
                                     
    return EAGAIN;
                                                   
  }
                                                                  

                                                                     
  if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
          
4000c2e0:	c4 06 60 50 	ld  [ %i1 + 0x50 ], %g2
                       
4000c2e4:	80 a0 a0 00 	cmp  %g2, 0
                                   
4000c2e8:	12 80 00 03 	bne  4000c2f4 <pthread_create+0x1f0>
          <== ALWAYS TAKEN
4000c2ec:	c2 04 61 70 	ld  [ %l1 + 0x170 ], %g1
                      
    the_thread->Life.state |= THREAD_LIFE_DETACHED;
                  
4000c2f0:	82 10 60 10 	or  %g1, 0x10, %g1
                            <== NOT EXECUTED
  }
                                                                  

                                                                     
  the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED;
             
4000c2f4:	82 10 60 08 	or  %g1, 8, %g1
                               <== NOT EXECUTED
4000c2f8:	c2 24 61 70 	st  %g1, [ %l1 + 0x170 ]
                      <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000c2fc:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
  _ISR_lock_ISR_disable( &lock_context );
                            
4000c300:	c2 27 bf c0 	st  %g1, [ %fp + -64 ]
                        
   status = _Scheduler_Set_affinity(
                                 
4000c304:	d4 06 60 58 	ld  [ %i1 + 0x58 ], %o2
                       
4000c308:	d2 06 60 54 	ld  [ %i1 + 0x54 ], %o1
                       
4000c30c:	40 00 03 39 	call  4000cff0 <_Scheduler_Set_affinity>
      
4000c310:	90 10 00 11 	mov  %l1, %o0
                                 
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000c314:	c2 07 bf c0 	ld  [ %fp + -64 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000c318:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000c31c:	01 00 00 00 	nop 
                                          
     the_thread,
                                                     
     the_attr->affinitysetsize,
                                      
     the_attr->affinityset
                                           
   );
                                                                
  _ISR_lock_ISR_enable( &lock_context );
                             
   if ( !status ) {
                                                  
4000c320:	80 a2 20 00 	cmp  %o0, 0
                                   
4000c324:	02 80 00 45 	be  4000c438 <pthread_create+0x334>
           <== NEVER TAKEN
4000c328:	92 10 00 11 	mov  %l1, %o1
                                 
   *  finish initializing the per API structure
                      
   */
                                                                
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
  executing_api = executing->API_Extensions[ THREAD_API_POSIX ];
     

                                                                     
  api->signals_unblocked = executing_api->signals_unblocked;
         
4000c32c:	c2 04 a1 5c 	ld  [ %l2 + 0x15c ], %g1
                      
4000c330:	c4 00 60 68 	ld  [ %g1 + 0x68 ], %g2
                       
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
4000c334:	d0 04 61 5c 	ld  [ %l1 + 0x15c ], %o0
                      

                                                                     
  the_thread->was_created_with_inherited_scheduler =
                 
    ( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
             
4000c338:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1
                       
4000c33c:	82 18 60 01 	xor  %g1, 1, %g1
                              
  api->signals_unblocked = executing_api->signals_unblocked;
         
4000c340:	c4 22 20 68 	st  %g2, [ %o0 + 0x68 ]
                       
    ( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
             
4000c344:	80 a0 00 01 	cmp  %g0, %g1
                                 
4000c348:	82 60 3f ff 	subx  %g0, -1, %g1
                            
4000c34c:	c2 2c 60 8b 	stb  %g1, [ %l1 + 0x8b ]
                      
  node->priority = priority;
                                         
4000c350:	f4 3a 20 38 	std  %i2, [ %o0 + 0x38 ]
                      
  _Priority_Node_set_priority( &api->Sporadic.Low_priority, core_low_prio );

  api->Sporadic.sched_ss_repl_period =
                               
    the_attr->schedparam.sched_ss_repl_period;
                       
  api->Sporadic.sched_ss_init_budget =
                               
    the_attr->schedparam.sched_ss_init_budget;
                       
  api->Sporadic.sched_ss_max_repl =
                                  
4000c354:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1
                       
  api->Sporadic.sched_ss_repl_period =
                               
4000c358:	f4 1e 60 20 	ldd  [ %i1 + 0x20 ], %i2
                      
4000c35c:	f8 1e 60 28 	ldd  [ %i1 + 0x28 ], %i4
                      
  api->Sporadic.sched_ss_init_budget =
                               
4000c360:	c4 1e 60 30 	ldd  [ %i1 + 0x30 ], %g2
                      
4000c364:	d8 1e 60 38 	ldd  [ %i1 + 0x38 ], %o4
                      
4000c368:	d8 3a 20 58 	std  %o4, [ %o0 + 0x58 ]
                      
  api->Sporadic.sched_ss_max_repl =
                                  
4000c36c:	c2 22 20 60 	st  %g1, [ %o0 + 0x60 ]
                       
  api->Sporadic.sched_ss_repl_period =
                               
4000c370:	f4 3a 20 40 	std  %i2, [ %o0 + 0x40 ]
                      
4000c374:	f8 3a 20 48 	std  %i4, [ %o0 + 0x48 ]
                      
  api->Sporadic.sched_ss_init_budget =
                               
4000c378:	c4 3a 20 50 	std  %g2, [ %o0 + 0x50 ]
                      
    the_attr->schedparam.sched_ss_max_repl;
                          

                                                                     
  if ( schedpolicy == SCHED_SPORADIC ) {
                             
4000c37c:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1
                        
4000c380:	80 a0 60 04 	cmp  %g1, 4
                                   
4000c384:	02 80 00 33 	be  4000c450 <pthread_create+0x34c>
           <== NEVER TAKEN
4000c388:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000c38c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  }
                                                                  

                                                                     
  /*
                                                                 
   *  POSIX threads are allocated and started in one operation.
      
   */
                                                                
  _ISR_lock_ISR_disable( &lock_context );
                            
4000c390:	c2 27 bf c0 	st  %g1, [ %fp + -64 ]
                        
  status = _Thread_Start( the_thread, &entry, &lock_context );
       
4000c394:	94 07 bf c0 	add  %fp, -64, %o2
                            
4000c398:	92 07 bf c4 	add  %fp, -60, %o1
                            
4000c39c:	40 00 05 0e 	call  4000d7d4 <_Thread_Start>
                
4000c3a0:	90 10 00 11 	mov  %l1, %o0
                                 
  #endif
                                                             

                                                                     
  /*
                                                                 
   *  Return the id and indicate we successfully created the thread
  
   */
                                                                
  *thread = the_thread->Object.id;
                                   
4000c3a4:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1
                          
  _RTEMS_Unlock_allocator();
                                         
4000c3a8:	7f ff e7 2c 	call  40006058 <_RTEMS_Unlock_allocator>
      
4000c3ac:	c2 26 00 00 	st  %g1, [ %i0 ]
                              

                                                                     
  _Objects_Allocator_unlock();
                                       
  return 0;
                                                          
4000c3b0:	81 c7 e0 08 	ret 
                                          
4000c3b4:	91 e8 00 10 	restore  %g0, %l0, %o0
                        
      return EINVAL;
                                                 
4000c3b8:	a0 10 20 16 	mov  0x16, %l0
                                <== NOT EXECUTED
}
                                                                    
4000c3bc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c3c0:	91 e8 00 10 	restore  %g0, %l0, %o0
                        <== NOT EXECUTED
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
     
4000c3c4:	10 bf ff 5d 	b  4000c138 <pthread_create+0x34>
             
4000c3c8:	b2 16 63 40 	or  %i1, 0x340, %i1
                           
  if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
                          
4000c3cc:	83 28 60 01 	sll  %g1, 1, %g1
                              
4000c3d0:	80 a4 c0 01 	cmp  %l3, %g1
                                 
4000c3d4:	2a bf ff 65 	bcs,a   4000c168 <pthread_create+0x64>
        
4000c3d8:	a6 10 00 01 	mov  %g1, %l3
                                 
  switch ( the_attr->inheritsched ) {
                                
4000c3dc:	10 bf ff 64 	b  4000c16c <pthread_create+0x68>
             
4000c3e0:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1
                       
    return EFAULT;
                                                   
4000c3e4:	a0 10 20 0e 	mov  0xe, %l0
                                 <== NOT EXECUTED
}
                                                                    
4000c3e8:	b0 10 00 10 	mov  %l0, %i0
                                 <== NOT EXECUTED
4000c3ec:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c3f0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      error = pthread_getschedparam(
                                 
4000c3f4:	40 00 00 c8 	call  4000c714 <pthread_self>
                 
4000c3f8:	a0 10 20 86 	mov  0x86, %l0
                                
4000c3fc:	94 07 bf d0 	add  %fp, -48, %o2
                            
4000c400:	40 00 00 17 	call  4000c45c <pthread_getschedparam>
        
4000c404:	92 07 bf bc 	add  %fp, -68, %o1
                            
      break;
                                                         
4000c408:	10 bf ff 6f 	b  4000c1c4 <pthread_create+0xc0>
             
4000c40c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1
                        
4000c410:	7f ff e7 12 	call  40006058 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
4000c414:	a0 10 20 0b 	mov  0xb, %l0
                                 <== NOT EXECUTED
    return EAGAIN;
                                                   
4000c418:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c41c:	91 e8 00 10 	restore  %g0, %l0, %o0
                        <== NOT EXECUTED

                                                                     
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
                      
  Thread_Control *the_pthread
                                        
)
                                                                    
{
                                                                    
  _Objects_Free( &_POSIX_Threads_Information.Objects, &the_pthread->Object );

4000c420:	90 15 62 08 	or  %l5, 0x208, %o0
                           <== NOT EXECUTED
4000c424:	40 00 02 34 	call  4000ccf4 <_Objects_Free>
                <== NOT EXECUTED
4000c428:	a0 10 20 0b 	mov  0xb, %l0
                                 <== NOT EXECUTED
4000c42c:	7f ff e7 0b 	call  40006058 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
4000c430:	b0 10 00 10 	mov  %l0, %i0
                                 <== NOT EXECUTED
    return EAGAIN;
                                                   
4000c434:	30 bf ff ee 	b,a   4000c3ec <pthread_create+0x2e8>
         <== NOT EXECUTED
4000c438:	90 15 62 08 	or  %l5, 0x208, %o0
                           <== NOT EXECUTED
4000c43c:	40 00 02 2e 	call  4000ccf4 <_Objects_Free>
                <== NOT EXECUTED
4000c440:	a0 10 20 16 	mov  0x16, %l0
                                <== NOT EXECUTED
     _RTEMS_Unlock_allocator();
                                      
4000c444:	7f ff e7 05 	call  40006058 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
4000c448:	b0 10 00 10 	mov  %l0, %i0
                                 <== NOT EXECUTED
     return EINVAL;
                                                  
4000c44c:	30 bf ff e8 	b,a   4000c3ec <pthread_create+0x2e8>
         <== NOT EXECUTED
    _POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer );
           
4000c450:	40 00 00 64 	call  4000c5e0 <_POSIX_Threads_Sporadic_timer>
<== NOT EXECUTED
4000c454:	90 02 20 08 	add  %o0, 8, %o0
                              <== NOT EXECUTED
4000c458:	30 bf ff cd 	b,a   4000c38c <pthread_create+0x288>
         <== NOT EXECUTED

                                                                     
===============================================================================
4000dcb4 <pthread_exit>:
                                             
#include <pthread.h>
                                                 

                                                                     
#include <rtems/score/threadimpl.h>
                                  

                                                                     
void pthread_exit( void *value_ptr )
                                 
{
                                                                    
4000dcb4:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  disable_level = cpu_self->thread_dispatch_disable_level;
           
4000dcb8:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
4000dcbc:	82 00 60 01 	inc  %g1
                                      
4000dcc0:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       
  return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );

4000dcc4:	ba 10 00 06 	mov  %g6, %i5
                                 
  Per_CPU_Control *cpu_self;
                                         

                                                                     
  cpu_self = _Thread_Dispatch_disable();
                             
  executing = _Per_CPU_Get_executing( cpu_self );
                    

                                                                     
  _Thread_Exit( executing, THREAD_LIFE_TERMINATING, value_ptr );
     
4000dcc8:	d0 01 a0 20 	ld  [ %g6 + 0x20 ], %o0
                       
4000dccc:	94 10 00 18 	mov  %i0, %o2
                                 
4000dcd0:	7f ff f1 e0 	call  4000a450 <_Thread_Exit>
                 
4000dcd4:	92 10 20 04 	mov  4, %o1
                                   

                                                                     
  _Thread_Dispatch_direct( cpu_self );
                               
4000dcd8:	7f ff fe 3b 	call  4000d5c4 <_Thread_Dispatch_direct>
      
4000dcdc:	90 10 00 1d 	mov  %i5, %o0
                                 
4000dce0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000c45c <pthread_getschedparam>:
                                    
int pthread_getschedparam(
                                           
  pthread_t           thread,
                                        
  int                *policy,
                                        
  struct sched_param *param
                                          
)
                                                                    
{
                                                                    
4000c45c:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  Thread_queue_Context          queue_context;
                       
  Thread_CPU_budget_algorithms  budget_algorithm;
                    
  const Scheduler_Control      *scheduler;
                           
  Priority_Control              priority;
                            

                                                                     
  if ( policy == NULL || param == NULL ) {
                           
4000c460:	80 a6 60 00 	cmp  %i1, 0
                                   
4000c464:	02 80 00 2b 	be  4000c510 <pthread_getschedparam+0xb4>
     <== NEVER TAKEN
4000c468:	80 a6 a0 00 	cmp  %i2, 0
                                   
4000c46c:	02 80 00 29 	be  4000c510 <pthread_getschedparam+0xb4>
     <== NEVER TAKEN
4000c470:	90 10 00 18 	mov  %i0, %o0
                                 
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );

4000c474:	92 07 bf dc 	add  %fp, -36, %o1
                            
4000c478:	7f ff f2 ab 	call  40008f24 <_Thread_Get>
                  
4000c47c:	b0 10 20 03 	mov  3, %i0
                                   

                                                                     
  if ( the_thread == NULL ) {
                                        
4000c480:	80 a2 20 00 	cmp  %o0, 0
                                   
4000c484:	02 80 00 21 	be  4000c508 <pthread_getschedparam+0xac>
     <== NEVER TAKEN
4000c488:	a2 10 00 08 	mov  %o0, %l1
                                 
4000c48c:	f6 02 21 5c 	ld  [ %o0 + 0x15c ], %i3
                      
)
                                                                    
{
                                                                    
  const POSIX_API_Control *api;
                                      

                                                                     
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
  param->sched_ss_low_priority = _POSIX_Priority_From_core(
          
4000c490:	d4 06 e0 3c 	ld  [ %i3 + 0x3c ], %o2
                       
4000c494:	d2 06 e0 38 	ld  [ %i3 + 0x38 ], %o1
                       
4000c498:	25 10 00 3c 	sethi  %hi(0x4000f000), %l2
                   
4000c49c:	40 00 05 ba 	call  4000db84 <_POSIX_Priority_From_core>
    
4000c4a0:	90 14 a2 a0 	or  %l2, 0x2a0, %o0	! 4000f2a0 <_Scheduler_Table>

    scheduler,
                                                       
    api->Sporadic.Low_priority.priority
                              
  );
                                                                 
  param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
  
  param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
  
4000c4a4:	c4 1e e0 58 	ldd  [ %i3 + 0x58 ], %g2
                      <== NOT EXECUTED
4000c4a8:	f8 1e e0 50 	ldd  [ %i3 + 0x50 ], %i4
                      <== NOT EXECUTED
  param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
  
4000c4ac:	d8 1e e0 40 	ldd  [ %i3 + 0x40 ], %o4
                      <== NOT EXECUTED
4000c4b0:	d4 1e e0 48 	ldd  [ %i3 + 0x48 ], %o2
                      <== NOT EXECUTED
  param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl;
        
4000c4b4:	c2 06 e0 60 	ld  [ %i3 + 0x60 ], %g1
                       <== NOT EXECUTED
4000c4b8:	c2 26 a0 28 	st  %g1, [ %i2 + 0x28 ]
                       <== NOT EXECUTED
  param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
  
4000c4bc:	f8 3e a0 18 	std  %i4, [ %i2 + 0x18 ]
                      <== NOT EXECUTED
4000c4c0:	c4 3e a0 20 	std  %g2, [ %i2 + 0x20 ]
                      <== NOT EXECUTED
  param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
  
4000c4c4:	d8 3e a0 08 	std  %o4, [ %i2 + 8 ]
                         <== NOT EXECUTED
4000c4c8:	d4 3e a0 10 	std  %o2, [ %i2 + 0x10 ]
                      <== NOT EXECUTED
  param->sched_ss_low_priority = _POSIX_Priority_From_core(
          
4000c4cc:	d0 26 a0 04 	st  %o0, [ %i2 + 4 ]
                          <== NOT EXECUTED

                                                                     
  _Thread_Wait_acquire_critical( the_thread, &queue_context );
       

                                                                     
  scheduler = _Thread_Scheduler_get_home( the_thread );
              
  _POSIX_Threads_Get_sched_param_sporadic( the_thread, scheduler, param );

  priority = the_thread->Real_priority.priority;
                     
4000c4d0:	c4 1c 60 30 	ldd  [ %l1 + 0x30 ], %g2
                      <== NOT EXECUTED
  budget_algorithm = the_thread->budget_algorithm;
                   
4000c4d4:	fa 04 60 90 	ld  [ %l1 + 0x90 ], %i5
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000c4d8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000c4dc:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000c4e0:	01 00 00 00 	nop 
                                          

                                                                     
  _Thread_Wait_release( the_thread, &queue_context );
                

                                                                     
  param->sched_priority = _POSIX_Priority_From_core( scheduler, priority );

4000c4e4:	92 10 00 02 	mov  %g2, %o1
                                 
4000c4e8:	94 10 00 03 	mov  %g3, %o2
                                 
4000c4ec:	40 00 05 a6 	call  4000db84 <_POSIX_Priority_From_core>
    
4000c4f0:	90 14 a2 a0 	or  %l2, 0x2a0, %o0
                           
4000c4f4:	d0 26 80 00 	st  %o0, [ %i2 ]
                              
  *policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );

  return 0;
                                                          
4000c4f8:	b0 10 20 00 	clr  %i0
                                      
  *policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );

4000c4fc:	40 00 05 ac 	call  4000dbac <_POSIX_Thread_Translate_to_sched_policy>

4000c500:	90 10 00 1d 	mov  %i5, %o0
                                 
4000c504:	d0 26 40 00 	st  %o0, [ %i1 ]
                              
  return 0;
                                                          
4000c508:	81 c7 e0 08 	ret 
                                          
4000c50c:	81 e8 00 00 	restore 
                                      
    return EINVAL;
                                                   
4000c510:	b0 10 20 16 	mov  0x16, %i0
                                <== NOT EXECUTED
}
                                                                    
4000c514:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000c518:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40005bac <pthread_getspecific>:
                                      
    ISR_Level level;
                                                 

                                                                     
    _ISR_Local_disable( level );
                                     
  #endif
                                                             

                                                                     
  executing = _Thread_Executing;
                                     
40005bac:	c6 01 a0 20 	ld  [ %g6 + 0x20 ], %g3
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005bb0:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
 */
                                                                  
RTEMS_INLINE_ROUTINE RBTree_Node * const *_RBTree_Root_const_reference(

  const RBTree_Control *the_rbtree
                                   
)
                                                                    
{
                                                                    
  return &RB_ROOT( the_rbtree );
                                     
40005bb4:	86 00 e1 60 	add  %g3, 0x160, %g3
                          
  RBTree_Node         *parent;
                                       

                                                                     
  link = _RBTree_Root_const_reference( the_rbtree );
                 
  parent = NULL;
                                                     

                                                                     
  while ( *link != NULL ) {
                                          
40005bb8:	c4 00 c0 00 	ld  [ %g3 ], %g2
                              
40005bbc:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005bc0:	02 80 00 0d 	be  40005bf4 <pthread_getspecific+0x48>
       
40005bc4:	86 00 bf f8 	add  %g2, -8, %g3
                             
  const POSIX_Keys_Key_value_pair *the_right;
                        

                                                                     
  the_left = left;
                                                   
  the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right );
     

                                                                     
  return *the_left == the_right->key;
                                
40005bc8:	c8 00 e0 18 	ld  [ %g3 + 0x18 ], %g4
                       
    parent = *link;
                                                  

                                                                     
    if ( ( *equal )( key, parent ) ) {
                               
40005bcc:	80 a2 00 04 	cmp  %o0, %g4
                                 
40005bd0:	22 80 00 0e 	be,a   40005c08 <pthread_getspecific+0x5c>
    <== ALWAYS TAKEN
40005bd4:	d0 00 e0 20 	ld  [ %g3 + 0x20 ], %o0
                       
      return ( *map )( parent );
                                     
    } else if ( ( *less )( key, parent ) ) {
                         
40005bd8:	1a bf ff f8 	bcc  40005bb8 <pthread_getspecific+0xc>
       <== NOT EXECUTED
40005bdc:	86 00 a0 04 	add  %g2, 4, %g3
                              <== NOT EXECUTED
  return &RB_LEFT( the_node, Node );
                                 
40005be0:	86 10 00 02 	mov  %g2, %g3
                                 <== NOT EXECUTED
  while ( *link != NULL ) {
                                          
40005be4:	c4 00 c0 00 	ld  [ %g3 ], %g2
                              <== NOT EXECUTED
40005be8:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40005bec:	12 bf ff f7 	bne  40005bc8 <pthread_getspecific+0x1c>
      <== NOT EXECUTED
40005bf0:	86 00 bf f8 	add  %g2, -8, %g3
                             <== NOT EXECUTED
  key_value_pair = _POSIX_Keys_Key_value_find( key, executing );
     

                                                                     
  if ( key_value_pair != NULL ) {
                                    
    value = key_value_pair->value;
                                   
  } else {
                                                           
    value = NULL;
                                                    
40005bf4:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005bf8:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005bfc:	01 00 00 00 	nop 
                                          
  }
                                                                  

                                                                     
  _POSIX_Keys_Key_value_release( executing, &lock_context );
         

                                                                     
  return value;
                                                      
}
                                                                    
40005c00:	81 c3 e0 08 	retl 
                                         
40005c04:	01 00 00 00 	nop 
                                          
40005c08:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005c0c:	01 00 00 00 	nop 
                                          
40005c10:	81 c3 e0 08 	retl 
                                         
40005c14:	01 00 00 00 	nop 
                                          

                                                                     
===============================================================================
40005b3c <pthread_key_create>:
                                       
 */
                                                                  
int pthread_key_create(
                                              
  pthread_key_t  *key,
                                               
  void          (*destructor)( void * )
                              
)
                                                                    
{
                                                                    
40005b3c:	9d e3 bf a0 	save  %sp, -96, %sp
                           
 * the inactive chain of free keys control blocks.
                   
 */
                                                                  

                                                                     
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )

{
                                                                    
  return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );

40005b40:	3b 10 00 49 	sethi  %hi(0x40012400), %i5
                   
40005b44:	40 00 07 7e 	call  4000793c <_Objects_Allocate>
            
40005b48:	90 17 60 98 	or  %i5, 0x98, %o0	! 40012498 <_POSIX_Keys_Information>

  POSIX_Keys_Control  *the_key;
                                      

                                                                     
  the_key = _POSIX_Keys_Allocate();
                                  

                                                                     
  if ( !the_key ) {
                                                  
40005b4c:	80 a2 20 00 	cmp  %o0, 0
                                   
40005b50:	02 80 00 13 	be  40005b9c <pthread_key_create+0x60>
        <== NEVER TAKEN
40005b54:	86 02 20 14 	add  %o0, 0x14, %g3
                           
  #if defined(RTEMS_DEBUG)
                                           
    if ( index > information->maximum )
                              
      return;
                                                        
  #endif
                                                             

                                                                     
  information->local_table[ index ] = the_object;
                    
40005b58:	c2 12 20 0a 	lduh  [ %o0 + 0xa ], %g1
                      
  tail->previous = head;
                                             
40005b5c:	c6 22 20 1c 	st  %g3, [ %o0 + 0x1c ]
                       
  return &the_chain->Tail.Node;
                                      
40005b60:	84 02 20 18 	add  %o0, 0x18, %g2
                           
    _Objects_Allocator_unlock();
                                     
    return EAGAIN;
                                                   
  }
                                                                  

                                                                     
  the_key->destructor = destructor;
                                  
40005b64:	f2 22 20 10 	st  %i1, [ %o0 + 0x10 ]
                       
40005b68:	ba 17 60 98 	or  %i5, 0x98, %i5
                            
  head->next = tail;
                                                 
40005b6c:	c4 22 20 14 	st  %g2, [ %o0 + 0x14 ]
                       
40005b70:	83 28 60 02 	sll  %g1, 2, %g1
                              
  head->previous = NULL;
                                             
40005b74:	c0 22 20 18 	clr  [ %o0 + 0x18 ]
                           
  Objects_Control     *the_object,
                                   
  uint32_t             name
                                          
)
                                                                    
{
                                                                    
  /* ASSERT: information->is_string == false */
                      
  the_object->name.name_u32 = name;
                                  
40005b78:	c0 22 20 0c 	clr  [ %o0 + 0xc ]
                            
  information->local_table[ index ] = the_object;
                    
40005b7c:	c6 07 60 1c 	ld  [ %i5 + 0x1c ], %g3
                       
40005b80:	c4 02 20 08 	ld  [ %o0 + 8 ], %g2
                          
40005b84:	d0 20 c0 01 	st  %o0, [ %g3 + %g1 ]
                        
  _Chain_Initialize_empty( &the_key->Key_value_pairs );
              
  _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );

  *key = the_key->Object.id;
                                         
40005b88:	c4 26 00 00 	st  %g2, [ %i0 ]
                              
 * previous thread life protection state and thus may not return if the

 * executing thread was restarted or deleted in the mean-time.
       
 */
                                                                  
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
          
{
                                                                    
  _RTEMS_Unlock_allocator();
                                         
40005b8c:	40 00 01 33 	call  40006058 <_RTEMS_Unlock_allocator>
      
40005b90:	b0 10 20 00 	clr  %i0
                                      
  _Objects_Allocator_unlock();
                                       
  return 0;
                                                          
}
                                                                    
40005b94:	81 c7 e0 08 	ret 
                                          
40005b98:	81 e8 00 00 	restore 
                                      
40005b9c:	40 00 01 2f 	call  40006058 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40005ba0:	b0 10 20 0b 	mov  0xb, %i0
                                 <== NOT EXECUTED
    return EAGAIN;
                                                   
40005ba4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005ba8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40005b70 <pthread_key_delete>:
                                       
 *  17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167

 */
                                                                  
int pthread_key_delete(
                                              
  pthread_key_t  key
                                                 
)
                                                                    
{
                                                                    
40005b70:	9d e3 bf 98 	save  %sp, -104, %sp
                          
  _RTEMS_Lock_allocator();
                                           
40005b74:	40 00 01 1e 	call  40005fec <_RTEMS_Lock_allocator>
        
40005b78:	33 10 00 49 	sethi  %hi(0x40012400), %i1
                   
  _Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
       
}
                                                                    

                                                                     
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Get( pthread_key_t key )

{
                                                                    
  return (POSIX_Keys_Control *)
                                      
40005b7c:	90 10 00 18 	mov  %i0, %o0
                                 
  the_key = _POSIX_Keys_Get( key );
                                  
  if ( the_key != NULL ) {
                                           
    _POSIX_Keys_Destroy( the_key );
                                  
    eno = 0;
                                                         
  } else {
                                                           
    eno = EINVAL;
                                                    
40005b80:	b0 10 20 16 	mov  0x16, %i0
                                
40005b84:	40 00 08 55 	call  40007cd8 <_Objects_Get_no_protection>
   
40005b88:	92 16 60 00 	mov  %i1, %o1
                                 
  if ( the_key != NULL ) {
                                           
40005b8c:	80 a2 20 00 	cmp  %o0, 0
                                   
40005b90:	02 80 00 24 	be  40005c20 <pthread_key_delete+0xb0>
        <== NEVER TAKEN
40005b94:	b8 10 00 08 	mov  %o0, %i4
                                 
  _Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
      
40005b98:	92 10 00 08 	mov  %o0, %o1
                                 
40005b9c:	40 00 07 57 	call  400078f8 <_Objects_Close>
               
40005ba0:	90 16 60 00 	mov  %i1, %o0
                                 
  return _Chain_Immutable_head( the_chain )->next;
                   
40005ba4:	fa 07 20 14 	ld  [ %i4 + 0x14 ], %i5
                       
  return &the_chain->Tail.Node;
                                      
40005ba8:	b4 07 20 18 	add  %i4, 0x18, %i2
                           
  while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
          
40005bac:	80 a6 80 1d 	cmp  %i2, %i5
                                 
40005bb0:	02 80 00 19 	be  40005c14 <pthread_key_delete+0xa4>
        
40005bb4:	92 10 00 1c 	mov  %i4, %o1
                                 
40005bb8:	37 10 00 49 	sethi  %hi(0x40012400), %i3
                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Key_value_free(
                
  POSIX_Keys_Key_value_pair *key_value_pair
                          
)
                                                                    
{
                                                                    
  _Chain_Extract_unprotected( &key_value_pair->Key_node );
           
  _Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
            
40005bbc:	b6 16 e0 3c 	or  %i3, 0x3c, %i3	! 4001243c <_POSIX_Keys_Keypool>
<== NOT EXECUTED
    the_thread = key_value_pair->thread;
                             
40005bc0:	d0 07 60 1c 	ld  [ %i5 + 0x1c ], %o0
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005bc4:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  return psr;
                                                        
40005bc8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         
    _RBTree_Extract(
                                                 
40005bcc:	92 07 60 08 	add  %i5, 8, %o1
                              
40005bd0:	40 00 09 0a 	call  40007ff8 <_RBTree_Extract>
              
40005bd4:	90 02 21 60 	add  %o0, 0x160, %o0
                          
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40005bd8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005bdc:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005be0:	01 00 00 00 	nop 
                                          
  next           = the_node->next;
                                   
40005be4:	c4 07 40 00 	ld  [ %i5 ], %g2
                              
  previous       = the_node->previous;
                               
40005be8:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1
                          
  next->previous = previous;
                                         
40005bec:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]
                          
40005bf0:	92 10 00 1d 	mov  %i5, %o1
                                 
  previous->next = next;
                                             
40005bf4:	c4 20 40 00 	st  %g2, [ %g1 ]
                              
40005bf8:	40 00 01 5e 	call  40006170 <_Freechain_Put>
               
40005bfc:	90 10 00 1b 	mov  %i3, %o0
                                 
  return _Chain_Immutable_head( the_chain )->next;
                   
40005c00:	fa 07 20 14 	ld  [ %i4 + 0x14 ], %i5
                       
  while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
          
40005c04:	80 a7 40 1a 	cmp  %i5, %i2
                                 
40005c08:	32 bf ff ef 	bne,a   40005bc4 <pthread_key_delete+0x54>
    <== NEVER TAKEN
40005c0c:	d0 07 60 1c 	ld  [ %i5 + 0x1c ], %o0
                       <== NOT EXECUTED
  _Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
       
40005c10:	92 10 00 1c 	mov  %i4, %o1
                                 
40005c14:	90 16 60 00 	mov  %i1, %o0
                                 
40005c18:	40 00 08 04 	call  40007c28 <_Objects_Free>
                
40005c1c:	b0 10 20 00 	clr  %i0
                                      
  _RTEMS_Unlock_allocator();
                                         
40005c20:	40 00 00 f8 	call  40006000 <_RTEMS_Unlock_allocator>
      
40005c24:	01 00 00 00 	nop 
                                          
  }
                                                                  

                                                                     
  _Objects_Allocator_unlock();
                                       

                                                                     
  return eno;
                                                        
}
                                                                    
40005c28:	81 c7 e0 08 	ret 
                                          
40005c2c:	81 e8 00 00 	restore 
                                      

                                                                     
===============================================================================
4000f88c <pthread_kill>:
                                             
#include <rtems/posix/threadsup.h>
                                   
#include <rtems/posix/psignalimpl.h>
                                 
#include <rtems/score/threadimpl.h>
                                  

                                                                     
int pthread_kill( pthread_t thread, int sig )
                        
{
                                                                    
4000f88c:	9d e3 bf 90 	save  %sp, -112, %sp
                          <== NOT EXECUTED

                                                                     
static inline bool is_valid_signo(
                                   
  int signo
                                                          
)
                                                                    
{
                                                                    
  return ((signo) >= 1 && (signo) <= 32 );
                           
4000f890:	ba 06 7f ff 	add  %i1, -1, %i5
                             <== NOT EXECUTED
  Thread_Control    *the_thread;
                                     
  ISR_lock_Context   lock_context;
                                   
  POSIX_API_Control *api;
                                            
  Per_CPU_Control   *cpu_self;
                                       

                                                                     
  if ( !is_valid_signo( sig ) ) {
                                    
4000f894:	80 a7 60 1f 	cmp  %i5, 0x1f
                                <== NOT EXECUTED
4000f898:	18 80 00 28 	bgu  4000f938 <pthread_kill+0xac>
             <== NOT EXECUTED
4000f89c:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  the_thread = _Thread_Get( thread, &lock_context );
                 
4000f8a0:	92 07 bf fc 	add  %fp, -4, %o1
                             <== NOT EXECUTED
4000f8a4:	7f ff e9 df 	call  4000a020 <_Thread_Get>
                  <== NOT EXECUTED
4000f8a8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED

                                                                     
  if ( the_thread == NULL ) {
                                        
4000f8ac:	86 92 20 00 	orcc  %o0, 0, %g3
                             <== NOT EXECUTED
4000f8b0:	02 80 00 22 	be  4000f938 <pthread_kill+0xac>
              <== NOT EXECUTED
4000f8b4:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
    return ESRCH;
                                                    
  }
                                                                  

                                                                     
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              

                                                                     
  if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
       
4000f8b8:	83 2e 60 01 	sll  %i1, 1, %g1
                              <== NOT EXECUTED
4000f8bc:	82 00 40 19 	add  %g1, %i1, %g1
                            <== NOT EXECUTED
4000f8c0:	85 28 60 02 	sll  %g1, 2, %g2
                              <== NOT EXECUTED
4000f8c4:	03 10 00 53 	sethi  %hi(0x40014c00), %g1
                   <== NOT EXECUTED
4000f8c8:	82 10 63 90 	or  %g1, 0x390, %g1	! 40014f90 <_POSIX_signals_Vectors>
<== NOT EXECUTED
4000f8cc:	82 00 40 02 	add  %g1, %g2, %g1
                            <== NOT EXECUTED
4000f8d0:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1
                          <== NOT EXECUTED
4000f8d4:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4000f8d8:	02 80 00 24 	be  4000f968 <pthread_kill+0xdc>
              <== NOT EXECUTED
4000f8dc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
4000f8e0:	c8 00 e1 5c 	ld  [ %g3 + 0x15c ], %g4
                      <== NOT EXECUTED
    return 0;
                                                        
  }
                                                                  

                                                                     
  /* XXX critical section */
                                         

                                                                     
  api->signals_pending |= signo_to_mask( sig );
                      
4000f8e4:	c4 01 20 6c 	ld  [ %g4 + 0x6c ], %g2
                       <== NOT EXECUTED
  disable_level = cpu_self->thread_dispatch_disable_level;
           
4000f8e8:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       <== NOT EXECUTED
  return 1u << (sig - 1);
                                            
4000f8ec:	86 10 20 01 	mov  1, %g3
                                   <== NOT EXECUTED
4000f8f0:	bb 28 c0 1d 	sll  %g3, %i5, %i5
                            <== NOT EXECUTED
4000f8f4:	ba 10 80 1d 	or  %g2, %i5, %i5
                             <== NOT EXECUTED
4000f8f8:	fa 21 20 6c 	st  %i5, [ %g4 + 0x6c ]
                       <== NOT EXECUTED
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
4000f8fc:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
  return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );

4000f900:	b8 10 00 06 	mov  %g6, %i4
                                 <== NOT EXECUTED
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
4000f904:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000f908:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f90c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f910:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
  cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
     
  _ISR_lock_ISR_enable( &lock_context );
                             

                                                                     
  (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
     
4000f914:	94 10 20 00 	clr  %o2	! 0 <PROM_START>
                     <== NOT EXECUTED
4000f918:	7f ff fe f9 	call  4000f4fc <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4000f91c:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
4000f920:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1
                       <== NOT EXECUTED
  if ( disable_level == 1 ) {
                                        
4000f924:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4000f928:	02 80 00 06 	be  4000f940 <pthread_kill+0xb4>
              <== NOT EXECUTED
4000f92c:	84 00 7f ff 	add  %g1, -1, %g2
                             <== NOT EXECUTED
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
4000f930:	c4 27 20 18 	st  %g2, [ %i4 + 0x18 ]
                       <== NOT EXECUTED
  _Thread_Dispatch_enable( cpu_self );
                               
  return 0;
                                                          
4000f934:	82 10 20 00 	clr  %g1
                                      <== NOT EXECUTED
}
                                                                    
4000f938:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f93c:	91 e8 00 01 	restore  %g0, %g1, %o0
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000f940:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
4000f944:	c4 0f 20 1c 	ldub  [ %i4 + 0x1c ], %g2
                     <== NOT EXECUTED
4000f948:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4000f94c:	12 80 00 0d 	bne  4000f980 <pthread_kill+0xf4>
             <== NOT EXECUTED
4000f950:	92 10 00 01 	mov  %g1, %o1
                                 <== NOT EXECUTED
      cpu_self->thread_dispatch_disable_level = 0;
                   
4000f954:	c0 27 20 18 	clr  [ %i4 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f958:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f95c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  return 0;
                                                          
4000f960:	10 bf ff f6 	b  4000f938 <pthread_kill+0xac>
               <== NOT EXECUTED
4000f964:	82 10 20 00 	clr  %g1	! 0 <PROM_START>
                     <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000f968:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000f96c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000f970:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    return 0;
                                                        
4000f974:	82 10 20 00 	clr  %g1	! 0 <PROM_START>
                     <== NOT EXECUTED
}
                                                                    
4000f978:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f97c:	91 e8 00 01 	restore  %g0, %g1, %o0
                        <== NOT EXECUTED
      _Thread_Do_dispatch( cpu_self, level );
                        
4000f980:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]
                        <== NOT EXECUTED
4000f984:	7f ff fc 0e 	call  4000e9bc <_Thread_Do_dispatch>
          <== NOT EXECUTED
4000f988:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
4000f98c:	10 bf ff f3 	b  4000f958 <pthread_kill+0xcc>
               <== NOT EXECUTED
4000f990:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1
                        <== NOT EXECUTED

                                                                     
===============================================================================
40005d1c <pthread_mutex_destroy>:
                                    
 */
                                                                  

                                                                     
int pthread_mutex_destroy(
                                           
  pthread_mutex_t           *mutex
                                   
)
                                                                    
{
                                                                    
40005d1c:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  unsigned long         flags;
                                       
  Thread_queue_Context  queue_context;
                               
  int                   eno;
                                         

                                                                     
  the_mutex = _POSIX_Mutex_Get( mutex );
                             
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
40005d20:	80 a6 20 00 	cmp  %i0, 0
                                   
40005d24:	02 80 00 18 	be  40005d84 <pthread_mutex_destroy+0x68>
     <== NEVER TAKEN
40005d28:	05 25 87 04 	sethi  %hi(0x961c1000), %g2
                   
40005d2c:	c2 06 00 00 	ld  [ %i0 ], %g1
                              
40005d30:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40005d34:	84 10 a3 b8 	or  %g2, 0x3b8, %g2
                           
40005d38:	82 18 40 02 	xor  %g1, %g2, %g1
                            
40005d3c:	80 88 7f f8 	btst  -8, %g1
                                 
40005d40:	12 80 00 0c 	bne  40005d70 <pthread_mutex_destroy+0x54>
    <== NEVER TAKEN
40005d44:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005d48:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
  _POSIX_Mutex_Acquire( the_mutex, &queue_context );
                 

                                                                     
  if ( _POSIX_Mutex_Get_owner( the_mutex ) == NULL ) {
               
40005d4c:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2
                       
40005d50:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005d54:	22 80 00 0e 	be,a   40005d8c <pthread_mutex_destroy+0x70>
  <== ALWAYS TAKEN
40005d58:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
    the_mutex->flags = ~the_mutex->flags;
                            
    eno = 0;
                                                         
  } else {
                                                           
    eno = EBUSY;
                                                     
40005d5c:	b0 10 20 10 	mov  0x10, %i0
                                <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005d60:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005d64:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  }
                                                                  

                                                                     
  _POSIX_Mutex_Release( the_mutex, &queue_context );
                 
  return eno;
                                                        
}
                                                                    
40005d68:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005d6c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
40005d70:	40 00 00 61 	call  40005ef4 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40005d74:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40005d78:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40005d7c:	12 bf ff f3 	bne  40005d48 <pthread_mutex_destroy+0x2c>
    <== NOT EXECUTED
40005d80:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40005d84:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005d88:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
    the_mutex->flags = ~the_mutex->flags;
                            
40005d8c:	84 38 00 02 	xnor  %g0, %g2, %g2
                           <== NOT EXECUTED
40005d90:	c4 26 00 00 	st  %g2, [ %i0 ]
                              <== NOT EXECUTED
    eno = 0;
                                                         
40005d94:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
40005d98:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005d9c:	01 00 00 00 	nop 
                                          
}
                                                                    
40005da0:	81 c7 e0 08 	ret 
                                          
40005da4:	81 e8 00 00 	restore 
                                      

                                                                     
===============================================================================
40005e6c <pthread_mutex_getprioceiling>:
                             
#else
                                                                
  pthread_mutex_t       *mutex,
                                      
#endif
                                                               
  int                   *prioceiling
                                 
)
                                                                    
{
                                                                    
40005e6c:	9d e3 bf 98 	save  %sp, -104, %sp
                          
  if ( prioceiling == NULL ) {
                                       
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  the_mutex = _POSIX_Mutex_Get( RTEMS_DECONST( pthread_mutex_t *, mutex ) );

  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
40005e70:	80 a6 60 00 	cmp  %i1, 0
                                   
40005e74:	02 80 00 1a 	be  40005edc <pthread_mutex_getprioceiling+0x70>
<== NEVER TAKEN
40005e78:	80 a6 20 00 	cmp  %i0, 0
                                   
40005e7c:	02 80 00 18 	be  40005edc <pthread_mutex_getprioceiling+0x70>
<== NEVER TAKEN
40005e80:	05 25 87 04 	sethi  %hi(0x961c1000), %g2
                   
40005e84:	fa 06 00 00 	ld  [ %i0 ], %i5
                              
40005e88:	82 1e 00 1d 	xor  %i0, %i5, %g1
                            
40005e8c:	84 10 a3 b8 	or  %g2, 0x3b8, %g2
                           
40005e90:	82 18 40 02 	xor  %g1, %g2, %g1
                            
40005e94:	80 88 7f f8 	btst  -8, %g1
                                 
40005e98:	12 80 00 0c 	bne  40005ec8 <pthread_mutex_getprioceiling+0x5c>
<== NEVER TAKEN
40005e9c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005ea0:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
RTEMS_INLINE_ROUTINE POSIX_Mutex_Protocol _POSIX_Mutex_Get_protocol(
 
  unsigned long flags
                                                
)
                                                                    
{
                                                                    
  return flags & POSIX_MUTEX_PROTOCOL_MASK;
                          
40005ea4:	ba 0f 60 03 	and  %i5, 3, %i5
                              

                                                                     
  _POSIX_Mutex_Acquire( the_mutex, &queue_context );
                 

                                                                     
  if ( _POSIX_Mutex_Get_protocol( flags ) == POSIX_MUTEX_PRIORITY_CEILING ) {

40005ea8:	80 a7 60 02 	cmp  %i5, 2
                                   
40005eac:	22 80 00 0e 	be,a   40005ee4 <pthread_mutex_getprioceiling+0x78>
<== NEVER TAKEN
40005eb0:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1
                       <== NOT EXECUTED
    *prioceiling = _POSIX_Priority_From_core(
                        
      _POSIX_Mutex_Get_scheduler( the_mutex ),
                       
      _POSIX_Mutex_Get_priority( the_mutex )
                         
    );
                                                               
  } else {
                                                           
    *prioceiling = 0;
                                                
40005eb4:	c0 26 40 00 	clr  [ %i1 ]
                                  <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005eb8:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005ebc:	01 00 00 00 	nop 
                                          
  }
                                                                  

                                                                     
  _POSIX_Mutex_Release( the_mutex, &queue_context );
                 
  return 0;
                                                          
}
                                                                    
40005ec0:	81 c7 e0 08 	ret 
                                          
40005ec4:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
40005ec8:	40 00 00 b8 	call  400061a8 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40005ecc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40005ed0:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40005ed4:	12 bf ff f3 	bne  40005ea0 <pthread_mutex_getprioceiling+0x34>
<== NOT EXECUTED
40005ed8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40005edc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005ee0:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
    *prioceiling = _POSIX_Priority_From_core(
                        
40005ee4:	d4 06 20 34 	ld  [ %i0 + 0x34 ], %o2
                       <== NOT EXECUTED
40005ee8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         <== NOT EXECUTED
40005eec:	11 10 00 3f 	sethi  %hi(0x4000fc00), %o0
                   <== NOT EXECUTED
40005ef0:	40 00 01 84 	call  40006500 <_POSIX_Priority_From_core>
    <== NOT EXECUTED
40005ef4:	90 12 21 58 	or  %o0, 0x158, %o0	! 4000fd58 <_Scheduler_Table>
<== NOT EXECUTED
40005ef8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
40005efc:	d0 26 40 00 	st  %o0, [ %i1 ]
                              <== NOT EXECUTED
40005f00:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005f04:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
}
                                                                    
40005f08:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005f0c:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED

                                                                     
===============================================================================
40006174 <pthread_mutex_init>:
                                       

                                                                     
int pthread_mutex_init(
                                              
  pthread_mutex_t           *mutex,
                                  
  const pthread_mutexattr_t *attr
                                    
)
                                                                    
{
                                                                    
40006174:	9d e3 bf 98 	save  %sp, -104, %sp
                          
  POSIX_Mutex_Protocol       protocol;
                               
  unsigned long              flags;
                                  
  Priority_Control           priority;
                               
  const Scheduler_Control   *scheduler;
                              

                                                                     
  if ( attr ) the_attr = attr;
                                       
40006178:	80 a6 60 00 	cmp  %i1, 0
                                   
4000617c:	02 80 00 0f 	be  400061b8 <pthread_mutex_init+0x44>
        <== ALWAYS TAKEN
40006180:	ba 10 00 18 	mov  %i0, %i5
                                 
  else        the_attr = &_POSIX_Mutex_Default_attributes;
           

                                                                     
  /* Check for NULL mutex */
                                         
  if ( !mutex )
                                                      
40006184:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
40006188:	02 80 00 44 	be  40006298 <pthread_mutex_init+0x124>
       <== NOT EXECUTED
4000618c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
   *  value in an uninitialized variable to make this fail.
          
   *
                                                                 
   *  Thus, we do not look at *mutex.
                                
   */
                                                                

                                                                     
  if ( !the_attr->is_initialized )
                                   
40006190:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
40006194:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006198:	02 80 00 06 	be  400061b0 <pthread_mutex_init+0x3c>
        <== NOT EXECUTED
4000619c:	b0 10 20 16 	mov  0x16, %i0
                                <== NOT EXECUTED
    return EINVAL;
                                                   

                                                                     
  if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) {
      
400061a0:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1
                          <== NOT EXECUTED
400061a4:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
400061a8:	28 80 00 16 	bleu,a   40006200 <pthread_mutex_init+0x8c>
   <== NOT EXECUTED
400061ac:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1
                        <== NOT EXECUTED
  );
                                                                 
  the_mutex->Recursive.nest_level = 0;
                               
  _Priority_Node_initialize( &the_mutex->Priority_ceiling, priority );

  the_mutex->scheduler = scheduler;
                                  
  return 0;
                                                          
}
                                                                    
400061b0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400061b4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  if ( !mutex )
                                                      
400061b8:	80 a6 20 00 	cmp  %i0, 0
                                   
400061bc:	02 80 00 37 	be  40006298 <pthread_mutex_init+0x124>
       <== NEVER TAKEN
400061c0:	03 25 87 04 	sethi  %hi(0x961c1000), %g1
                   
  flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
                 
400061c4:	82 10 63 b8 	or  %g1, 0x3b8, %g1	! 961c13b8 <RAM_END+0x55dc13b8>

400061c8:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
  flags &= ~POSIX_MUTEX_FLAGS_MASK;
                                  
400061cc:	82 08 7f f8 	and  %g1, -8, %g1
                             
  the_mutex->flags = flags;
                                          
400061d0:	c2 26 00 00 	st  %g1, [ %i0 ]
                              
    scheduler = NULL;
                                                
400061d4:	84 10 20 00 	clr  %g2
                                      
    priority = 0;
                                                    
400061d8:	90 10 20 00 	clr  %o0
                                      
400061dc:	92 10 20 00 	clr  %o1
                                      
  queue->heads = NULL;
                                               
400061e0:	c0 27 60 0c 	clr  [ %i5 + 0xc ]
                            
  queue->owner = NULL;
                                               
400061e4:	c0 27 60 10 	clr  [ %i5 + 0x10 ]
                           
  queue->name = name;
                                                
400061e8:	c0 27 60 14 	clr  [ %i5 + 0x14 ]
                           
  the_mutex->Recursive.nest_level = 0;
                               
400061ec:	c0 27 60 18 	clr  [ %i5 + 0x18 ]
                           
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
                 
  Priority_Node    *node,
                                            
  Priority_Control  priority
                                         
)
                                                                    
{
                                                                    
  node->priority = priority;
                                         
400061f0:	d0 3f 60 30 	std  %o0, [ %i5 + 0x30 ]
                      
  the_mutex->scheduler = scheduler;
                                  
400061f4:	c4 27 60 38 	st  %g2, [ %i5 + 0x38 ]
                       
  return 0;
                                                          
400061f8:	81 c7 e0 08 	ret 
                                          
400061fc:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  switch ( the_attr->protocol ) {
                                    
40006200:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
40006204:	02 80 00 27 	be  400062a0 <pthread_mutex_init+0x12c>
       <== NOT EXECUTED
40006208:	80 a0 60 02 	cmp  %g1, 2
                                   <== NOT EXECUTED
4000620c:	02 80 00 27 	be  400062a8 <pthread_mutex_init+0x134>
       <== NOT EXECUTED
40006210:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006214:	12 bf ff e7 	bne  400061b0 <pthread_mutex_init+0x3c>
       <== NOT EXECUTED
40006218:	84 10 20 00 	clr  %g2
                                      <== NOT EXECUTED
  switch ( the_attr->type ) {
                                        
4000621c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1
                       <== NOT EXECUTED
40006220:	80 a0 60 03 	cmp  %g1, 3
                                   <== NOT EXECUTED
40006224:	18 bf ff e3 	bgu  400061b0 <pthread_mutex_init+0x3c>
       <== NOT EXECUTED
40006228:	b0 10 20 16 	mov  0x16, %i0
                                <== NOT EXECUTED
  if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
                 
4000622c:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
  flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
                 
40006230:	03 25 87 04 	sethi  %hi(0x961c1000), %g1
                   <== NOT EXECUTED
40006234:	82 10 63 b8 	or  %g1, 0x3b8, %g1	! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40006238:	82 1f 40 01 	xor  %i5, %g1, %g1
                            <== NOT EXECUTED
  flags &= ~POSIX_MUTEX_FLAGS_MASK;
                                  
4000623c:	82 08 7f f8 	and  %g1, -8, %g1
                             <== NOT EXECUTED
  if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
                 
40006240:	12 80 00 03 	bne  4000624c <pthread_mutex_init+0xd8>
       <== NOT EXECUTED
40006244:	82 10 80 01 	or  %g2, %g1, %g1
                             <== NOT EXECUTED
    flags |= POSIX_MUTEX_RECURSIVE;
                                  
40006248:	82 10 60 04 	or  %g1, 4, %g1
                               <== NOT EXECUTED
  if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) {
                  
4000624c:	80 a0 a0 02 	cmp  %g2, 2
                                   <== NOT EXECUTED
40006250:	12 80 00 18 	bne  400062b0 <pthread_mutex_init+0x13c>
      <== NOT EXECUTED
40006254:	c2 27 40 00 	st  %g1, [ %i5 ]
                              <== NOT EXECUTED
    prio_ceiling = the_attr->prio_ceiling;
                           
40006258:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1
                          <== NOT EXECUTED
    if ( prio_ceiling == INT_MAX ) {
                                 
4000625c:	03 1f ff ff 	sethi  %hi(0x7ffffc00), %g1
                   <== NOT EXECUTED
40006260:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! 7fffffff <RAM_END+0x3fbfffff>
<== NOT EXECUTED
40006264:	80 a2 40 01 	cmp  %o1, %g1
                                 <== NOT EXECUTED
40006268:	12 80 00 05 	bne  4000627c <pthread_mutex_init+0x108>
      <== NOT EXECUTED
4000626c:	39 10 00 40 	sethi  %hi(0x40010000), %i4
                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
                
  const Scheduler_Control *scheduler
                                 
)
                                                                    
{
                                                                    
  _Assert( (int) scheduler->maximum_priority > 1 );
                  
  return (int) scheduler->maximum_priority - 1;
                      
40006270:	82 17 23 a0 	or  %i4, 0x3a0, %g1	! 400103a0 <_Scheduler_Table>
<== NOT EXECUTED
40006274:	d2 00 60 44 	ld  [ %g1 + 0x44 ], %o1
                       <== NOT EXECUTED
40006278:	92 02 7f ff 	add  %o1, -1, %o1
                             <== NOT EXECUTED
    priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid );

4000627c:	94 07 bf ff 	add  %fp, -1, %o2
                             <== NOT EXECUTED
40006280:	40 00 01 75 	call  40006854 <_POSIX_Priority_To_core>
      <== NOT EXECUTED
40006284:	90 17 23 a0 	or  %i4, 0x3a0, %o0
                           <== NOT EXECUTED
    if ( !valid ) {
                                                  
40006288:	c2 0f bf ff 	ldub  [ %fp + -1 ], %g1
                       <== NOT EXECUTED
4000628c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006290:	12 bf ff d4 	bne  400061e0 <pthread_mutex_init+0x6c>
       <== NOT EXECUTED
40006294:	84 17 23 a0 	or  %i4, 0x3a0, %g2
                           <== NOT EXECUTED
    return EINVAL;
                                                   
40006298:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000629c:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
      protocol = POSIX_MUTEX_PRIORITY_INHERIT;
                       
400062a0:	10 bf ff df 	b  4000621c <pthread_mutex_init+0xa8>
         <== NOT EXECUTED
400062a4:	84 10 20 01 	mov  1, %g2
                                   <== NOT EXECUTED
      break;
                                                         
400062a8:	10 bf ff dd 	b  4000621c <pthread_mutex_init+0xa8>
         <== NOT EXECUTED
400062ac:	84 10 20 02 	mov  2, %g2
                                   <== NOT EXECUTED
    scheduler = NULL;
                                                
400062b0:	84 10 20 00 	clr  %g2
                                      <== NOT EXECUTED
    priority = 0;
                                                    
400062b4:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
400062b8:	10 bf ff ca 	b  400061e0 <pthread_mutex_init+0x6c>
         <== NOT EXECUTED
400062bc:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000605c <pthread_mutex_setprioceiling>:
                             
int pthread_mutex_setprioceiling(
                                    
  pthread_mutex_t   *mutex,
                                          
  int                prioceiling,
                                    
  int               *old_ceiling
                                     
)
                                                                    
{
                                                                    
4000605c:	9d e3 bf 70 	save  %sp, -144, %sp
                          
  POSIX_Mutex_Control *the_mutex;
                                    
  int                  error;
                                        
  int                  unlock_error;
                                 

                                                                     
  if ( old_ceiling == NULL ) {
                                       
40006060:	80 a6 a0 00 	cmp  %i2, 0
                                   
40006064:	02 80 00 12 	be  400060ac <pthread_mutex_setprioceiling+0x50>
<== NEVER TAKEN
40006068:	ba 10 20 16 	mov  0x16, %i5
                                

                                                                     
  /*
                                                                 
   *  Must acquire the mutex before we can change it's ceiling.
      
   *  POSIX says block until we acquire it.
                          
   */
                                                                
  error = pthread_mutex_lock( mutex );
                               
4000606c:	40 00 1b 64 	call  4000cdfc <pthread_mutex_lock>
           
40006070:	90 10 00 18 	mov  %i0, %o0
                                 
  if ( error != 0 ) {
                                                
40006074:	ba 92 20 00 	orcc  %o0, 0, %i5
                             
40006078:	32 80 00 0d 	bne,a   400060ac <pthread_mutex_setprioceiling+0x50>
<== NEVER TAKEN
4000607c:	ba 10 20 16 	mov  0x16, %i5
                                <== NOT EXECUTED
40006080:	c2 06 00 00 	ld  [ %i0 ], %g1
                              
40006084:	82 08 60 03 	and  %g1, 3, %g1
                              
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  the_mutex = _POSIX_Mutex_Get( mutex );
                             

                                                                     
  if (
                                                               
40006088:	80 a0 60 02 	cmp  %g1, 2
                                   
4000608c:	22 80 00 0a 	be,a   400060b4 <pthread_mutex_setprioceiling+0x58>
<== NEVER TAKEN
40006090:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1
                       <== NOT EXECUTED
      error = 0;
                                                     
    } else {
                                                         
      error = EINVAL;
                                                
    }
                                                                
  } else {
                                                           
    *old_ceiling = 0;
                                                
40006094:	c0 26 80 00 	clr  [ %i2 ]
                                  
    error = 0;
                                                       
  }
                                                                  

                                                                     
  unlock_error = pthread_mutex_unlock( mutex );
                      
40006098:	90 10 00 18 	mov  %i0, %o0
                                 
4000609c:	40 00 00 6a 	call  40006244 <pthread_mutex_unlock>
         
400060a0:	b0 10 00 1d 	mov  %i5, %i0
                                 
  _Assert( unlock_error == 0 );
                                      
  (void) unlock_error;
                                               
  return error;
                                                      
}
                                                                    
400060a4:	81 c7 e0 08 	ret 
                                          
400060a8:	81 e8 00 00 	restore 
                                      
400060ac:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060b0:	91 e8 00 1d 	restore  %g0, %i5, %o0
                        <== NOT EXECUTED
    *old_ceiling = _POSIX_Priority_From_core( scheduler, old_priority );

400060b4:	d4 06 20 34 	ld  [ %i0 + 0x34 ], %o2
                       <== NOT EXECUTED
400060b8:	39 10 00 3f 	sethi  %hi(0x4000fc00), %i4
                   <== NOT EXECUTED
400060bc:	40 00 01 11 	call  40006500 <_POSIX_Priority_From_core>
    <== NOT EXECUTED
400060c0:	90 17 21 58 	or  %i4, 0x158, %o0	! 4000fd58 <_Scheduler_Table>
<== NOT EXECUTED
400060c4:	d0 26 80 00 	st  %o0, [ %i2 ]
                              <== NOT EXECUTED
    new_priority = _POSIX_Priority_To_core( scheduler, prioceiling, &valid );

400060c8:	94 07 bf db 	add  %fp, -37, %o2
                            <== NOT EXECUTED
400060cc:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
400060d0:	40 00 00 ef 	call  4000648c <_POSIX_Priority_To_core>
      <== NOT EXECUTED
400060d4:	90 17 21 58 	or  %i4, 0x158, %o0
                           <== NOT EXECUTED
    if ( valid ) {
                                                   
400060d8:	c2 0f bf db 	ldub  [ %fp + -37 ], %g1
                      <== NOT EXECUTED
400060dc:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
400060e0:	32 80 00 04 	bne,a   400060f0 <pthread_mutex_setprioceiling+0x94>
<== NOT EXECUTED
400060e4:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
      error = EINVAL;
                                                
400060e8:	10 bf ff ec 	b  40006098 <pthread_mutex_setprioceiling+0x3c>
<== NOT EXECUTED
400060ec:	ba 10 20 16 	mov  0x16, %i5
                                <== NOT EXECUTED
400060f0:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2
                       <== NOT EXECUTED
{
                                                                    
  Thread_Control *owner;
                                             

                                                                     
  owner = _POSIX_Mutex_Get_owner( the_mutex );
                       

                                                                     
  if ( owner != NULL ) {
                                             
400060f4:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
400060f8:	22 80 00 1b 	be,a   40006164 <pthread_mutex_setprioceiling+0x108>
<== NOT EXECUTED
400060fc:	d0 3e 20 30 	std  %o0, [ %i0 + 0x30 ]
                      <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006100:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire(
                      
  Thread_Control       *the_thread,
                                  
  Thread_queue_Context *queue_context
                                
)
                                                                    
{
                                                                    
  _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );

40006104:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority(
               
  Priority_Node    *node,
                                            
  Priority_Control  priority
                                         
)
                                                                    
{
                                                                    
  node->priority = priority;
                                         
40006108:	d0 3e 20 30 	std  %o0, [ %i0 + 0x30 ]
                      <== NOT EXECUTED
  _Thread_Priority_changed(
                                          
4000610c:	b6 07 bf dc 	add  %fp, -36, %i3
                            <== NOT EXECUTED
40006110:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
40006114:	96 10 00 1b 	mov  %i3, %o3
                                 <== NOT EXECUTED
40006118:	92 06 20 20 	add  %i0, 0x20, %o1
                           <== NOT EXECUTED
4000611c:	40 00 0d cc 	call  4000984c <_Thread_Priority_changed>
     <== NOT EXECUTED
40006120:	90 10 00 02 	mov  %g2, %o0
                                 <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006124:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006128:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000612c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  const ISR_lock_Context *lock_context
                               
)
                                                                    
{
                                                                    
  uint32_t disable_level;
                                            

                                                                     
  disable_level = cpu_self->thread_dispatch_disable_level;
           
40006130:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       <== NOT EXECUTED
  _Profiling_Thread_dispatch_disable_critical(
                       
    cpu_self,
                                                        
    disable_level,
                                                   
    lock_context
                                                     
  );
                                                                 
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
40006134:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
40006138:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       <== NOT EXECUTED
 */
                                                                  
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(

  const ISR_lock_Context *lock_context
                               
)
                                                                    
{
                                                                    
  return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );

4000613c:	b8 10 00 06 	mov  %g6, %i4
                                 <== NOT EXECUTED
      _Thread_Priority_update( &queue_context );
                     
40006140:	40 00 0d ca 	call  40009868 <_Thread_Priority_update>
      <== NOT EXECUTED
40006144:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
 *
                                                                   
 * @param[in] cpu_self The current processor.
                        
 */
                                                                  
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )

{
                                                                    
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
40006148:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1
                       <== NOT EXECUTED

                                                                     
  if ( disable_level == 1 ) {
                                        
4000614c:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
40006150:	02 80 00 07 	be  4000616c <pthread_mutex_setprioceiling+0x110>
<== NOT EXECUTED
40006154:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    }
                                                                

                                                                     
    _ISR_Local_enable( level );
                                      
  } else {
                                                           
    _Assert( disable_level > 0 );
                                    
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
40006158:	c2 27 20 18 	st  %g1, [ %i4 + 0x18 ]
                       <== NOT EXECUTED
  unlock_error = pthread_mutex_unlock( mutex );
                      
4000615c:	10 bf ff d0 	b  4000609c <pthread_mutex_setprioceiling+0x40>
<== NOT EXECUTED
40006160:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006164:	10 bf ff f3 	b  40006130 <pthread_mutex_setprioceiling+0xd4>
<== NOT EXECUTED
40006168:	b6 07 bf dc 	add  %fp, -36, %i3
                            <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000616c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
40006170:	c4 0f 20 1c 	ldub  [ %i4 + 0x1c ], %g2
                     <== NOT EXECUTED
40006174:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40006178:	12 80 00 07 	bne  40006194 <pthread_mutex_setprioceiling+0x138>
<== NOT EXECUTED
4000617c:	92 10 00 01 	mov  %g1, %o1
                                 <== NOT EXECUTED
      cpu_self->thread_dispatch_disable_level = 0;
                   
40006180:	c0 27 20 18 	clr  [ %i4 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006184:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006188:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000618c:	10 bf ff c4 	b  4000609c <pthread_mutex_setprioceiling+0x40>
<== NOT EXECUTED
40006190:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
      _Thread_Do_dispatch( cpu_self, level );
                        
40006194:	c2 27 bf d4 	st  %g1, [ %fp + -44 ]
                        <== NOT EXECUTED
40006198:	40 00 0e 10 	call  400099d8 <_Thread_Do_dispatch>
          <== NOT EXECUTED
4000619c:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
400061a0:	10 bf ff f9 	b  40006184 <pthread_mutex_setprioceiling+0x128>
<== NOT EXECUTED
400061a4:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1
                        <== NOT EXECUTED

                                                                     
===============================================================================
4000660c <pthread_mutex_unlock>:
                                     
 */
                                                                  

                                                                     
int pthread_mutex_unlock(
                                            
  pthread_mutex_t           *mutex
                                   
)
                                                                    
{
                                                                    
4000660c:	9d e3 bf 70 	save  %sp, -144, %sp
                          
  Thread_queue_Context  queue_context;
                               
  Thread_Control       *executing;
                                   
  Status_Control        status;
                                      

                                                                     
  the_mutex = _POSIX_Mutex_Get( mutex );
                             
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
40006610:	80 a6 20 00 	cmp  %i0, 0
                                   
40006614:	02 80 00 32 	be  400066dc <pthread_mutex_unlock+0xd0>
      <== NEVER TAKEN
40006618:	05 25 87 04 	sethi  %hi(0x961c1000), %g2
                   
4000661c:	fa 06 00 00 	ld  [ %i0 ], %i5
                              
40006620:	82 1e 00 1d 	xor  %i0, %i5, %g1
                            
40006624:	84 10 a3 b8 	or  %g2, 0x3b8, %g2
                           
40006628:	82 18 40 02 	xor  %g1, %g2, %g1
                            
4000662c:	80 88 7f f8 	btst  -8, %g1
                                 
40006630:	12 80 00 26 	bne  400066c8 <pthread_mutex_unlock+0xbc>
     <== NEVER TAKEN
40006634:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006638:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
4000663c:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]
                        

                                                                     
  executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
     

                                                                     
  switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
                    
40006640:	ba 8f 60 03 	andcc  %i5, 3, %i5
                            
40006644:	02 80 00 28 	be  400066e4 <pthread_mutex_unlock+0xd8>
      <== ALWAYS TAKEN
40006648:	d0 01 a0 20 	ld  [ %g6 + 0x20 ], %o0
                       
4000664c:	80 a7 60 02 	cmp  %i5, 2
                                   <== NOT EXECUTED
40006650:	12 80 00 0a 	bne  40006678 <pthread_mutex_unlock+0x6c>
     <== NOT EXECUTED
40006654:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1
                       <== NOT EXECUTED
  unsigned int        nest_level;
                                    
  ISR_lock_Context    lock_context;
                                  
  Per_CPU_Control    *cpu_self;
                                      
  Thread_queue_Heads *heads;
                                         

                                                                     
  if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
            
40006658:	80 a2 00 01 	cmp  %o0, %g1
                                 <== NOT EXECUTED
4000665c:	22 80 00 37 	be,a   40006738 <pthread_mutex_unlock+0x12c>
  <== NOT EXECUTED
40006660:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006664:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006668:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000666c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006670:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006674:	91 e8 20 01 	restore  %g0, 1, %o0
                          <== NOT EXECUTED
  if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
            
40006678:	80 a2 00 01 	cmp  %o0, %g1
                                 <== NOT EXECUTED
4000667c:	12 bf ff fa 	bne  40006664 <pthread_mutex_unlock+0x58>
     <== NOT EXECUTED
40006680:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  nest_level = the_mutex->Recursive.nest_level;
                      
40006684:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       <== NOT EXECUTED
  if ( nest_level > 0 ) {
                                            
40006688:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4000668c:	12 80 00 2e 	bne  40006744 <pthread_mutex_unlock+0x138>
    <== NOT EXECUTED
40006690:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
  the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
              
40006694:	c0 26 20 10 	clr  [ %i0 + 0x10 ]
                           <== NOT EXECUTED
  heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
              
40006698:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1
                        <== NOT EXECUTED
  if ( heads == NULL ) {
                                             
4000669c:	80 a2 60 00 	cmp  %o1, 0
                                   <== NOT EXECUTED
400066a0:	02 80 00 2f 	be  4000675c <pthread_mutex_unlock+0x150>
     <== NOT EXECUTED
400066a4:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
  _Thread_queue_Surrender(
                                           
400066a8:	96 07 bf dc 	add  %fp, -36, %o3
                            <== NOT EXECUTED
400066ac:	90 06 20 0c 	add  %i0, 0xc, %o0
                            <== NOT EXECUTED
400066b0:	19 10 00 42 	sethi  %hi(0x40010800), %o4
                   <== NOT EXECUTED
400066b4:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
400066b8:	40 00 13 1a 	call  4000b320 <_Thread_queue_Surrender>
      <== NOT EXECUTED
400066bc:	98 13 20 e4 	or  %o4, 0xe4, %o4
                            <== NOT EXECUTED
      );
                                                             
      break;
                                                         
  }
                                                                  

                                                                     
  return _POSIX_Get_error( status );
                                 
}
                                                                    
400066c0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400066c4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
                   
400066c8:	7f ff ff aa 	call  40006570 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
400066cc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400066d0:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400066d4:	12 bf ff d9 	bne  40006638 <pthread_mutex_unlock+0x2c>
     <== NOT EXECUTED
400066d8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
400066dc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400066e0:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED
  if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
            
400066e4:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1
                       
400066e8:	80 a2 00 01 	cmp  %o0, %g1
                                 
400066ec:	12 bf ff de 	bne  40006664 <pthread_mutex_unlock+0x58>
     <== NEVER TAKEN
400066f0:	01 00 00 00 	nop 
                                          
  nest_level = the_mutex->Recursive.nest_level;
                      
400066f4:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       
  if ( nest_level > 0 ) {
                                            
400066f8:	80 a0 60 00 	cmp  %g1, 0
                                   
400066fc:	12 80 00 12 	bne  40006744 <pthread_mutex_unlock+0x138>
    <== NEVER TAKEN
40006700:	82 00 7f ff 	add  %g1, -1, %g1
                             
  the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
              
40006704:	c0 26 20 10 	clr  [ %i0 + 0x10 ]
                           
  heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
              
40006708:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1
                        
  if ( heads == NULL ) {
                                             
4000670c:	80 a2 60 00 	cmp  %o1, 0
                                   
40006710:	02 80 00 13 	be  4000675c <pthread_mutex_unlock+0x150>
     
40006714:	94 10 00 08 	mov  %o0, %o2
                                 
  _Thread_queue_Surrender(
                                           
40006718:	96 07 bf dc 	add  %fp, -36, %o3
                            
4000671c:	90 06 20 0c 	add  %i0, 0xc, %o0
                            
40006720:	19 10 00 42 	sethi  %hi(0x40010800), %o4
                   
40006724:	b0 10 20 00 	clr  %i0
                                      
40006728:	40 00 12 fe 	call  4000b320 <_Thread_queue_Surrender>
      
4000672c:	98 13 21 0c 	or  %o4, 0x10c, %o4
                           
40006730:	81 c7 e0 08 	ret 
                                          
40006734:	81 e8 00 00 	restore 
                                      
    return STATUS_NOT_OWNER;
                                         
  }
                                                                  

                                                                     
  nest_level = the_mutex->Recursive.nest_level;
                      

                                                                     
  if ( nest_level > 0 ) {
                                            
40006738:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4000673c:	02 80 00 0d 	be  40006770 <pthread_mutex_unlock+0x164>
     <== NOT EXECUTED
40006740:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    the_mutex->Recursive.nest_level = nest_level - 1;
                
40006744:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006748:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000674c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006750:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006754:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006758:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

4000675c:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006760:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006764:	01 00 00 00 	nop 
                                          
40006768:	81 c7 e0 08 	ret 
                                          
4000676c:	91 e8 20 00 	restore  %g0, 0, %o0
                          
40006770:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED

                                                                     
  _Thread_Resource_count_decrement( executing );
                     

                                                                     
  _Thread_queue_Context_clear_priority_updates( queue_context );
     
  _Thread_Wait_acquire_default_critical( executing, &lock_context );
 
  _Thread_Priority_remove(
                                           
40006774:	b6 06 20 20 	add  %i0, 0x20, %i3
                           <== NOT EXECUTED
40006778:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
4000677c:	40 00 0f f5 	call  4000a750 <_Thread_Priority_remove>
      <== NOT EXECUTED
40006780:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
  disable_level = cpu_self->thread_dispatch_disable_level;
           
40006784:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       <== NOT EXECUTED
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
40006788:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
4000678c:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       <== NOT EXECUTED
  );
                                                                 
  _Thread_Wait_release_default_critical( executing, &lock_context );
 

                                                                     
  cpu_self = _Thread_queue_Dispatch_disable( queue_context );
        

                                                                     
  heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
              
40006790:	d0 06 20 0c 	ld  [ %i0 + 0xc ], %o0
                        <== NOT EXECUTED

                                                                     
  if ( heads != NULL ) {
                                             
40006794:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006798:	02 80 00 2a 	be  40006840 <pthread_mutex_unlock+0x234>
     <== NOT EXECUTED
4000679c:	ba 10 00 06 	mov  %g6, %i5
                                 <== NOT EXECUTED
    const Thread_queue_Operations *operations;
                       
    Thread_Control                *new_owner;
                        

                                                                     
    operations = POSIX_MUTEX_PRIORITY_CEILING_TQ_OPERATIONS;
         
    new_owner = ( *operations->first )( heads );
                     
400067a0:	39 10 00 42 	sethi  %hi(0x40010800), %i4
                   <== NOT EXECUTED
400067a4:	b8 17 20 f8 	or  %i4, 0xf8, %i4	! 400108f8 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400067a8:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1
                       <== NOT EXECUTED
400067ac:	9f c0 40 00 	call  %g1
                                     <== NOT EXECUTED
400067b0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
              
400067b4:	d0 26 20 10 	st  %o0, [ %i0 + 0x10 ]
                       <== NOT EXECUTED
    new_owner = ( *operations->first )( heads );
                     
400067b8:	b4 10 00 08 	mov  %o0, %i2
                                 <== NOT EXECUTED
    _POSIX_Mutex_Set_owner( the_mutex, new_owner );
                  
    _Thread_Resource_count_increment( new_owner );
                   
    _Thread_Priority_add(
                                            
400067bc:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
400067c0:	40 00 0f df 	call  4000a73c <_Thread_Priority_add>
         <== NOT EXECUTED
400067c4:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
      new_owner,
                                                     
      &the_mutex->Priority_ceiling,
                                  
      queue_context
                                                  
    );
                                                               
    _Thread_queue_Extract_critical(
                                  
400067c8:	96 07 bf dc 	add  %fp, -36, %o3
                            <== NOT EXECUTED
400067cc:	94 10 00 1a 	mov  %i2, %o2
                                 <== NOT EXECUTED
400067d0:	92 10 00 1c 	mov  %i4, %o1
                                 <== NOT EXECUTED
400067d4:	40 00 12 92 	call  4000b21c <_Thread_queue_Extract_critical>
<== NOT EXECUTED
400067d8:	90 06 20 0c 	add  %i0, 0xc, %o0
                            <== NOT EXECUTED
  } else {
                                                           
    _POSIX_Mutex_Set_owner( the_mutex, NULL );
                       
    _POSIX_Mutex_Release( the_mutex, queue_context );
                
  }
                                                                  

                                                                     
  _Thread_Priority_update( queue_context );
                          
400067dc:	40 00 0f e9 	call  4000a780 <_Thread_Priority_update>
      <== NOT EXECUTED
400067e0:	90 07 bf dc 	add  %fp, -36, %o0
                            <== NOT EXECUTED
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
400067e4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1
                       <== NOT EXECUTED
  if ( disable_level == 1 ) {
                                        
400067e8:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
400067ec:	02 80 00 06 	be  40006804 <pthread_mutex_unlock+0x1f8>
     <== NOT EXECUTED
400067f0:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
400067f4:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
400067f8:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]
                       <== NOT EXECUTED
400067fc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006800:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006804:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
40006808:	c4 0f 60 1c 	ldub  [ %i5 + 0x1c ], %g2
                     <== NOT EXECUTED
4000680c:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40006810:	12 80 00 07 	bne  4000682c <pthread_mutex_unlock+0x220>
    <== NOT EXECUTED
40006814:	92 10 00 01 	mov  %g1, %o1
                                 <== NOT EXECUTED
      cpu_self->thread_dispatch_disable_level = 0;
                   
40006818:	c0 27 60 18 	clr  [ %i5 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000681c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006820:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006824:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006828:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
      _Thread_Do_dispatch( cpu_self, level );
                        
4000682c:	c2 27 bf d4 	st  %g1, [ %fp + -44 ]
                        <== NOT EXECUTED
40006830:	40 00 10 30 	call  4000a8f0 <_Thread_Do_dispatch>
          <== NOT EXECUTED
40006834:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
40006838:	10 bf ff f9 	b  4000681c <pthread_mutex_unlock+0x210>
      <== NOT EXECUTED
4000683c:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1
                        <== NOT EXECUTED
  the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
              
40006840:	c0 26 20 10 	clr  [ %i0 + 0x10 ]
                           <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40006844:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006848:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000684c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006850:	30 bf ff e3 	b,a   400067dc <pthread_mutex_unlock+0x1d0>
   <== NOT EXECUTED

                                                                     
===============================================================================
40006014 <pthread_rwlock_destroy>:
                                   
#include <rtems/posix/rwlockimpl.h>
                                  

                                                                     
int pthread_rwlock_destroy(
                                          
  pthread_rwlock_t *_rwlock
                                          
)
                                                                    
{
                                                                    
40006014:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               

                                                                     
  the_rwlock = _POSIX_RWLock_Get( _rwlock );
                         
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006018:	80 a6 20 00 	cmp  %i0, 0
                                   
4000601c:	02 80 00 16 	be  40006074 <pthread_rwlock_destroy+0x60>
    <== NEVER TAKEN
40006020:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
40006024:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40006028:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
4000602c:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006030:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006034:	12 80 00 0b 	bne  40006060 <pthread_rwlock_destroy+0x4c>
   <== NEVER TAKEN
40006038:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

4000603c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
  /*
                                                                 
   *  If there is at least one thread waiting, then do not delete it.

   */
                                                                

                                                                     
  if ( !_Thread_queue_Is_empty( &the_rwlock->RWLock.Queue.Queue ) ) {

40006040:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2
                        
40006044:	80 a0 a0 00 	cmp  %g2, 0
                                   
40006048:	22 80 00 0d 	be,a   4000607c <pthread_rwlock_destroy+0x68>
 <== ALWAYS TAKEN
4000604c:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006050:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006054:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    _CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context );
     
    return EBUSY;
                                                    
40006058:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000605c:	91 e8 20 10 	restore  %g0, 0x10, %o0
                       <== NOT EXECUTED
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006060:	40 00 00 a4 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
40006064:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006068:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000606c:	12 bf ff f4 	bne  4000603c <pthread_rwlock_destroy+0x28>
   <== NOT EXECUTED
40006070:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006074:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006078:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
  /*
                                                                 
   *  POSIX doesn't require behavior when it is locked.
              
   */
                                                                

                                                                     
  the_rwlock->flags = ~the_rwlock->flags;
                            
4000607c:	84 38 00 02 	xnor  %g0, %g2, %g2
                           <== NOT EXECUTED
40006080:	c4 26 00 00 	st  %g2, [ %i0 ]
                              <== NOT EXECUTED
40006084:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006088:	01 00 00 00 	nop 
                                          
  _CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context );
       
  return 0;
                                                          
}
                                                                    
4000608c:	81 c7 e0 08 	ret 
                                          
40006090:	91 e8 20 00 	restore  %g0, 0, %o0
                          

                                                                     
===============================================================================
40006094 <pthread_rwlock_init>:
                                      

                                                                     
int pthread_rwlock_init(
                                             
  pthread_rwlock_t           *rwlock,
                                
  const pthread_rwlockattr_t *attr
                                   
)
                                                                    
{
                                                                    
40006094:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_RWLock_Control *the_rwlock;
                                  

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          

                                                                     
  if ( the_rwlock == NULL ) {
                                        
40006098:	90 96 20 00 	orcc  %i0, 0, %o0
                             
4000609c:	02 80 00 14 	be  400060ec <pthread_rwlock_init+0x58>
       <== NEVER TAKEN
400060a0:	80 a6 60 00 	cmp  %i1, 0
                                   
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  if ( attr != NULL ) {
                                              
400060a4:	02 80 00 0a 	be  400060cc <pthread_rwlock_init+0x38>
       <== NEVER TAKEN
400060a8:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
    if ( !attr->is_initialized ) {
                                   
400060ac:	c2 06 40 00 	ld  [ %i1 ], %g1
                              
400060b0:	80 a0 60 00 	cmp  %g1, 0
                                   
400060b4:	02 80 00 0c 	be  400060e4 <pthread_rwlock_init+0x50>
       <== NEVER TAKEN
400060b8:	b0 10 20 16 	mov  0x16, %i0
                                
      return EINVAL;
                                                 
    }
                                                                

                                                                     
    if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
        
400060bc:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1
                          
400060c0:	80 a0 60 01 	cmp  %g1, 1
                                   
400060c4:	18 80 00 08 	bgu  400060e4 <pthread_rwlock_init+0x50>
      <== NEVER TAKEN
400060c8:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
      return EINVAL;
                                                 
    }
                                                                
  }
                                                                  

                                                                     
  the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC;
   
400060cc:	82 10 62 bd 	or  %g1, 0x2bd, %g1	! 9621dabd <RAM_END+0x55e1dabd>

400060d0:	82 1a 00 01 	xor  %o0, %g1, %g1
                            
400060d4:	c2 22 00 00 	st  %g1, [ %o0 ]
                              
  _CORE_RWLock_Initialize( &the_rwlock->RWLock );
                    
  return 0;
                                                          
400060d8:	b0 10 20 00 	clr  %i0
                                      
  _CORE_RWLock_Initialize( &the_rwlock->RWLock );
                    
400060dc:	40 00 01 90 	call  4000671c <_CORE_RWLock_Initialize>
      
400060e0:	90 02 20 04 	add  %o0, 4, %o0
                              
  return 0;
                                                          
400060e4:	81 c7 e0 08 	ret 
                                          
400060e8:	81 e8 00 00 	restore 
                                      
    return EINVAL;
                                                   
400060ec:	b0 10 20 16 	mov  0x16, %i0
                                <== NOT EXECUTED
}
                                                                    
400060f0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060f4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400060f8 <pthread_rwlock_rdlock>:
                                    
#include <rtems/posix/posixapi.h>
                                    

                                                                     
int pthread_rwlock_rdlock(
                                           
  pthread_rwlock_t  *rwlock
                                          
)
                                                                    
{
                                                                    
400060f8:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
400060fc:	80 a6 20 00 	cmp  %i0, 0
                                   
40006100:	02 80 00 16 	be  40006158 <pthread_rwlock_rdlock+0x60>
     <== NEVER TAKEN
40006104:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
40006108:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
4000610c:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
40006110:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006114:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006118:	02 80 00 07 	be  40006134 <pthread_rwlock_rdlock+0x3c>
     <== ALWAYS TAKEN
4000611c:	03 10 00 27 	sethi  %hi(0x40009c00), %g1
                   
40006120:	40 00 00 74 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
40006124:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006128:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000612c:	02 80 00 0b 	be  40006158 <pthread_rwlock_rdlock+0x60>
     <== NOT EXECUTED
40006130:	03 10 00 27 	sethi  %hi(0x40009c00), %g1
                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void
                                            
_Thread_queue_Context_set_enqueue_do_nothing_extra(
                  
  Thread_queue_Context *queue_context
                                
)
                                                                    
{
                                                                    
  queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;

40006134:	82 10 61 8c 	or  %g1, 0x18c, %g1	! 40009d8c <_Thread_queue_Enqueue_do_nothing_extra>


                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );

  status = _CORE_RWLock_Seize_for_reading(
                           
40006138:	94 07 bf dc 	add  %fp, -36, %o2
                            
4000613c:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        
40006140:	90 06 20 04 	add  %i0, 4, %o0
                              
40006144:	40 00 01 7c 	call  40006734 <_CORE_RWLock_Seize_for_reading>

40006148:	92 10 20 01 	mov  1, %o1
                                   
  return _POSIX_Get_by_name_error_table[ error ];
                    
}
                                                                    

                                                                     
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
   
{
                                                                    
  return STATUS_GET_POSIX( status );
                                 
4000614c:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
    &the_rwlock->RWLock,
                                             
    true,                 /* we are willing to wait forever */
       
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Get_error( status );
                                 
}
                                                                    
40006150:	81 c7 e0 08 	ret 
                                          
40006154:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006158:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000615c:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
40006160 <pthread_rwlock_timedrdlock>:
                               

                                                                     
int pthread_rwlock_timedrdlock(
                                      
  pthread_rwlock_t      *rwlock,
                                     
  const struct timespec *abstime
                                     
)
                                                                    
{
                                                                    
40006160:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006164:	80 a6 20 00 	cmp  %i0, 0
                                   
40006168:	02 80 00 17 	be  400061c4 <pthread_rwlock_timedrdlock+0x64>
<== NEVER TAKEN
4000616c:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
40006170:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40006174:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
40006178:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
4000617c:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006180:	02 80 00 07 	be  4000619c <pthread_rwlock_timedrdlock+0x3c>
<== ALWAYS TAKEN
40006184:	03 10 00 2b 	sethi  %hi(0x4000ac00), %g1
                   
40006188:	40 00 00 5a 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
4000618c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006190:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006194:	02 80 00 0c 	be  400061c4 <pthread_rwlock_timedrdlock+0x64>
<== NOT EXECUTED
40006198:	03 10 00 2b 	sethi  %hi(0x4000ac00), %g1
                   <== NOT EXECUTED
  Thread_queue_Context  *queue_context,
                              
  const struct timespec *abstime
                                     
)
                                                                    
{
                                                                    
  queue_context->Timeout.arg = abstime;
                              
  queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;

4000619c:	82 10 61 24 	or  %g1, 0x124, %g1	! 4000ad24 <_Thread_queue_Add_timeout_realtime_timespec>

  queue_context->Timeout.arg = abstime;
                              
400061a0:	f2 27 bf e8 	st  %i1, [ %fp + -24 ]
                        
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_set_enqueue_timeout_realtime_timespec(
       
    &queue_context,
                                                  
    abstime
                                                          
  );
                                                                 
  status = _CORE_RWLock_Seize_for_reading(
                           
400061a4:	94 07 bf dc 	add  %fp, -36, %o2
                            
  queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;

400061a8:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        
400061ac:	90 06 20 04 	add  %i0, 4, %o0
                              
400061b0:	40 00 01 61 	call  40006734 <_CORE_RWLock_Seize_for_reading>

400061b4:	92 10 20 01 	mov  1, %o1
                                   
400061b8:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
    &the_rwlock->RWLock,
                                             
    true,
                                                            
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Get_error( status );
                                 
}
                                                                    
400061bc:	81 c7 e0 08 	ret 
                                          
400061c0:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
400061c4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400061c8:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
400061cc <pthread_rwlock_timedwrlock>:
                               

                                                                     
int pthread_rwlock_timedwrlock(
                                      
  pthread_rwlock_t      *rwlock,
                                     
  const struct timespec *abstime
                                     
)
                                                                    
{
                                                                    
400061cc:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
400061d0:	80 a6 20 00 	cmp  %i0, 0
                                   
400061d4:	02 80 00 17 	be  40006230 <pthread_rwlock_timedwrlock+0x64>
<== NEVER TAKEN
400061d8:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
400061dc:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
400061e0:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
400061e4:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
400061e8:	80 a0 40 02 	cmp  %g1, %g2
                                 
400061ec:	02 80 00 07 	be  40006208 <pthread_rwlock_timedwrlock+0x3c>
<== ALWAYS TAKEN
400061f0:	03 10 00 2b 	sethi  %hi(0x4000ac00), %g1
                   
400061f4:	40 00 00 3f 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
400061f8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400061fc:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006200:	02 80 00 0c 	be  40006230 <pthread_rwlock_timedwrlock+0x64>
<== NOT EXECUTED
40006204:	03 10 00 2b 	sethi  %hi(0x4000ac00), %g1
                   <== NOT EXECUTED
40006208:	82 10 61 24 	or  %g1, 0x124, %g1	! 4000ad24 <_Thread_queue_Add_timeout_realtime_timespec>

  queue_context->Timeout.arg = abstime;
                              
4000620c:	f2 27 bf e8 	st  %i1, [ %fp + -24 ]
                        
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_set_enqueue_timeout_realtime_timespec(
       
    &queue_context,
                                                  
    abstime
                                                          
  );
                                                                 
  status = _CORE_RWLock_Seize_for_writing(
                           
40006210:	94 07 bf dc 	add  %fp, -36, %o2
                            
  queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;

40006214:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        
40006218:	90 06 20 04 	add  %i0, 4, %o0
                              
4000621c:	40 00 01 78 	call  400067fc <_CORE_RWLock_Seize_for_writing>

40006220:	92 10 20 01 	mov  1, %o1
                                   
40006224:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
    &the_rwlock->RWLock,
                                             
    true,
                                                            
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Get_error( status );
                                 
}
                                                                    
40006228:	81 c7 e0 08 	ret 
                                          
4000622c:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006230:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006234:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
40006238 <pthread_rwlock_tryrdlock>:
                                 
#include <rtems/posix/posixapi.h>
                                    

                                                                     
int pthread_rwlock_tryrdlock(
                                        
  pthread_rwlock_t  *rwlock
                                          
)
                                                                    
{
                                                                    
40006238:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
4000623c:	80 a6 20 00 	cmp  %i0, 0
                                   
40006240:	02 80 00 13 	be  4000628c <pthread_rwlock_tryrdlock+0x54>
  <== NEVER TAKEN
40006244:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
40006248:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
4000624c:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
40006250:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006254:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006258:	02 80 00 07 	be  40006274 <pthread_rwlock_tryrdlock+0x3c>
  <== ALWAYS TAKEN
4000625c:	94 07 bf dc 	add  %fp, -36, %o2
                            
40006260:	40 00 00 24 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
40006264:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006268:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000626c:	02 80 00 08 	be  4000628c <pthread_rwlock_tryrdlock+0x54>
  <== NOT EXECUTED
40006270:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  status = _CORE_RWLock_Seize_for_reading(
                           
40006274:	90 06 20 04 	add  %i0, 4, %o0
                              
40006278:	40 00 01 2f 	call  40006734 <_CORE_RWLock_Seize_for_reading>

4000627c:	92 10 20 00 	clr  %o1
                                      
40006280:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
    &the_rwlock->RWLock,
                                             
    false,                  /* do not wait for the rwlock */
         
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Get_error( status );
                                 
}
                                                                    
40006284:	81 c7 e0 08 	ret 
                                          
40006288:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
4000628c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006290:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
40006294 <pthread_rwlock_trywrlock>:
                                 
#include <rtems/posix/posixapi.h>
                                    

                                                                     
int pthread_rwlock_trywrlock(
                                        
  pthread_rwlock_t  *rwlock
                                          
)
                                                                    
{
                                                                    
40006294:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006298:	80 a6 20 00 	cmp  %i0, 0
                                   
4000629c:	02 80 00 13 	be  400062e8 <pthread_rwlock_trywrlock+0x54>
  <== NEVER TAKEN
400062a0:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
400062a4:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
400062a8:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
400062ac:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
400062b0:	80 a0 40 02 	cmp  %g1, %g2
                                 
400062b4:	02 80 00 07 	be  400062d0 <pthread_rwlock_trywrlock+0x3c>
  <== ALWAYS TAKEN
400062b8:	94 07 bf dc 	add  %fp, -36, %o2
                            
400062bc:	40 00 00 0d 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
400062c0:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400062c4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400062c8:	02 80 00 08 	be  400062e8 <pthread_rwlock_trywrlock+0x54>
  <== NOT EXECUTED
400062cc:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED

                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  status = _CORE_RWLock_Seize_for_writing(
                           
400062d0:	90 06 20 04 	add  %i0, 4, %o0
                              
400062d4:	40 00 01 4a 	call  400067fc <_CORE_RWLock_Seize_for_writing>

400062d8:	92 10 20 00 	clr  %o1
                                      
400062dc:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
    &the_rwlock->RWLock,
                                             
    false,                 /* we are not willing to wait */
          
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Get_error( status );
                                 
}
                                                                    
400062e0:	81 c7 e0 08 	ret 
                                          
400062e4:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
400062e8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400062ec:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
40006350 <pthread_rwlock_unlock>:
                                    

                                                                     
int pthread_rwlock_unlock(
                                           
  pthread_rwlock_t  *rwlock
                                          
)
                                                                    
{
                                                                    
40006350:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_RWLock_Control *the_rwlock;
                                  
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006354:	80 a6 20 00 	cmp  %i0, 0
                                   
40006358:	02 80 00 12 	be  400063a0 <pthread_rwlock_unlock+0x50>
     <== NEVER TAKEN
4000635c:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
40006360:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40006364:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
40006368:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
4000636c:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006370:	02 80 00 07 	be  4000638c <pthread_rwlock_unlock+0x3c>
     <== ALWAYS TAKEN
40006374:	01 00 00 00 	nop 
                                          
40006378:	7f ff ff de 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
4000637c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006380:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006384:	02 80 00 07 	be  400063a0 <pthread_rwlock_unlock+0x50>
     <== NOT EXECUTED
40006388:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
  status = _CORE_RWLock_Surrender( &the_rwlock->RWLock );
            
4000638c:	40 00 01 63 	call  40006918 <_CORE_RWLock_Surrender>
       
40006390:	90 06 20 04 	add  %i0, 4, %o0
                              
40006394:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
  return _POSIX_Get_error( status );
                                 
}
                                                                    
40006398:	81 c7 e0 08 	ret 
                                          
4000639c:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
400063a0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400063a4:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
400063a8 <pthread_rwlock_wrlock>:
                                    
#include <rtems/posix/posixapi.h>
                                    

                                                                     
int pthread_rwlock_wrlock(
                                           
  pthread_rwlock_t  *rwlock
                                          
)
                                                                    
{
                                                                    
400063a8:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  POSIX_RWLock_Control *the_rwlock;
                                  
  Thread_queue_Context  queue_context;
                               
  Status_Control        status;
                                      

                                                                     
  the_rwlock = _POSIX_RWLock_Get( rwlock );
                          
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
400063ac:	80 a6 20 00 	cmp  %i0, 0
                                   
400063b0:	02 80 00 16 	be  40006408 <pthread_rwlock_wrlock+0x60>
     <== NEVER TAKEN
400063b4:	03 25 88 76 	sethi  %hi(0x9621d800), %g1
                   
400063b8:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
400063bc:	82 10 62 bd 	or  %g1, 0x2bd, %g1
                           
400063c0:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
400063c4:	80 a0 40 02 	cmp  %g1, %g2
                                 
400063c8:	02 80 00 07 	be  400063e4 <pthread_rwlock_wrlock+0x3c>
     <== ALWAYS TAKEN
400063cc:	03 10 00 27 	sethi  %hi(0x40009c00), %g1
                   
400063d0:	7f ff ff c8 	call  400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
400063d4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400063d8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400063dc:	02 80 00 0b 	be  40006408 <pthread_rwlock_wrlock+0x60>
     <== NOT EXECUTED
400063e0:	03 10 00 27 	sethi  %hi(0x40009c00), %g1
                   <== NOT EXECUTED
  queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;

400063e4:	82 10 61 8c 	or  %g1, 0x18c, %g1	! 40009d8c <_Thread_queue_Enqueue_do_nothing_extra>


                                                                     
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );

  status = _CORE_RWLock_Seize_for_writing(
                           
400063e8:	94 07 bf dc 	add  %fp, -36, %o2
                            
400063ec:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]
                        
400063f0:	90 06 20 04 	add  %i0, 4, %o0
                              
400063f4:	40 00 01 02 	call  400067fc <_CORE_RWLock_Seize_for_writing>

400063f8:	92 10 20 01 	mov  1, %o1
                                   
400063fc:	b1 3a 60 08 	sra  %o1, 8, %i0
                              
    &the_rwlock->RWLock,
                                             
    true,          /* do not timeout -- wait forever */
              
    &queue_context
                                                   
  );
                                                                 
  return _POSIX_Get_error( status );
                                 
}
                                                                    
40006400:	81 c7 e0 08 	ret 
                                          
40006404:	81 e8 00 00 	restore 
                                      
  POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
                        
40006408:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000640c:	91 e8 20 16 	restore  %g0, 0x16, %o0
                       <== NOT EXECUTED

                                                                     
===============================================================================
400064b4 <pthread_rwlockattr_init>:
                                  

                                                                     
int pthread_rwlockattr_init(
                                         
  pthread_rwlockattr_t *attr
                                         
)
                                                                    
{
                                                                    
  if ( !attr )
                                                       
400064b4:	82 92 20 00 	orcc  %o0, 0, %g1
                             
400064b8:	02 80 00 06 	be  400064d0 <pthread_rwlockattr_init+0x1c>
   <== NEVER TAKEN
400064bc:	84 10 20 01 	mov  1, %g2
                                   
    return EINVAL;
                                                   

                                                                     
  attr->is_initialized = true;
                                       
  attr->process_shared = PTHREAD_PROCESS_PRIVATE;
                    
400064c0:	c0 20 60 04 	clr  [ %g1 + 4 ]
                              
  return 0;
                                                          
400064c4:	90 10 20 00 	clr  %o0
                                      
400064c8:	81 c3 e0 08 	retl 
                                         
400064cc:	c4 20 40 00 	st  %g2, [ %g1 ]
                              
}
                                                                    
400064d0:	81 c3 e0 08 	retl 
                                         <== NOT EXECUTED
400064d4:	90 10 20 16 	mov  0x16, %o0
                                <== NOT EXECUTED

                                                                     
===============================================================================
40006554 <pthread_setschedparam>:
                                    
  const struct sched_param *param
                                    
#else
                                                                
  struct sched_param       *param
                                    
#endif
                                                               
)
                                                                    
{
                                                                    
40006554:	9d e3 bf 68 	save  %sp, -152, %sp
                          
  Thread_Control                      *the_thread;
                   
  Per_CPU_Control                     *cpu_self;
                     
  Thread_queue_Context                 queue_context;
                
  int                                  error;
                        

                                                                     
  if ( param == NULL ) {
                                             
40006558:	80 a6 a0 00 	cmp  %i2, 0
                                   
4000655c:	02 80 00 0a 	be  40006584 <pthread_setschedparam+0x30>
     <== NEVER TAKEN
40006560:	b6 10 20 16 	mov  0x16, %i3
                                
    return EINVAL;
                                                   
  }
                                                                  

                                                                     
  error = _POSIX_Thread_Translate_sched_param(
                       
40006564:	96 07 bf d8 	add  %fp, -40, %o3
                            
40006568:	94 07 bf d4 	add  %fp, -44, %o2
                            
4000656c:	92 10 00 1a 	mov  %i2, %o1
                                 
40006570:	40 00 1c 0c 	call  4000d5a0 <_POSIX_Thread_Translate_sched_param>

40006574:	90 10 00 19 	mov  %i1, %o0
                                 
    policy,
                                                          
    param,
                                                           
    &budget_algorithm,
                                               
    &budget_callout
                                                  
  );
                                                                 
  if ( error != 0 ) {
                                                
40006578:	b6 92 20 00 	orcc  %o0, 0, %i3
                             
4000657c:	02 80 00 04 	be  4000658c <pthread_setschedparam+0x38>
     <== ALWAYS TAKEN
40006580:	90 10 00 18 	mov  %i0, %o0
                                 
  cpu_self = _Thread_queue_Dispatch_disable( &queue_context );
       
  _Thread_Wait_release( the_thread, &queue_context );
                
  _Thread_Priority_update( &queue_context );
                         
  _Thread_Dispatch_enable( cpu_self );
                               
  return error;
                                                      
}
                                                                    
40006584:	81 c7 e0 08 	ret 
                                          
40006588:	91 e8 00 1b 	restore  %g0, %i3, %o0
                        
4000658c:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            
  the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );

40006590:	40 00 0e 7b 	call  40009f7c <_Thread_Get>
                  
40006594:	92 07 bf dc 	add  %fp, -36, %o1
                            
  if ( the_thread == NULL ) {
                                        
40006598:	b0 92 20 00 	orcc  %o0, 0, %i0
                             
4000659c:	02 80 00 41 	be  400066a0 <pthread_setschedparam+0x14c>
    <== NEVER TAKEN
400065a0:	ea 07 bf d4 	ld  [ %fp + -44 ], %l5
                        
  normal_prio = param->sched_priority;
                               
400065a4:	e0 06 80 00 	ld  [ %i2 ], %l0
                              
  error = _POSIX_Set_sched_param(
                                    
400065a8:	e8 07 bf d8 	ld  [ %fp + -40 ], %l4
                        
  core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );

400065ac:	92 10 00 10 	mov  %l0, %o1
                                 
400065b0:	94 07 bf d3 	add  %fp, -45, %o2
                            
400065b4:	23 10 00 3d 	sethi  %hi(0x4000f400), %l1
                   
400065b8:	40 00 1b c9 	call  4000d4dc <_POSIX_Priority_To_core>
      
400065bc:	90 14 62 b0 	or  %l1, 0x2b0, %o0	! 4000f6b0 <_Scheduler_Table>

  if ( !valid ) {
                                                    
400065c0:	c2 0f bf d3 	ldub  [ %fp + -45 ], %g1
                      
  core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );

400065c4:	b8 10 00 08 	mov  %o0, %i4
                                 
  if ( !valid ) {
                                                    
400065c8:	80 a0 60 00 	cmp  %g1, 0
                                   
400065cc:	02 80 00 37 	be  400066a8 <pthread_setschedparam+0x154>
    <== NEVER TAKEN
400065d0:	ba 10 00 09 	mov  %o1, %i5
                                 
  if ( policy == SCHED_SPORADIC ) {
                                  
400065d4:	80 a6 60 04 	cmp  %i1, 4
                                   
400065d8:	22 80 00 02 	be,a   400065e0 <pthread_setschedparam+0x8c>
  <== NEVER TAKEN
400065dc:	e0 06 a0 04 	ld  [ %i2 + 4 ], %l0
                          <== NOT EXECUTED
  core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );

400065e0:	94 07 bf d3 	add  %fp, -45, %o2
                            
400065e4:	92 10 00 10 	mov  %l0, %o1
                                 
400065e8:	40 00 1b bd 	call  4000d4dc <_POSIX_Priority_To_core>
      
400065ec:	90 14 62 b0 	or  %l1, 0x2b0, %o0
                           
  if ( !valid ) {
                                                    
400065f0:	c2 0f bf d3 	ldub  [ %fp + -45 ], %g1
                      
  core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );

400065f4:	a4 10 00 08 	mov  %o0, %l2
                                 
  if ( !valid ) {
                                                    
400065f8:	80 a0 60 00 	cmp  %g1, 0
                                   
400065fc:	02 80 00 2b 	be  400066a8 <pthread_setschedparam+0x154>
    <== NEVER TAKEN
40006600:	a6 10 00 09 	mov  %o1, %l3
                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];
              
40006604:	e2 06 21 5c 	ld  [ %i0 + 0x15c ], %l1
                      
  _Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
            
40006608:	a0 04 60 08 	add  %l1, 8, %l0
                              
  _Watchdog_Remove(
                                                  
4000660c:	11 10 00 4b 	sethi  %hi(0x40012c00), %o0
                   
40006610:	92 10 00 10 	mov  %l0, %o1
                                 
40006614:	40 00 16 57 	call  4000bf70 <_Watchdog_Remove>
             
40006618:	90 12 21 78 	or  %o0, 0x178, %o0
                           
4000661c:	f8 3e 20 30 	std  %i4, [ %i0 + 0x30 ]
                      
  if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
   
40006620:	c2 04 60 34 	ld  [ %l1 + 0x34 ], %g1
                       
40006624:	80 a0 7f ff 	cmp  %g1, -1
                                  
40006628:	02 80 00 3b 	be  40006714 <pthread_setschedparam+0x1c0>
    <== ALWAYS TAKEN
4000662c:	92 06 20 20 	add  %i0, 0x20, %o1
                           
    _Thread_Priority_add(
                                            
40006630:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006634:	40 00 0d 85 	call  40009c48 <_Thread_Priority_add>
         <== NOT EXECUTED
40006638:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
    _Thread_Priority_remove(
                                         
4000663c:	94 07 bf dc 	add  %fp, -36, %o2
                            <== NOT EXECUTED
40006640:	92 04 60 28 	add  %l1, 0x28, %o1
                           <== NOT EXECUTED
40006644:	40 00 0d 86 	call  40009c5c <_Thread_Priority_remove>
      <== NOT EXECUTED
40006648:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4000664c:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
40006650:	c2 24 60 34 	st  %g1, [ %l1 + 0x34 ]
                       <== NOT EXECUTED
  if ( policy == SCHED_SPORADIC ) {
                                  
40006654:	80 a6 60 04 	cmp  %i1, 4
                                   <== NOT EXECUTED
  the_thread->budget_algorithm = budget_algorithm;
                   
40006658:	ea 26 20 90 	st  %l5, [ %i0 + 0x90 ]
                       
  the_thread->budget_callout   = budget_callout;
                     
4000665c:	e8 26 20 94 	st  %l4, [ %i0 + 0x94 ]
                       
40006660:	e4 3c 60 38 	std  %l2, [ %l1 + 0x38 ]
                      
  api->Sporadic.sched_ss_max_repl = param->sched_ss_max_repl;
        
40006664:	c2 06 a0 28 	ld  [ %i2 + 0x28 ], %g1
                       
  api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
  
40006668:	d4 1e a0 08 	ldd  [ %i2 + 8 ], %o2
                         
4000666c:	d8 1e a0 10 	ldd  [ %i2 + 0x10 ], %o4
                      
  api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
  
40006670:	f8 1e a0 18 	ldd  [ %i2 + 0x18 ], %i4
                      
40006674:	c4 1e a0 20 	ldd  [ %i2 + 0x20 ], %g2
                      
40006678:	c4 3c 60 58 	std  %g2, [ %l1 + 0x58 ]
                      
  api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
  
4000667c:	d4 3c 60 40 	std  %o2, [ %l1 + 0x40 ]
                      
40006680:	d8 3c 60 48 	std  %o4, [ %l1 + 0x48 ]
                      
  api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
  
40006684:	f8 3c 60 50 	std  %i4, [ %l1 + 0x50 ]
                      
  if ( policy == SCHED_SPORADIC ) {
                                  
40006688:	02 80 00 2e 	be  40006740 <pthread_setschedparam+0x1ec>
    <== NEVER TAKEN
4000668c:	c2 24 60 60 	st  %g1, [ %l1 + 0x60 ]
                       
      rtems_configuration_get_ticks_per_timeslice();
                 
40006690:	03 10 00 3d 	sethi  %hi(0x4000f400), %g1
                   
    the_thread->cpu_time_budget =
                                    
40006694:	c2 00 62 04 	ld  [ %g1 + 0x204 ], %g1	! 4000f604 <Configuration+0x18>

40006698:	10 80 00 05 	b  400066ac <pthread_setschedparam+0x158>
     
4000669c:	c2 26 20 8c 	st  %g1, [ %i0 + 0x8c ]
                       
    return ESRCH;
                                                    
400066a0:	10 bf ff b9 	b  40006584 <pthread_setschedparam+0x30>
      <== NOT EXECUTED
400066a4:	b6 10 20 03 	mov  3, %i3
                                   <== NOT EXECUTED
    return EINVAL;
                                                   
400066a8:	b6 10 20 16 	mov  0x16, %i3
                                <== NOT EXECUTED
  const ISR_lock_Context *lock_context
                               
)
                                                                    
{
                                                                    
  uint32_t disable_level;
                                            

                                                                     
  disable_level = cpu_self->thread_dispatch_disable_level;
           
400066ac:	c2 01 a0 18 	ld  [ %g6 + 0x18 ], %g1
                       <== NOT EXECUTED
  _Profiling_Thread_dispatch_disable_critical(
                       
    cpu_self,
                                                        
    disable_level,
                                                   
    lock_context
                                                     
  );
                                                                 
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
400066b0:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
 */
                                                                  
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(

  const ISR_lock_Context *lock_context
                               
)
                                                                    
{
                                                                    
  return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );

400066b4:	ba 10 00 06 	mov  %g6, %i5
                                 <== NOT EXECUTED
  cpu_self->thread_dispatch_disable_level = disable_level + 1;
       
400066b8:	c2 21 a0 18 	st  %g1, [ %g6 + 0x18 ]
                       <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400066bc:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1
                        <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400066c0:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400066c4:	01 00 00 00 	nop 
                                          
  _Thread_Priority_update( &queue_context );
                         
400066c8:	40 00 0d 71 	call  40009c8c <_Thread_Priority_update>
      
400066cc:	90 07 bf dc 	add  %fp, -36, %o0
                            
 *
                                                                   
 * @param[in] cpu_self The current processor.
                        
 */
                                                                  
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )

{
                                                                    
  uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
  
400066d0:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1
                       

                                                                     
  if ( disable_level == 1 ) {
                                        
400066d4:	80 a0 60 01 	cmp  %g1, 1
                                   
400066d8:	02 80 00 06 	be  400066f0 <pthread_setschedparam+0x19c>
    <== ALWAYS TAKEN
400066dc:	82 00 7f ff 	add  %g1, -1, %g1
                             
}
                                                                    
400066e0:	b0 10 00 1b 	mov  %i3, %i0
                                 <== NOT EXECUTED
    }
                                                                

                                                                     
    _ISR_Local_enable( level );
                                      
  } else {
                                                           
    _Assert( disable_level > 0 );
                                    
    cpu_self->thread_dispatch_disable_level = disable_level - 1;
     
400066e4:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]
                       <== NOT EXECUTED
400066e8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400066ec:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

400066f0:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
    if (
                                                             
400066f4:	c4 0f 60 1c 	ldub  [ %i5 + 0x1c ], %g2
                     
400066f8:	80 a0 a0 00 	cmp  %g2, 0
                                   
400066fc:	12 80 00 0c 	bne  4000672c <pthread_setschedparam+0x1d8>
   
40006700:	92 10 00 01 	mov  %g1, %o1
                                 
      cpu_self->thread_dispatch_disable_level = 0;
                   
40006704:	c0 27 60 18 	clr  [ %i5 + 0x18 ]
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006708:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
4000670c:	01 00 00 00 	nop 
                                          
40006710:	30 bf ff 9d 	b,a   40006584 <pthread_setschedparam+0x30>
   
    _Thread_Priority_changed(
                                        
40006714:	96 07 bf dc 	add  %fp, -36, %o3
                            
40006718:	94 10 20 00 	clr  %o2
                                      
4000671c:	40 00 0d 55 	call  40009c70 <_Thread_Priority_changed>
     
40006720:	90 10 00 18 	mov  %i0, %o0
                                 
  if ( policy == SCHED_SPORADIC ) {
                                  
40006724:	10 bf ff cd 	b  40006658 <pthread_setschedparam+0x104>
     
40006728:	80 a6 60 04 	cmp  %i1, 4
                                   
      _Thread_Do_dispatch( cpu_self, level );
                        
4000672c:	c2 27 bf cc 	st  %g1, [ %fp + -52 ]
                        
40006730:	40 00 0d b3 	call  40009dfc <_Thread_Do_dispatch>
          
40006734:	90 10 00 1d 	mov  %i5, %o0
                                 
40006738:	10 bf ff f4 	b  40006708 <pthread_setschedparam+0x1b4>
     <== NOT EXECUTED
4000673c:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1
                        <== NOT EXECUTED
    _Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
       
40006740:	40 00 14 dc 	call  4000bab0 <_Timespec_To_ticks>
           <== NOT EXECUTED
40006744:	90 04 60 50 	add  %l1, 0x50, %o0
                           <== NOT EXECUTED
  the_thread->cpu_time_budget =
                                      
40006748:	d0 26 20 8c 	st  %o0, [ %i0 + 0x8c ]
                       <== NOT EXECUTED
  _Watchdog_Per_CPU_insert_ticks(
                                    
4000674c:	ba 10 00 06 	mov  %g6, %i5
                                 <== NOT EXECUTED
40006750:	40 00 14 d8 	call  4000bab0 <_Timespec_To_ticks>
           <== NOT EXECUTED
40006754:	90 04 60 40 	add  %l1, 0x40, %o0
                           <== NOT EXECUTED
  expire = ticks + cpu->Watchdog.ticks;
                              
40006758:	d4 1f 60 30 	ldd  [ %i5 + 0x30 ], %o2
                      <== NOT EXECUTED
  _Watchdog_Insert(header, the_watchdog, expire);
                    
4000675c:	86 82 c0 08 	addcc  %o3, %o0, %g3
                          <== NOT EXECUTED
40006760:	84 42 a0 00 	addx  %o2, 0, %g2
                             <== NOT EXECUTED
40006764:	96 10 00 03 	mov  %g3, %o3
                                 <== NOT EXECUTED
40006768:	94 10 00 02 	mov  %g2, %o2
                                 <== NOT EXECUTED
4000676c:	92 10 00 10 	mov  %l0, %o1
                                 <== NOT EXECUTED
40006770:	40 00 15 d8 	call  4000bed0 <_Watchdog_Insert>
             <== NOT EXECUTED
40006774:	90 07 60 38 	add  %i5, 0x38, %o0
                           <== NOT EXECUTED
40006778:	30 bf ff cd 	b,a   400066ac <pthread_setschedparam+0x158>
  <== NOT EXECUTED

                                                                     
===============================================================================
40005ec8 <pthread_setspecific>:
                                      

                                                                     
int pthread_setspecific(
                                             
  pthread_key_t  key,
                                                
  const void    *value
                                               
)
                                                                    
{
                                                                    
40005ec8:	9d e3 bf 98 	save  %sp, -104, %sp
                          
40005ecc:	ba 10 00 18 	mov  %i0, %i5
                                 
  Thread_Control   *executing;
                                       
  int               eno;
                                             

                                                                     
  executing = _Thread_Get_executing();
                               

                                                                     
  if ( value != NULL ) {
                                             
40005ed0:	80 a6 60 00 	cmp  %i1, 0
                                   
40005ed4:	02 80 00 52 	be  4000601c <pthread_setspecific+0x154>
      <== NEVER TAKEN
40005ed8:	f8 01 a0 20 	ld  [ %g6 + 0x20 ], %i4
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005edc:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  return &RB_ROOT( the_rbtree );
                                     
40005ee0:	b6 07 21 60 	add  %i4, 0x160, %i3
                          
  link = _RBTree_Root_const_reference( the_rbtree );
                 
40005ee4:	86 10 00 1b 	mov  %i3, %g3
                                 
  while ( *link != NULL ) {
                                          
40005ee8:	c4 00 c0 00 	ld  [ %g3 ], %g2
                              
40005eec:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005ef0:	02 80 00 0d 	be  40005f24 <pthread_setspecific+0x5c>
       <== ALWAYS TAKEN
40005ef4:	86 00 bf f8 	add  %g2, -8, %g3
                             
  return *the_left == the_right->key;
                                
40005ef8:	c8 00 e0 18 	ld  [ %g3 + 0x18 ], %g4
                       <== NOT EXECUTED
    if ( ( *equal )( key, parent ) ) {
                               
40005efc:	80 a7 40 04 	cmp  %i5, %g4
                                 <== NOT EXECUTED
40005f00:	22 80 00 31 	be,a   40005fc4 <pthread_setspecific+0xfc>
    <== NOT EXECUTED
40005f04:	f2 20 e0 20 	st  %i1, [ %g3 + 0x20 ]
                       <== NOT EXECUTED
    } else if ( ( *less )( key, parent ) ) {
                         
40005f08:	1a bf ff f8 	bcc  40005ee8 <pthread_setspecific+0x20>
      <== NOT EXECUTED
40005f0c:	86 00 a0 04 	add  %g2, 4, %g3
                              <== NOT EXECUTED
  return &RB_LEFT( the_node, Node );
                                 
40005f10:	86 10 00 02 	mov  %g2, %g3
                                 <== NOT EXECUTED
  while ( *link != NULL ) {
                                          
40005f14:	c4 00 c0 00 	ld  [ %g3 ], %g2
                              <== NOT EXECUTED
40005f18:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40005f1c:	12 bf ff f7 	bne  40005ef8 <pthread_setspecific+0x30>
      <== NOT EXECUTED
40005f20:	86 00 bf f8 	add  %g2, -8, %g3
                             <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005f24:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005f28:	01 00 00 00 	nop 
                                          
  _RTEMS_Lock_allocator();
                                           
40005f2c:	40 00 00 f0 	call  400062ec <_RTEMS_Lock_allocator>
        
40005f30:	b0 10 20 16 	mov  0x16, %i0	! 16 <_TLS_Alignment+0x15>
     
  return (POSIX_Keys_Control *)
                                      
40005f34:	90 10 00 1d 	mov  %i5, %o0
                                 
40005f38:	13 10 00 49 	sethi  %hi(0x40012400), %o1
                   
40005f3c:	40 00 08 27 	call  40007fd8 <_Objects_Get_no_protection>
   
40005f40:	92 12 63 40 	or  %o1, 0x340, %o1	! 40012740 <_POSIX_Keys_Information>

  if ( the_key != NULL ) {
                                           
40005f44:	b4 92 20 00 	orcc  %o0, 0, %i2
                             
40005f48:	02 80 00 31 	be  4000600c <pthread_setspecific+0x144>
      <== NEVER TAKEN
40005f4c:	01 00 00 00 	nop 
                                          
    key_value_pair = _POSIX_Keys_Key_value_allocate();
               
40005f50:	7f ff ff ce 	call  40005e88 <_POSIX_Keys_Key_value_allocate>

40005f54:	b0 10 20 0c 	mov  0xc, %i0	! c <_TLS_Alignment+0xb>
        
    if ( key_value_pair != NULL ) {
                                  
40005f58:	80 a2 20 00 	cmp  %o0, 0
                                   
40005f5c:	02 80 00 2c 	be  4000600c <pthread_setspecific+0x144>
      <== NEVER TAKEN
40005f60:	88 10 00 08 	mov  %o0, %g4
                                 <== NOT EXECUTED
  old_last = tail->previous;
                                         
40005f64:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1
                       <== NOT EXECUTED
  return &the_chain->Tail.Node;
                                      
40005f68:	84 06 a0 18 	add  %i2, 0x18, %g2
                           <== NOT EXECUTED
      key_value_pair->key = key;
                                     
40005f6c:	fa 22 20 18 	st  %i5, [ %o0 + 0x18 ]
                       <== NOT EXECUTED
      _RBTree_Initialize_node( &key_value_pair->Lookup_node );
       
40005f70:	b0 02 20 08 	add  %o0, 8, %i0
                              <== NOT EXECUTED
      key_value_pair->thread = executing;
                            
40005f74:	f8 22 20 1c 	st  %i4, [ %o0 + 0x1c ]
                       <== NOT EXECUTED
      key_value_pair->value = RTEMS_DECONST( void *, value );
        
40005f78:	f2 22 20 20 	st  %i1, [ %o0 + 0x20 ]
                       <== NOT EXECUTED
  the_node->next = tail;
                                             
40005f7c:	c4 22 00 00 	st  %g2, [ %o0 ]
                              <== NOT EXECUTED
  tail->previous = the_node;
                                         
40005f80:	d0 26 a0 1c 	st  %o0, [ %i2 + 0x1c ]
                       <== NOT EXECUTED
  old_last->next = the_node;
                                         
40005f84:	d0 20 40 00 	st  %o0, [ %g1 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
40005f88:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]
                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005f8c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  parent = NULL;
                                                     
40005f90:	b8 10 20 00 	clr  %i4
                                      
  link = _RBTree_Root_reference( the_rbtree );
                       
40005f94:	86 10 00 1b 	mov  %i3, %g3
                                 
  while ( *link != NULL ) {
                                          
40005f98:	c4 00 c0 00 	ld  [ %g3 ], %g2
                              
40005f9c:	80 a0 a0 00 	cmp  %g2, 0
                                   
40005fa0:	22 80 00 41 	be,a   400060a4 <pthread_setspecific+0x1dc>
   <== ALWAYS TAKEN
40005fa4:	f8 21 20 10 	st  %i4, [ %g4 + 0x10 ]
                       
    if ( ( *less )( key, parent ) ) {
                                
40005fa8:	f8 00 a0 10 	ld  [ %g2 + 0x10 ], %i4
                       <== NOT EXECUTED
40005fac:	80 a7 40 1c 	cmp  %i5, %i4
                                 <== NOT EXECUTED
40005fb0:	1a 80 00 03 	bcc  40005fbc <pthread_setspecific+0xf4>
      <== NOT EXECUTED
40005fb4:	86 00 a0 04 	add  %g2, 4, %g3
                              <== NOT EXECUTED
  return &RB_LEFT( the_node, Node );
                                 
40005fb8:	86 10 00 02 	mov  %g2, %g3
                                 <== NOT EXECUTED
  link = _RBTree_Root_const_reference( the_rbtree );
                 
40005fbc:	10 bf ff f7 	b  40005f98 <pthread_setspecific+0xd0>
        <== NOT EXECUTED
40005fc0:	b8 10 00 02 	mov  %g2, %i4
                                 <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005fc4:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005fc8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  } else {
                                                           
    eno = _POSIX_Keys_Delete_value( key, executing );
                
  }
                                                                  

                                                                     
  return eno;
                                                        
}
                                                                    
40005fcc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005fd0:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
      _RBTree_Extract(
                                               
40005fd4:	40 00 08 c9 	call  400082f8 <_RBTree_Extract>
              <== NOT EXECUTED
40005fd8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40005fdc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005fe0:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005fe4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  next           = the_node->next;
                                   
40005fe8:	c4 07 00 00 	ld  [ %i4 ], %g2
                              <== NOT EXECUTED
  previous       = the_node->previous;
                               
40005fec:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1
                          <== NOT EXECUTED
  next->previous = previous;
                                         
40005ff0:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]
                          <== NOT EXECUTED
  _Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
            
40005ff4:	11 10 00 49 	sethi  %hi(0x40012400), %o0
                   <== NOT EXECUTED
  previous->next = next;
                                             
40005ff8:	c4 20 40 00 	st  %g2, [ %g1 ]
                              <== NOT EXECUTED
40005ffc:	92 10 00 1c 	mov  %i4, %o1
                                 <== NOT EXECUTED
    eno = 0;
                                                         
40006000:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
40006004:	40 00 01 1b 	call  40006470 <_Freechain_Put>
               <== NOT EXECUTED
40006008:	90 12 23 7c 	or  %o0, 0x37c, %o0
                           <== NOT EXECUTED
  _RTEMS_Unlock_allocator();
                                         
4000600c:	40 00 00 bd 	call  40006300 <_RTEMS_Unlock_allocator>
      
40006010:	01 00 00 00 	nop 
                                          
  return eno;
                                                        
40006014:	81 c7 e0 08 	ret 
                                          
40006018:	81 e8 00 00 	restore 
                                      
  _RTEMS_Lock_allocator();
                                           
4000601c:	40 00 00 b4 	call  400062ec <_RTEMS_Lock_allocator>
        <== NOT EXECUTED
40006020:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  return (POSIX_Keys_Control *)
                                      
40006024:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006028:	13 10 00 49 	sethi  %hi(0x40012400), %o1
                   <== NOT EXECUTED
    eno = EINVAL;
                                                    
4000602c:	b0 10 20 16 	mov  0x16, %i0
                                <== NOT EXECUTED
40006030:	40 00 07 ea 	call  40007fd8 <_Objects_Get_no_protection>
   <== NOT EXECUTED
40006034:	92 12 63 40 	or  %o1, 0x340, %o1
                           <== NOT EXECUTED
  if ( the_key != NULL ) {
                                           
40006038:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000603c:	02 bf ff f4 	be  4000600c <pthread_setspecific+0x144>
      <== NOT EXECUTED
40006040:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006044:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Keys_Key_value_pair *_POSIX_Keys_Key_value_find(

  pthread_key_t         key,
                                         
  const Thread_Control *the_thread
                                   
)
                                                                    
{
                                                                    
  return _RBTree_Find_inline(
                                        
40006048:	90 07 21 60 	add  %i4, 0x160, %o0
                          <== NOT EXECUTED
4000604c:	84 10 00 08 	mov  %o0, %g2
                                 <== NOT EXECUTED
  while ( *link != NULL ) {
                                          
40006050:	d2 00 80 00 	ld  [ %g2 ], %o1
                              <== NOT EXECUTED
40006054:	80 a2 60 00 	cmp  %o1, 0
                                   <== NOT EXECUTED
40006058:	02 80 00 0d 	be  4000608c <pthread_setspecific+0x1c4>
      <== NOT EXECUTED
4000605c:	b8 02 7f f8 	add  %o1, -8, %i4
                             <== NOT EXECUTED
  return *the_left == the_right->key;
                                
40006060:	c4 07 20 18 	ld  [ %i4 + 0x18 ], %g2
                       <== NOT EXECUTED
    if ( ( *equal )( key, parent ) ) {
                               
40006064:	80 a7 40 02 	cmp  %i5, %g2
                                 <== NOT EXECUTED
40006068:	02 bf ff db 	be  40005fd4 <pthread_setspecific+0x10c>
      <== NOT EXECUTED
4000606c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    } else if ( ( *less )( key, parent ) ) {
                         
40006070:	1a bf ff f8 	bcc  40006050 <pthread_setspecific+0x188>
     <== NOT EXECUTED
40006074:	84 02 60 04 	add  %o1, 4, %g2
                              <== NOT EXECUTED
  return &RB_LEFT( the_node, Node );
                                 
40006078:	84 10 00 09 	mov  %o1, %g2
                                 <== NOT EXECUTED
  while ( *link != NULL ) {
                                          
4000607c:	d2 00 80 00 	ld  [ %g2 ], %o1
                              <== NOT EXECUTED
40006080:	80 a2 60 00 	cmp  %o1, 0
                                   <== NOT EXECUTED
40006084:	12 bf ff f7 	bne  40006060 <pthread_setspecific+0x198>
     <== NOT EXECUTED
40006088:	b8 02 7f f8 	add  %o1, -8, %i4
                             <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000608c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006090:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _RTEMS_Unlock_allocator();
                                         
40006094:	40 00 00 9b 	call  40006300 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006098:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>
                     <== NOT EXECUTED
  return eno;
                                                        
4000609c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060a0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  RB_SET( child, parent, Node );
                                     
400060a4:	84 10 20 01 	mov  1, %g2
                                   
400060a8:	c0 21 20 0c 	clr  [ %g4 + 0xc ]
                            
  _RBTree_Insert_color( the_rbtree, the_node );
                      
400060ac:	92 10 00 18 	mov  %i0, %o1
                                 
  RB_SET( child, parent, Node );
                                     
400060b0:	c0 21 20 08 	clr  [ %g4 + 8 ]
                              
  _RBTree_Insert_color( the_rbtree, the_node );
                      
400060b4:	90 10 00 1b 	mov  %i3, %o0
                                 
  RB_SET( child, parent, Node );
                                     
400060b8:	c4 21 20 14 	st  %g2, [ %g4 + 0x14 ]
                       
  *link = child;
                                                     
400060bc:	f0 20 c0 00 	st  %i0, [ %g3 ]
                              
  _RBTree_Insert_color( the_rbtree, the_node );
                      
400060c0:	40 00 09 f0 	call  40008880 <_RBTree_Insert_color>
         
400060c4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]
                         
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400060c8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400060cc:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400060d0:	01 00 00 00 	nop 
                                          
      eno = 0;
                                                       
400060d4:	10 bf ff ce 	b  4000600c <pthread_setspecific+0x144>
       
400060d8:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>
                     

                                                                     
===============================================================================
4000677c <sched_get_priority_max>:
                                   
#include <rtems/score/schedulerimpl.h>
                               

                                                                     
int sched_get_priority_max(
                                          
  int  policy
                                                        
)
                                                                    
{
                                                                    
4000677c:	9d e3 bf a0 	save  %sp, -96, %sp
                           
40006780:	80 a6 20 04 	cmp  %i0, 4
                                   
40006784:	18 80 00 09 	bgu  400067a8 <sched_get_priority_max+0x2c>
   <== NEVER TAKEN
40006788:	82 10 20 01 	mov  1, %g1
                                   
4000678c:	b1 28 40 18 	sll  %g1, %i0, %i0
                            
40006790:	80 8e 20 17 	btst  0x17, %i0
                               
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
                
  const Scheduler_Control *scheduler
                                 
)
                                                                    
{
                                                                    
  _Assert( (int) scheduler->maximum_priority > 1 );
                  
  return (int) scheduler->maximum_priority - 1;
                      
40006794:	02 80 00 05 	be  400067a8 <sched_get_priority_max+0x2c>
    <== NEVER TAKEN
40006798:	03 10 00 3d 	sethi  %hi(0x4000f400), %g1
                   
4000679c:	f0 00 62 f4 	ld  [ %g1 + 0x2f4 ], %i0	! 4000f6f4 <_Scheduler_Table+0x44>

      rtems_set_errno_and_return_minus_one( EINVAL );
                
  }
                                                                  

                                                                     
  scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() );
 
  return _POSIX_Priority_Get_maximum( scheduler );
                   
}
                                                                    
400067a0:	81 c7 e0 08 	ret 
                                          
400067a4:	91 ee 3f ff 	restore  %i0, -1, %o0
                         
      rtems_set_errno_and_return_minus_one( EINVAL );
                
400067a8:	40 00 1e 76 	call  4000e180 <__errno>
                      <== NOT EXECUTED
400067ac:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400067b0:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
400067b4:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400067b8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400067bc:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000664c <sched_get_priority_min>:
                                   
 *  13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
    
 */
                                                                  
int sched_get_priority_min(
                                          
  int  policy
                                                        
)
                                                                    
{
                                                                    
4000664c:	9d e3 bf a0 	save  %sp, -96, %sp
                           
40006650:	80 a6 20 04 	cmp  %i0, 4
                                   
40006654:	18 80 00 08 	bgu  40006674 <sched_get_priority_min+0x28>
   <== NEVER TAKEN
40006658:	82 10 20 01 	mov  1, %g1
                                   
4000665c:	83 28 40 18 	sll  %g1, %i0, %g1
                            
40006660:	80 88 60 17 	btst  0x17, %g1
                               

                                                                     
    default:
                                                         
      rtems_set_errno_and_return_minus_one( EINVAL );
                
  }
                                                                  

                                                                     
  return POSIX_SCHEDULER_MINIMUM_PRIORITY;
                           
40006664:	02 80 00 04 	be  40006674 <sched_get_priority_min+0x28>
    <== NEVER TAKEN
40006668:	84 10 20 01 	mov  1, %g2
                                   
}
                                                                    
4000666c:	81 c7 e0 08 	ret 
                                          
40006670:	91 e8 00 02 	restore  %g0, %g2, %o0
                        
      rtems_set_errno_and_return_minus_one( EINVAL );
                
40006674:	40 00 1e 32 	call  4000df3c <__errno>
                      <== NOT EXECUTED
40006678:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000667c:	82 10 20 16 	mov  0x16, %g1	! 16 <_TLS_Alignment+0x15>
     <== NOT EXECUTED
40006680:	84 10 3f ff 	mov  -1, %g2
                                  <== NOT EXECUTED
40006684:	10 bf ff fa 	b  4000666c <sched_get_priority_min+0x20>
     <== NOT EXECUTED
40006688:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED

                                                                     
===============================================================================
40005fac <sem_close>:
                                                
#endif
                                                               

                                                                     
#include <rtems/posix/semaphoreimpl.h>
                               

                                                                     
int sem_close( sem_t *sem )
                                          
{
                                                                    
40005fac:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_Semaphore_Control *the_semaphore;
                            
  uint32_t                 open_count;
                               

                                                                     
  POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
                            
40005fb0:	80 a6 20 00 	cmp  %i0, 0
                                   
40005fb4:	02 80 00 22 	be  4000603c <sem_close+0x90>
                 <== NEVER TAKEN
40005fb8:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
40005fbc:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40005fc0:	82 10 63 e7 	or  %g1, 0x3e7, %g1
                           
40005fc4:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40005fc8:	80 a0 40 02 	cmp  %g1, %g2
                                 
40005fcc:	12 80 00 1c 	bne  4000603c <sem_close+0x90>
                <== NEVER TAKEN
40005fd0:	01 00 00 00 	nop 
                                          

                                                                     
  if ( !_POSIX_Semaphore_Is_named( sem ) ) {
                         
40005fd4:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1
                       
40005fd8:	80 a0 60 00 	cmp  %g1, 0
                                   
40005fdc:	02 80 00 18 	be  4000603c <sem_close+0x90>
                 <== NEVER TAKEN
40005fe0:	01 00 00 00 	nop 
                                          
  _RTEMS_Lock_allocator();
                                           
40005fe4:	40 00 01 4a 	call  4000650c <_RTEMS_Lock_allocator>
        
40005fe8:	01 00 00 00 	nop 
                                          

                                                                     
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get(
  
  sem_t *sem
                                                         
)
                                                                    
{
                                                                    
  return RTEMS_CONTAINER_OF( sem, POSIX_Semaphore_Control, Semaphore );

40005fec:	90 06 3f f0 	add  %i0, -16, %o0
                            

                                                                     
  the_semaphore = _POSIX_Semaphore_Get( sem );
                       

                                                                     
  _Objects_Allocator_lock();
                                         

                                                                     
  open_count = the_semaphore->open_count;
                            
40005ff0:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1
                       

                                                                     
  if ( open_count == 0 ) {
                                           
40005ff4:	80 a0 60 00 	cmp  %g1, 0
                                   
40005ff8:	02 80 00 0f 	be  40006034 <sem_close+0x88>
                 <== NEVER TAKEN
40005ffc:	80 a0 60 01 	cmp  %g1, 1
                                   
    _Objects_Allocator_unlock();
                                     
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
  }
                                                                  

                                                                     
  if ( open_count == 1 && _POSIX_Semaphore_Is_busy( sem ) ) {
        
40006000:	12 80 00 06 	bne  40006018 <sem_close+0x6c>
                
40006004:	82 00 7f ff 	add  %g1, -1, %g1
                             
40006008:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2
                        
4000600c:	80 a0 a0 00 	cmp  %g2, 0
                                   
40006010:	12 80 00 11 	bne  40006054 <sem_close+0xa8>
                <== NEVER TAKEN
40006014:	01 00 00 00 	nop 
                                          
    _Objects_Allocator_unlock();
                                     
    rtems_set_errno_and_return_minus_one( EBUSY );
                   
  }
                                                                  

                                                                     
  the_semaphore->open_count = open_count - 1;
                        
40006018:	c2 22 20 30 	st  %g1, [ %o0 + 0x30 ]
                       
  _POSIX_Semaphore_Delete( the_semaphore );
                          
4000601c:	40 00 1b 41 	call  4000cd20 <_POSIX_Semaphore_Delete>
      
40006020:	b0 10 20 00 	clr  %i0
                                      
  _RTEMS_Unlock_allocator();
                                         
40006024:	40 00 01 3f 	call  40006520 <_RTEMS_Unlock_allocator>
      
40006028:	01 00 00 00 	nop 
                                          
  _Objects_Allocator_unlock();
                                       
  return 0;
                                                          
}
                                                                    
4000602c:	81 c7 e0 08 	ret 
                                          
40006030:	81 e8 00 00 	restore 
                                      
40006034:	40 00 01 3b 	call  40006520 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006038:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
4000603c:	40 00 20 db 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
40006040:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
40006044:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40006048:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000604c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006050:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
40006054:	40 00 01 33 	call  40006520 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006058:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBUSY );
                   
4000605c:	40 00 20 d3 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
40006060:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006064:	82 10 20 10 	mov  0x10, %g1	! 10 <_TLS_Alignment+0xf>
      <== NOT EXECUTED
40006068:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000606c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006070:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006074 <sem_destroy>:
                                              
#endif
                                                               

                                                                     
#include <rtems/posix/semaphoreimpl.h>
                               

                                                                     
int sem_destroy( sem_t *sem )
                                        
{
                                                                    
40006074:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
                            
40006078:	80 a6 20 00 	cmp  %i0, 0
                                   
4000607c:	02 80 00 13 	be  400060c8 <sem_destroy+0x54>
               <== NEVER TAKEN
40006080:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
40006084:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40006088:	82 10 63 e7 	or  %g1, 0x3e7, %g1
                           
4000608c:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006090:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006094:	12 80 00 0d 	bne  400060c8 <sem_destroy+0x54>
              <== NEVER TAKEN
40006098:	01 00 00 00 	nop 
                                          

                                                                     
  if ( _POSIX_Semaphore_Is_named( sem ) ) {
                          
4000609c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1
                       
400060a0:	80 a0 60 00 	cmp  %g1, 0
                                   
400060a4:	12 80 00 09 	bne  400060c8 <sem_destroy+0x54>
              <== NEVER TAKEN
400060a8:	01 00 00 00 	nop 
                                          
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
  }
                                                                  

                                                                     
  if ( _POSIX_Semaphore_Is_busy( sem ) ) {
                           
400060ac:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1
                        
400060b0:	80 a0 60 00 	cmp  %g1, 0
                                   
400060b4:	12 80 00 0b 	bne  400060e0 <sem_destroy+0x6c>
              <== NEVER TAKEN
400060b8:	01 00 00 00 	nop 
                                          
  _Semaphore_Initialize_named( &sem->_Semaphore, name, value );
      
}
                                                                    

                                                                     
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Destroy( sem_t *sem )
     
{
                                                                    
  sem->_flags = 0;
                                                   
400060bc:	c0 26 00 00 	clr  [ %i0 ]
                                  
    rtems_set_errno_and_return_minus_one( EBUSY );
                   
  }
                                                                  

                                                                     
  _POSIX_Semaphore_Destroy( sem );
                                   
  return 0;
                                                          
}
                                                                    
400060c0:	81 c7 e0 08 	ret 
                                          
400060c4:	91 e8 20 00 	restore  %g0, 0, %o0
                          
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
400060c8:	40 00 20 b8 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
400060cc:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400060d0:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
400060d4:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400060d8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060dc:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBUSY );
                   
400060e0:	40 00 20 b2 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
400060e4:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400060e8:	82 10 20 10 	mov  0x10, %g1
                                <== NOT EXECUTED
400060ec:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400060f0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060f4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40005f34 <sem_getvalue>:
                                             

                                                                     
int sem_getvalue(
                                                    
  sem_t  *__restrict _sem,
                                           
  int    *__restrict sval
                                            
)
                                                                    
{
                                                                    
40005f34:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  Sem_Control          *sem;
                                         
  ISR_Level             level;
                                       
  Thread_queue_Context  queue_context;
                               

                                                                     
  POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
                           
40005f38:	80 a6 20 00 	cmp  %i0, 0
                                   
40005f3c:	02 80 00 0f 	be  40005f78 <sem_getvalue+0x44>
              <== NEVER TAKEN
40005f40:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
40005f44:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40005f48:	82 10 63 e7 	or  %g1, 0x3e7, %g1
                           
40005f4c:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40005f50:	80 a0 40 02 	cmp  %g1, %g2
                                 
40005f54:	12 80 00 09 	bne  40005f78 <sem_getvalue+0x44>
             <== NEVER TAKEN
40005f58:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40005f5c:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED

                                                                     
  sem = _Sem_Get( &_sem->_Semaphore );
                               
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_ISR_disable( &queue_context, level );
        
  _Sem_Queue_acquire_critical( sem, &queue_context );
                
  *sval = (int) sem->count;
                                          
40005f60:	c4 06 20 18 	ld  [ %i0 + 0x18 ], %g2
                       <== NOT EXECUTED
40005f64:	c4 26 40 00 	st  %g2, [ %i1 ]
                              <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40005f68:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40005f6c:	01 00 00 00 	nop 
                                          
  _Sem_Queue_release( sem, level, &queue_context );
                  
  return 0;
                                                          
}
                                                                    
40005f70:	81 c7 e0 08 	ret 
                                          
40005f74:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
                           
40005f78:	40 00 20 5e 	call  4000e0f0 <__errno>
                      <== NOT EXECUTED
40005f7c:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40005f80:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40005f84:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40005f88:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40005f8c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400060f8 <sem_init>:
                                                 
int sem_init(
                                                        
  sem_t         *sem,
                                                
  int            pshared,
                                            
  unsigned int   value
                                               
)
                                                                    
{
                                                                    
400060f8:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  if ( sem == NULL ) {
                                               
400060fc:	82 96 20 00 	orcc  %i0, 0, %g1
                             
40006100:	02 80 00 0f 	be  4000613c <sem_init+0x44>
                  <== NEVER TAKEN
40006104:	80 a6 a0 00 	cmp  %i2, 0
                                   
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
  }
                                                                  

                                                                     
  if ( value > SEM_VALUE_MAX ) {
                                     
40006108:	06 80 00 0d 	bl  4000613c <sem_init+0x44>
                  <== NEVER TAKEN
4000610c:	05 17 4d 9f 	sethi  %hi(0x5d367c00), %g2
                   
    const char *_name, unsigned int _count)
                          
{
                                                                    
	struct _Semaphore_Control _init =
                                   
	    _SEMAPHORE_NAMED_INITIALIZER(_name, _count);
                    

                                                                     
	*_semaphore = _init;
                                                
40006110:	c0 20 60 04 	clr  [ %g1 + 4 ]
                              
40006114:	c0 20 60 08 	clr  [ %g1 + 8 ]
                              
  sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC;
             
40006118:	84 10 a3 e7 	or  %g2, 0x3e7, %g2
                           
4000611c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]
                            
40006120:	84 18 40 02 	xor  %g1, %g2, %g2
                            
40006124:	c4 20 40 00 	st  %g2, [ %g1 ]
                              
40006128:	c0 20 60 10 	clr  [ %g1 + 0x10 ]
                           
4000612c:	c0 20 60 14 	clr  [ %g1 + 0x14 ]
                           
40006130:	f4 20 60 18 	st  %i2, [ %g1 + 0x18 ]
                       
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
  }
                                                                  

                                                                     
  _POSIX_Semaphore_Initialize( sem, NULL, value );
                   
  return 0;
                                                          
}
                                                                    
40006134:	81 c7 e0 08 	ret 
                                          
40006138:	91 e8 20 00 	restore  %g0, 0, %o0
                          
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
4000613c:	40 00 20 9b 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
40006140:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40006144:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40006148:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000614c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006150:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006154 <sem_open>:
                                                 
  int         oflag,
                                                 
  ...
                                                                
  /* mode_t mode, */
                                                 
  /* unsigned int value */
                                           
)
                                                                    
{
                                                                    
40006154:	9d e3 bf 90 	save  %sp, -112, %sp
                          
  size_t                     name_len;
                               
  Objects_Get_by_name_error  error;
                                  
  sem_t                     *sem;
                                    

                                                                     
  if ( oflag & O_CREAT ) {
                                           
    va_start(arg, oflag);
                                            
40006158:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]
                       
  if ( oflag & O_CREAT ) {
                                           
4000615c:	80 8e 62 00 	btst  0x200, %i1
                              
    va_start(arg, oflag);
                                            
40006160:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]
                       
40006164:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]
                       
  if ( oflag & O_CREAT ) {
                                           
40006168:	12 80 00 18 	bne  400061c8 <sem_open+0x74>
                 
4000616c:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]
                       
  _RTEMS_Lock_allocator();
                                           
40006170:	40 00 00 e7 	call  4000650c <_RTEMS_Lock_allocator>
        
40006174:	01 00 00 00 	nop 
                                          
  const char                *name,
                                   
  size_t                    *name_length_p,
                          
  Objects_Get_by_name_error *error
                                   
)
                                                                    
{
                                                                    
  return (POSIX_Semaphore_Control *) _Objects_Get_by_name(
           
40006178:	96 07 bf fc 	add  %fp, -4, %o3
                             
4000617c:	94 07 bf f8 	add  %fp, -8, %o2
                             
40006180:	92 10 00 18 	mov  %i0, %o1
                                 
40006184:	11 10 00 4c 	sethi  %hi(0x40013000), %o0
                   
40006188:	40 00 08 36 	call  40008260 <_Objects_Get_by_name>
         
4000618c:	90 12 22 d0 	or  %o0, 0x2d0, %o0	! 400132d0 <_POSIX_Semaphore_Information>

   *  and we can just return a pointer to the id.  Otherwise we may
  
   *  need to check to see if this is a "semaphore does not exist"
   
   *  or some other miscellaneous error on the name.
                 
   */
                                                                

                                                                     
  if ( the_semaphore == NULL ) {
                                     
40006190:	80 a2 20 00 	cmp  %o0, 0
                                   
40006194:	02 80 00 3f 	be  40006290 <sem_open+0x13c>
                 <== NEVER TAKEN
40006198:	01 00 00 00 	nop 
                                          

                                                                     
    /*
                                                               
     * Check for existence with creation.
                            
     */
                                                              

                                                                     
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
      
4000619c:	b2 0e 6a 00 	and  %i1, 0xa00, %i1
                          
400061a0:	80 a6 6a 00 	cmp  %i1, 0xa00
                               
400061a4:	02 80 00 46 	be  400062bc <sem_open+0x168>
                 <== NEVER TAKEN
400061a8:	01 00 00 00 	nop 
                                          
      _Objects_Allocator_unlock();
                                   
      rtems_set_errno_and_return_value( EEXIST, SEM_FAILED );
        
    }
                                                                

                                                                     
    the_semaphore->open_count += 1;
                                  
400061ac:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1
                       
400061b0:	82 00 60 01 	inc  %g1
                                      
400061b4:	c2 22 20 30 	st  %g1, [ %o0 + 0x30 ]
                       
  _RTEMS_Unlock_allocator();
                                         
400061b8:	40 00 00 da 	call  40006520 <_RTEMS_Unlock_allocator>
      
400061bc:	b0 02 20 10 	add  %o0, 0x10, %i0
                           
    _Objects_Allocator_unlock();
                                     
    return &the_semaphore->Semaphore;
                                
400061c0:	81 c7 e0 08 	ret 
                                          
400061c4:	81 e8 00 00 	restore 
                                      
    va_start(arg, oflag);
                                            
400061c8:	82 07 a0 4c 	add  %fp, 0x4c, %g1
                           
  _RTEMS_Lock_allocator();
                                           
400061cc:	40 00 00 d0 	call  4000650c <_RTEMS_Lock_allocator>
        
400061d0:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]
                        
400061d4:	3b 10 00 4c 	sethi  %hi(0x40013000), %i5
                   
400061d8:	96 07 bf fc 	add  %fp, -4, %o3
                             
400061dc:	94 07 bf f8 	add  %fp, -8, %o2
                             
400061e0:	92 10 00 18 	mov  %i0, %o1
                                 
400061e4:	40 00 08 1f 	call  40008260 <_Objects_Get_by_name>
         
400061e8:	90 17 62 d0 	or  %i5, 0x2d0, %o0
                           
  if ( the_semaphore == NULL ) {
                                     
400061ec:	80 a2 20 00 	cmp  %o0, 0
                                   
400061f0:	12 bf ff eb 	bne  4000619c <sem_open+0x48>
                 <== NEVER TAKEN
400061f4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         
    if ( !( error == OBJECTS_GET_BY_NAME_NO_OBJECT && (oflag & O_CREAT) ) ) {

400061f8:	80 a0 60 02 	cmp  %g1, 2
                                   
400061fc:	12 80 00 25 	bne  40006290 <sem_open+0x13c>
                <== NEVER TAKEN
40006200:	80 a6 e0 00 	cmp  %i3, 0
                                   
  if ( value > SEM_VALUE_MAX ) {
                                     
40006204:	06 80 00 36 	bl  400062dc <sem_open+0x188>
                 <== NEVER TAKEN
40006208:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1
                         
  name = _Workspace_String_duplicate( name_arg, name_len );
          
4000620c:	40 00 14 5b 	call  4000b378 <_Workspace_String_duplicate>
  
40006210:	90 10 00 18 	mov  %i0, %o0
                                 
  if ( name == NULL ) {
                                              
40006214:	b8 92 20 00 	orcc  %o0, 0, %i4
                             
40006218:	02 80 00 36 	be  400062f0 <sem_open+0x19c>
                 <== NEVER TAKEN
4000621c:	01 00 00 00 	nop 
                                          
  return (POSIX_Semaphore_Control *)
                                 
40006220:	40 00 06 c3 	call  40007d2c <_Objects_Allocate_unprotected>

40006224:	90 17 62 d0 	or  %i5, 0x2d0, %o0
                           
  if ( the_semaphore == NULL ) {
                                     
40006228:	80 a2 20 00 	cmp  %o0, 0
                                   
4000622c:	02 80 00 36 	be  40006304 <sem_open+0x1b0>
                 <== NEVER TAKEN
40006230:	82 10 20 01 	mov  1, %g1
                                   
  information->local_table[ index ] = the_object;
                    
40006234:	c4 12 20 0a 	lduh  [ %o0 + 0xa ], %g2
                      
  the_semaphore->open_count = 1;
                                     
40006238:	c2 22 20 30 	st  %g1, [ %o0 + 0x30 ]
                       
  _POSIX_Semaphore_Initialize( &the_semaphore->Semaphore, name, value );

4000623c:	b0 02 20 10 	add  %o0, 0x10, %i0
                           
  the_semaphore->linked = true;
                                      
40006240:	c2 2a 20 2c 	stb  %g1, [ %o0 + 0x2c ]
                      
  sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC;
             
40006244:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
40006248:	82 10 63 e7 	or  %g1, 0x3e7, %g1	! 5d367fe7 <RAM_END+0x1cf67fe7>

4000624c:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006250:	c0 22 20 14 	clr  [ %o0 + 0x14 ]
                           
40006254:	ba 17 62 d0 	or  %i5, 0x2d0, %i5
                           
40006258:	c2 22 20 10 	st  %g1, [ %o0 + 0x10 ]
                       
4000625c:	83 28 a0 02 	sll  %g2, 2, %g1
                              
40006260:	c0 22 20 18 	clr  [ %o0 + 0x18 ]
                           
40006264:	c0 22 20 1c 	clr  [ %o0 + 0x1c ]
                           
40006268:	c0 22 20 20 	clr  [ %o0 + 0x20 ]
                           
4000626c:	f8 22 20 24 	st  %i4, [ %o0 + 0x24 ]
                       
40006270:	f6 22 20 28 	st  %i3, [ %o0 + 0x28 ]
                       
    the_object->name.name_p = name;
                                  
40006274:	f8 22 20 0c 	st  %i4, [ %o0 + 0xc ]
                        
  information->local_table[ index ] = the_object;
                    
40006278:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2
                       
4000627c:	d0 20 80 01 	st  %o0, [ %g2 + %g1 ]
                        
  _RTEMS_Unlock_allocator();
                                         
40006280:	40 00 00 a8 	call  40006520 <_RTEMS_Unlock_allocator>
      
40006284:	01 00 00 00 	nop 
                                          
    value
                                                            
  );
                                                                 

                                                                     
  _Objects_Allocator_unlock();
                                       
  return sem;
                                                        
}
                                                                    
40006288:	81 c7 e0 08 	ret 
                                          
4000628c:	81 e8 00 00 	restore 
                                      
40006290:	40 00 00 a4 	call  40006520 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006294:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
      rtems_set_errno_and_return_value(
                              
40006298:	40 00 20 44 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
4000629c:	fa 07 bf fc 	ld  [ %fp + -4 ], %i5
                         <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error(
                   
  Objects_Get_by_name_error error
                                    
)
                                                                    
{
                                                                    
  _Assert( (size_t) error < RTEMS_ARRAY_SIZE( _POSIX_Get_by_name_error_table ) );

  return _POSIX_Get_by_name_error_table[ error ];
                    
400062a0:	bb 2f 60 02 	sll  %i5, 2, %i5
                              <== NOT EXECUTED
400062a4:	03 10 00 40 	sethi  %hi(0x40010000), %g1
                   <== NOT EXECUTED
400062a8:	82 10 63 00 	or  %g1, 0x300, %g1	! 40010300 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
400062ac:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1
                        <== NOT EXECUTED
400062b0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400062b4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400062b8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
400062bc:	40 00 00 99 	call  40006520 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
400062c0:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
      rtems_set_errno_and_return_value( EEXIST, SEM_FAILED );
        
400062c4:	40 00 20 39 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
400062c8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
400062cc:	82 10 20 11 	mov  0x11, %g1	! 11 <_TLS_Alignment+0x10>
     <== NOT EXECUTED
400062d0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400062d4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400062d8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_set_errno_and_return_value( EINVAL, SEM_FAILED );
          
400062dc:	40 00 20 33 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
400062e0:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
400062e4:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
400062e8:	10 bf ff e6 	b  40006280 <sem_open+0x12c>
                  <== NOT EXECUTED
400062ec:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
    rtems_set_errno_and_return_value( ENOMEM, SEM_FAILED );
          
400062f0:	40 00 20 2e 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
400062f4:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
400062f8:	82 10 20 0c 	mov  0xc, %g1
                                 <== NOT EXECUTED
400062fc:	10 bf ff e1 	b  40006280 <sem_open+0x12c>
                  <== NOT EXECUTED
40006300:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
    _Workspace_Free( name );
                                         
40006304:	40 00 14 08 	call  4000b324 <_Workspace_Free>
              <== NOT EXECUTED
40006308:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
    rtems_set_errno_and_return_value( ENOSPC, SEM_FAILED );
          
4000630c:	40 00 20 27 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
40006310:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
40006314:	82 10 20 1c 	mov  0x1c, %g1
                                <== NOT EXECUTED
40006318:	10 bf ff da 	b  40006280 <sem_open+0x12c>
                  <== NOT EXECUTED
4000631c:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED

                                                                     
===============================================================================
40005fec <sem_post>:
                                                 
#include <rtems/posix/semaphoreimpl.h>
                               

                                                                     
#include <limits.h>
                                                  

                                                                     
int sem_post( sem_t *_sem )
                                          
{
                                                                    
40005fec:	9d e3 bf 78 	save  %sp, -136, %sp
                          
  ISR_Level             level;
                                       
  Thread_queue_Context  queue_context;
                               
  Thread_queue_Heads   *heads;
                                       
  unsigned int          count;
                                       

                                                                     
  POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
                           
40005ff0:	80 a6 20 00 	cmp  %i0, 0
                                   
40005ff4:	02 80 00 27 	be  40006090 <sem_post+0xa4>
                  <== NEVER TAKEN
40005ff8:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
40005ffc:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40006000:	82 10 63 e7 	or  %g1, 0x3e7, %g1
                           
40006004:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006008:	80 a0 40 02 	cmp  %g1, %g2
                                 
4000600c:	12 80 00 21 	bne  40006090 <sem_post+0xa4>
                 <== NEVER TAKEN
40006010:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40006014:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  return psr;
                                                        
40006018:	88 10 00 01 	mov  %g1, %g4
                                 
  sem = _Sem_Get( &_sem->_Semaphore );
                               
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_ISR_disable( &queue_context, level );
        
  _Sem_Queue_acquire_critical( sem, &queue_context );
                

                                                                     
  heads = sem->Queue.Queue.heads;
                                    
4000601c:	d0 06 20 0c 	ld  [ %i0 + 0xc ], %o0
                        
  count = sem->count;
                                                

                                                                     
  if ( __predict_true( heads == NULL && count < SEM_VALUE_MAX ) ) {
  
40006020:	80 a2 20 00 	cmp  %o0, 0
                                   
40006024:	12 80 00 0d 	bne  40006058 <sem_post+0x6c>
                 
40006028:	c4 06 20 18 	ld  [ %i0 + 0x18 ], %g2
                       
4000602c:	07 1f ff ff 	sethi  %hi(0x7ffffc00), %g3
                   
40006030:	86 10 e3 fe 	or  %g3, 0x3fe, %g3	! 7ffffffe <RAM_END+0x3fbffffe>

40006034:	80 a0 c0 02 	cmp  %g3, %g2
                                 
40006038:	0a 80 00 07 	bcs  40006054 <sem_post+0x68>
                 <== NEVER TAKEN
4000603c:	84 00 a0 01 	inc  %g2
                                      <== NOT EXECUTED
    sem->count = count + 1;
                                          
40006040:	c4 26 20 18 	st  %g2, [ %i0 + 0x18 ]
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40006044:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006048:	01 00 00 00 	nop 
                                          
    _Sem_Queue_release( sem, level, &queue_context );
                
    return 0;
                                                        
4000604c:	81 c7 e0 08 	ret 
                                          
40006050:	91 e8 20 00 	restore  %g0, 0, %o0
                          
  }
                                                                  

                                                                     
  if ( __predict_true( heads != NULL ) ) {
                           
40006054:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006058:	02 80 00 14 	be  400060a8 <sem_post+0xbc>
                  <== NEVER TAKEN
4000605c:	3b 10 00 3e 	sethi  %hi(0x4000f800), %i5
                   
    const Thread_queue_Operations *operations;
                       
    Thread_Control *first;
                                           

                                                                     
    _Thread_queue_Context_set_ISR_level( &queue_context, level );
    
    operations = SEMAPHORE_TQ_OPERATIONS;
                            
    first = ( *operations->first )( heads );
                         
40006060:	ba 17 63 e8 	or  %i5, 0x3e8, %i5	! 4000fbe8 <_Thread_queue_Operations_priority>

40006064:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1
                       
40006068:	9f c0 40 00 	call  %g1
                                     
4000606c:	c8 27 bf dc 	st  %g4, [ %fp + -36 ]
                        

                                                                     
    _Thread_queue_Extract_critical(
                                  
40006070:	96 07 bf dc 	add  %fp, -36, %o3
                            
40006074:	94 10 00 08 	mov  %o0, %o2
                                 
40006078:	92 10 00 1d 	mov  %i5, %o1
                                 
4000607c:	90 06 20 0c 	add  %i0, 0xc, %o0
                            
40006080:	40 00 0e 5d 	call  400099f4 <_Thread_queue_Extract_critical>

40006084:	b0 10 20 00 	clr  %i0
                                      
      &sem->Queue.Queue,
                                             
      operations,
                                                    
      first,
                                                         
      &queue_context
                                                 
    );
                                                               
    return 0;
                                                        
40006088:	81 c7 e0 08 	ret 
                                          
4000608c:	81 e8 00 00 	restore 
                                      
  POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
                           
40006090:	40 00 20 18 	call  4000e0f0 <__errno>
                      <== NOT EXECUTED
40006094:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40006098:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
4000609c:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
400060a0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060a4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

400060a8:	82 10 00 04 	mov  %g4, %g1
                                 <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400060ac:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400060b0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  }
                                                                  

                                                                     
  _Sem_Queue_release( sem, level, &queue_context );
                  
  rtems_set_errno_and_return_minus_one( EOVERFLOW );
                 
400060b4:	40 00 20 0f 	call  4000e0f0 <__errno>
                      <== NOT EXECUTED
400060b8:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
400060bc:	82 10 20 8b 	mov  0x8b, %g1
                                <== NOT EXECUTED
400060c0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
}
                                                                    
400060c4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400060c8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400060cc <sem_trywait>:
                                              
#endif
                                                               

                                                                     
#include <rtems/posix/semaphoreimpl.h>
                               

                                                                     
int sem_trywait( sem_t *_sem )
                                       
{
                                                                    
400060cc:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  Sem_Control          *sem;
                                         
  Thread_queue_Context  queue_context;
                               
  ISR_Level             level;
                                       
  unsigned int          count;
                                       

                                                                     
  POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
                           
400060d0:	80 a6 20 00 	cmp  %i0, 0
                                   
400060d4:	02 80 00 1a 	be  4000613c <sem_trywait+0x70>
               <== NEVER TAKEN
400060d8:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
400060dc:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
400060e0:	82 10 63 e7 	or  %g1, 0x3e7, %g1
                           
400060e4:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
400060e8:	80 a0 40 02 	cmp  %g1, %g2
                                 
400060ec:	12 80 00 14 	bne  4000613c <sem_trywait+0x70>
              <== NEVER TAKEN
400060f0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

400060f4:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  sem = _Sem_Get( &_sem->_Semaphore );
                               
  _Thread_queue_Context_initialize( &queue_context );
                
  _Thread_queue_Context_ISR_disable( &queue_context, level );
        
  _Sem_Queue_acquire_critical( sem, &queue_context );
                

                                                                     
  count = sem->count;
                                                
400060f8:	c4 06 20 18 	ld  [ %i0 + 0x18 ], %g2
                       
  if ( __predict_true( count > 0 ) ) {
                               
400060fc:	80 a0 a0 00 	cmp  %g2, 0
                                   
40006100:	02 80 00 07 	be  4000611c <sem_trywait+0x50>
               
40006104:	84 00 bf ff 	add  %g2, -1, %g2
                             
    sem->count = count - 1;
                                          
40006108:	c4 26 20 18 	st  %g2, [ %i0 + 0x18 ]
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000610c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006110:	01 00 00 00 	nop 
                                          
    _Sem_Queue_release( sem, level, &queue_context );
                
    return 0;
                                                        
40006114:	81 c7 e0 08 	ret 
                                          
40006118:	91 e8 20 00 	restore  %g0, 0, %o0
                          
4000611c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40006120:	01 00 00 00 	nop 
                                          
  } else {
                                                           
    _Sem_Queue_release( sem, level, &queue_context );
                
    rtems_set_errno_and_return_minus_one( EAGAIN );
                  
40006124:	40 00 1f f3 	call  4000e0f0 <__errno>
                      
40006128:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  
4000612c:	82 10 20 0b 	mov  0xb, %g1
                                 
40006130:	c2 22 00 00 	st  %g1, [ %o0 ]
                              
  }
                                                                  
}
                                                                    
40006134:	81 c7 e0 08 	ret 
                                          
40006138:	81 e8 00 00 	restore 
                                      
  POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
                           
4000613c:	40 00 1f ed 	call  4000e0f0 <__errno>
                      <== NOT EXECUTED
40006140:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40006144:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40006148:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000614c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006150:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006320 <sem_unlink>:
                                               
#endif
                                                               

                                                                     
#include <rtems/posix/semaphoreimpl.h>
                               

                                                                     
int sem_unlink( const char *name )
                                   
{
                                                                    
40006320:	9d e3 bf 98 	save  %sp, -104, %sp
                          
  _RTEMS_Lock_allocator();
                                           
40006324:	40 00 00 7a 	call  4000650c <_RTEMS_Lock_allocator>
        
40006328:	39 10 00 4c 	sethi  %hi(0x40013000), %i4
                   
  return (POSIX_Semaphore_Control *) _Objects_Get_by_name(
           
4000632c:	96 07 bf fc 	add  %fp, -4, %o3
                             
40006330:	94 10 20 00 	clr  %o2
                                      
40006334:	92 10 00 18 	mov  %i0, %o1
                                 
40006338:	40 00 07 ca 	call  40008260 <_Objects_Get_by_name>
         
4000633c:	90 17 22 d0 	or  %i4, 0x2d0, %o0
                           
  Objects_Get_by_name_error  error;
                                  

                                                                     
  _Objects_Allocator_lock();
                                         

                                                                     
  the_semaphore = _POSIX_Semaphore_Get_by_name( name, NULL, &error );

  if ( the_semaphore == NULL ) {
                                     
40006340:	ba 92 20 00 	orcc  %o0, 0, %i5
                             
40006344:	02 80 00 0c 	be  40006374 <sem_unlink+0x54>
                <== NEVER TAKEN
40006348:	92 10 00 1d 	mov  %i5, %o1
                                 
  _Objects_Namespace_remove( 
                                        
4000634c:	40 00 07 bb 	call  40008238 <_Objects_Namespace_remove>
    
40006350:	90 17 22 d0 	or  %i4, 0x2d0, %o0
                           
    _Objects_Allocator_unlock();
                                     
    rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) );

  }
                                                                  

                                                                     
  _POSIX_Semaphore_Namespace_remove( the_semaphore );
                
  the_semaphore->linked = false;
                                     
40006354:	c0 2f 60 2c 	clrb  [ %i5 + 0x2c ]
                          
  _POSIX_Semaphore_Delete( the_semaphore );
                          
40006358:	90 10 00 1d 	mov  %i5, %o0
                                 
4000635c:	40 00 1a 71 	call  4000cd20 <_POSIX_Semaphore_Delete>
      
40006360:	b0 10 20 00 	clr  %i0
                                      
  _RTEMS_Unlock_allocator();
                                         
40006364:	40 00 00 6f 	call  40006520 <_RTEMS_Unlock_allocator>
      
40006368:	01 00 00 00 	nop 
                                          
  _Objects_Allocator_unlock();
                                       
  return 0;
                                                          
}
                                                                    
4000636c:	81 c7 e0 08 	ret 
                                          
40006370:	81 e8 00 00 	restore 
                                      
40006374:	40 00 00 6b 	call  40006520 <_RTEMS_Unlock_allocator>
      <== NOT EXECUTED
40006378:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) );

4000637c:	40 00 20 0b 	call  4000e3a8 <__errno>
                      <== NOT EXECUTED
40006380:	fa 07 bf fc 	ld  [ %fp + -4 ], %i5
                         <== NOT EXECUTED
40006384:	bb 2f 60 02 	sll  %i5, 2, %i5
                              <== NOT EXECUTED
40006388:	03 10 00 40 	sethi  %hi(0x40010000), %g1
                   <== NOT EXECUTED
4000638c:	82 10 63 00 	or  %g1, 0x300, %g1	! 40010300 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
40006390:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1
                        <== NOT EXECUTED
40006394:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
40006398:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000639c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006154 <sem_wait>:
                                                 
#endif
                                                               

                                                                     
#include <rtems/posix/semaphoreimpl.h>
                               

                                                                     
int sem_wait( sem_t *sem )
                                           
{
                                                                    
40006154:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
                            
40006158:	80 a6 20 00 	cmp  %i0, 0
                                   
4000615c:	02 80 00 0c 	be  4000618c <sem_wait+0x38>
                  <== NEVER TAKEN
40006160:	03 17 4d 9f 	sethi  %hi(0x5d367c00), %g1
                   
40006164:	c4 06 00 00 	ld  [ %i0 ], %g2
                              
40006168:	82 10 63 e7 	or  %g1, 0x3e7, %g1
                           
4000616c:	82 1e 00 01 	xor  %i0, %g1, %g1
                            
40006170:	80 a0 40 02 	cmp  %g1, %g2
                                 
40006174:	12 80 00 06 	bne  4000618c <sem_wait+0x38>
                 <== NEVER TAKEN
40006178:	90 06 20 04 	add  %i0, 4, %o0
                              
  _Semaphore_Wait( &sem->_Semaphore );
                               
4000617c:	40 00 0b d3 	call  400090c8 <_Semaphore_Wait>
              
40006180:	b0 10 20 00 	clr  %i0
                                      
  return 0;
                                                          
}
                                                                    
40006184:	81 c7 e0 08 	ret 
                                          
40006188:	81 e8 00 00 	restore 
                                      
  POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
                            
4000618c:	40 00 1f d9 	call  4000e0f0 <__errno>
                      <== NOT EXECUTED
40006190:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
40006194:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40006198:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000619c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400061a0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000f994 <sigemptyset>:
                                              
#include <rtems/seterr.h>
                                            

                                                                     
int sigemptyset(
                                                     
  sigset_t   *set
                                                    
)
                                                                    
{
                                                                    
4000f994:	9d e3 bf a0 	save  %sp, -96, %sp
                           
  if ( !set )
                                                        
4000f998:	80 a6 20 00 	cmp  %i0, 0
                                   
4000f99c:	02 80 00 05 	be  4000f9b0 <sigemptyset+0x1c>
               <== NEVER TAKEN
4000f9a0:	01 00 00 00 	nop 
                                          
    rtems_set_errno_and_return_minus_one( EINVAL );
                  

                                                                     
  *set = 0;
                                                          
4000f9a4:	c0 26 00 00 	clr  [ %i0 ]
                                  
  return 0;
                                                          
}
                                                                    
4000f9a8:	81 c7 e0 08 	ret 
                                          
4000f9ac:	91 e8 20 00 	restore  %g0, 0, %o0
                          
    rtems_set_errno_and_return_minus_one( EINVAL );
                  
4000f9b0:	40 00 00 90 	call  4000fbf0 <__errno>
                      <== NOT EXECUTED
4000f9b4:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
4000f9b8:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
4000f9bc:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4000f9c0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000f9c4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED