===============================================================================
4000bfc8 <rtems_stack_checker_begin_extension>:
                      
  return ( uint32_t ) ( per_cpu_envelope - &_Per_CPU_Information[ 0 ] );

4000bfc8:	07 33 33 33 	sethi  %hi(0xcccccc00), %g3
                   <== NOT EXECUTED
4000bfcc:	86 10 e0 cd 	or  %g3, 0xcd, %g3	! cccccccd <RAM_END+0x8c8ccccd>
<== NOT EXECUTED
4000bfd0:	03 10 00 5f 	sethi  %hi(0x40017c00), %g1
                   <== NOT EXECUTED
#endif
                                                               

                                                                     
  cpu_self_index = _Per_CPU_Get_index( cpu_self );
                   
  stack = &Stack_check_Interrupt_stack[ cpu_self_index ];
            

                                                                     
  if ( stack->area == NULL ) {
                                       
4000bfd4:	05 10 00 5a 	sethi  %hi(0x40016800), %g2
                   <== NOT EXECUTED
4000bfd8:	82 10 60 00 	mov  %g1, %g1
                                 <== NOT EXECUTED
4000bfdc:	84 10 a2 2c 	or  %g2, 0x22c, %g2
                           <== NOT EXECUTED
4000bfe0:	82 21 80 01 	sub  %g6, %g1, %g1
                            <== NOT EXECUTED
4000bfe4:	83 38 60 04 	sra  %g1, 4, %g1
                              <== NOT EXECUTED
4000bfe8:	82 58 40 03 	smul  %g1, %g3, %g1
                           <== NOT EXECUTED
4000bfec:	83 28 60 03 	sll  %g1, 3, %g1
                              <== NOT EXECUTED
4000bff0:	86 00 80 01 	add  %g2, %g1, %g3
                            <== NOT EXECUTED
4000bff4:	da 00 e0 04 	ld  [ %g3 + 4 ], %o5
                          <== NOT EXECUTED
4000bff8:	80 a3 60 00 	cmp  %o5, 0
                                   <== NOT EXECUTED
4000bffc:	22 80 00 04 	be,a   4000c00c <rtems_stack_checker_begin_extension+0x44>
<== NOT EXECUTED
4000c000:	d0 01 a0 08 	ld  [ %g6 + 8 ], %o0
                          
  }
                                                                  

                                                                     
#if defined(RTEMS_SMP)
                                               
  _Thread_Dispatch_enable( cpu_self );
                               
#endif
                                                               
}
                                                                    
4000c004:	81 c3 e0 08 	retl 
                                         
4000c008:	01 00 00 00 	nop 
                                          
    stack->area = cpu_self->interrupt_stack_low;
                     
4000c00c:	d0 20 e0 04 	st  %o0, [ %g3 + 4 ]
                          
    Stack_check_Dope_stack( stack );
                                 
4000c010:	92 10 20 a5 	mov  0xa5, %o1
                                
    stack->size = (size_t) ( (char *) cpu_self->interrupt_stack_high -

4000c014:	c8 01 a0 0c 	ld  [ %g6 + 0xc ], %g4
                        
4000c018:	88 21 00 08 	sub  %g4, %o0, %g4
                            
    Stack_check_Dope_stack( stack );
                                 
4000c01c:	94 10 00 04 	mov  %g4, %o2
                                 
    stack->size = (size_t) ( (char *) cpu_self->interrupt_stack_high -

4000c020:	c8 20 80 01 	st  %g4, [ %g2 + %g1 ]
                        
    Stack_check_Dope_stack( stack );
                                 
4000c024:	82 13 c0 00 	mov  %o7, %g1
                                 
4000c028:	40 00 09 9f 	call  4000e6a4 <memset>
                       
4000c02c:	9e 10 40 00 	mov  %g1, %o7
                                 

                                                                     
===============================================================================
400024cc <rtems_stack_checker_is_blown>:
                             

                                                                     
/*
                                                                   
 *  Check if blown
                                                   
 */
                                                                  
bool rtems_stack_checker_is_blown( void )
                            
{
                                                                    
400024cc:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_stack_checker_switch_extension( _Thread_Get_executing(), NULL );

400024d0:	d0 01 a0 20 	ld  [ %g6 + 0x20 ], %o0
                       <== NOT EXECUTED

                                                                     
  /*
                                                                 
   * The Stack Pointer and the Pattern Area are OK so return false.
  
   */
                                                                
  return false;
                                                      
}
                                                                    
400024d4:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  rtems_stack_checker_switch_extension( _Thread_Get_executing(), NULL );

400024d8:	7f ff ff bb 	call  400023c4 <rtems_stack_checker_switch_extension>
<== NOT EXECUTED
400024dc:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
}
                                                                    
400024e0:	81 c7 e0 08 	ret 
                                          
400024e4:	81 e8 00 00 	restore 
                                      

                                                                     
===============================================================================
400034d8 <rtems_stack_checker_report_usage>:
                         

                                                                     
void rtems_stack_checker_report_usage( void )
                        
{
                                                                    
400034d8:	9d e3 bf 98 	save  %sp, -104, %sp
                          <== NOT EXECUTED
  rtems_printer printer;
                                             
  rtems_print_printer_printk(&printer);
                              
400034dc:	40 00 09 e1 	call  40005c60 <rtems_print_printer_printk>
   <== NOT EXECUTED
400034e0:	90 07 bf f8 	add  %fp, -8, %o0
                             <== NOT EXECUTED
  rtems_stack_checker_report_usage_with_plugin( &printer );
          
400034e4:	7f ff ff df 	call  40003460 <rtems_stack_checker_report_usage_with_plugin>

400034e8:	90 07 bf f8 	add  %fp, -8, %o0
                             
}
                                                                    
400034ec:	81 c7 e0 08 	ret 
                                          
400034f0:	81 e8 00 00 	restore 
                                      

                                                                     
===============================================================================
40003460 <rtems_stack_checker_report_usage_with_plugin>:
             
 */
                                                                  

                                                                     
void rtems_stack_checker_report_usage_with_plugin(
                   
  const rtems_printer* printer
                                       
)
                                                                    
{
                                                                    
40003460:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  uint32_t cpu_max;
                                                  
  uint32_t cpu_index;
                                                

                                                                     
  rtems_printf(
                                                      
40003464:	13 10 00 46 	sethi  %hi(0x40011800), %o1
                   <== NOT EXECUTED
40003468:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4000346c:	40 00 0a 11 	call  40005cb0 <rtems_printf>
                 <== NOT EXECUTED
40003470:	92 12 61 40 	or  %o1, 0x140, %o1
                           <== NOT EXECUTED
     "                             STACK USAGE BY THREAD\n"
          
     "ID         NAME                  LOW        HIGH       CURRENT     AVAIL   USED\n"

  );
                                                                 

                                                                     
  /* iterate over all threads and dump the usage */
                  
  rtems_task_iterate(
                                                
40003474:	92 10 00 18 	mov  %i0, %o1
                                 
40003478:	11 10 00 0c 	sethi  %hi(0x40003000), %o0
                   
4000347c:	40 00 10 c4 	call  4000778c <rtems_task_iterate>
           
40003480:	90 12 22 74 	or  %o0, 0x274, %o0	! 40003274 <Stack_check_Dump_threads_usage>

    Stack_check_Dump_threads_usage,
                                  
    RTEMS_DECONST( rtems_printer *, printer )
                        
  );
                                                                 

                                                                     
  cpu_max = rtems_get_processor_count();
                             
40003484:	40 00 0f c4 	call  40007394 <rtems_get_processor_count>
    
40003488:	01 00 00 00 	nop 
                                          

                                                                     
  for ( cpu_index = 0; cpu_index < cpu_max; ++cpu_index ) {
          
4000348c:	b4 92 20 00 	orcc  %o0, 0, %i2
                             
40003490:	02 80 00 10 	be  400034d0 <rtems_stack_checker_report_usage_with_plugin+0x70>
<== NEVER TAKEN
40003494:	39 10 00 53 	sethi  %hi(0x40014c00), %i4
                   
  Stack_check_Dump_stack_usage(
                                      
40003498:	37 10 00 46 	sethi  %hi(0x40011800), %i3
                   
4000349c:	b8 17 20 1c 	or  %i4, 0x1c, %i4
                            
  for ( cpu_index = 0; cpu_index < cpu_max; ++cpu_index ) {
          
400034a0:	ba 10 20 00 	clr  %i5
                                      
  Stack_check_Dump_stack_usage(
                                      
400034a4:	b6 16 e1 c8 	or  %i3, 0x1c8, %i3
                           
400034a8:	96 10 00 1d 	mov  %i5, %o3
                                 
400034ac:	90 10 00 1c 	mov  %i4, %o0
                                 
400034b0:	98 10 00 18 	mov  %i0, %o4
                                 
400034b4:	94 10 00 1b 	mov  %i3, %o2
                                 
400034b8:	7f ff ff 29 	call  4000315c <Stack_check_Dump_stack_usage>
 
400034bc:	92 10 20 00 	clr  %o1
                                      
  for ( cpu_index = 0; cpu_index < cpu_max; ++cpu_index ) {
          
400034c0:	ba 07 60 01 	inc  %i5
                                      
400034c4:	80 a6 80 1d 	cmp  %i2, %i5
                                 
400034c8:	12 bf ff f8 	bne  400034a8 <rtems_stack_checker_report_usage_with_plugin+0x48>
<== NEVER TAKEN
400034cc:	b8 07 20 08 	add  %i4, 8, %i4
                              
      &Stack_check_Interrupt_stack[ cpu_index ],
                     
      cpu_index,
                                                     
      printer
                                                        
    );
                                                               
  }
                                                                  
}
                                                                    
400034d0:	81 c7 e0 08 	ret 
                                          
400034d4:	81 e8 00 00 	restore 
                                      

                                                                     
===============================================================================
4000c030 <rtems_stack_checker_switch_extension>:
                     
 */
                                                                  
void rtems_stack_checker_switch_extension(
                           
  Thread_Control *running RTEMS_UNUSED,
                              
  Thread_Control *heir RTEMS_UNUSED
                                  
)
                                                                    
{
                                                                    
4000c030:	9d e3 bf 80 	save  %sp, -128, %sp
                          <== NOT EXECUTED
    if ( sp < the_stack->area ) {
                                    
4000c034:	fa 06 20 d0 	ld  [ %i0 + 0xd0 ], %i5
                       <== NOT EXECUTED
4000c038:	b8 07 60 08 	add  %i5, 8, %i4
                              <== NOT EXECUTED
4000c03c:	13 10 00 4f 	sethi  %hi(0x40013c00), %o1
                   <== NOT EXECUTED
4000c040:	94 10 20 10 	mov  0x10, %o2
                                <== NOT EXECUTED
4000c044:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
4000c048:	80 a7 80 1d 	cmp  %fp, %i5
                                 <== NOT EXECUTED
4000c04c:	0a 80 00 0e 	bcs  4000c084 <rtems_stack_checker_switch_extension+0x54>
<== NOT EXECUTED
4000c050:	92 12 60 6c 	or  %o1, 0x6c, %o1
                            
4000c054:	40 00 09 2f 	call  4000e510 <memcmp>
                       
4000c058:	01 00 00 00 	nop 
                                          
    if ( sp > (the_stack->area + the_stack->size) ) {
                
4000c05c:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1
                       
4000c060:	82 07 40 01 	add  %i5, %g1, %g1
                            
4000c064:	80 a7 80 01 	cmp  %fp, %g1
                                 
4000c068:	18 80 00 0a 	bgu  4000c090 <rtems_stack_checker_switch_extension+0x60>
<== NEVER TAKEN
4000c06c:	b6 10 00 08 	mov  %o0, %i3
                                 
   */
                                                                
  sp_ok = Stack_check_Frame_pointer_in_range( running );
             

                                                                     
  pattern_ok = Stack_check_Is_pattern_valid( running );
              

                                                                     
  if ( !sp_ok || !pattern_ok ) {
                                     
4000c070:	80 a2 20 00 	cmp  %o0, 0
                                   
4000c074:	12 80 00 08 	bne  4000c094 <rtems_stack_checker_switch_extension+0x64>

4000c078:	11 10 00 4e 	sethi  %hi(0x40013800), %o0
                   
    Stack_check_report_blown_task( running, pattern_ok );
            
  }
                                                                  
}
                                                                    
4000c07c:	81 c7 e0 08 	ret 
                                          
4000c080:	81 e8 00 00 	restore 
                                      
4000c084:	40 00 09 23 	call  4000e510 <memcmp>
                       <== NOT EXECUTED
4000c088:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4000c08c:	b6 10 00 08 	mov  %o0, %i3
                                 <== NOT EXECUTED
  printk("BLOWN STACK!!!\n");
                                        
4000c090:	11 10 00 4e 	sethi  %hi(0x40013800), %o0
                   <== NOT EXECUTED
4000c094:	7f ff e3 3d 	call  40004d88 <printk>
                       
4000c098:	90 12 23 90 	or  %o0, 0x390, %o0	! 40013b90 <test_state_strings+0x14>

  printk("task control block: 0x%08" PRIxPTR "\n", (intptr_t) running);

4000c09c:	92 10 00 18 	mov  %i0, %o1
                                 
4000c0a0:	11 10 00 4e 	sethi  %hi(0x40013800), %o0
                   
4000c0a4:	7f ff e3 39 	call  40004d88 <printk>
                       
4000c0a8:	90 12 23 a0 	or  %o0, 0x3a0, %o0	! 40013ba0 <test_state_strings+0x24>

  printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
  
4000c0ac:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1
                          
4000c0b0:	11 10 00 4e 	sethi  %hi(0x40013800), %o0
                   
4000c0b4:	7f ff e3 35 	call  40004d88 <printk>
                       
4000c0b8:	90 12 23 c0 	or  %o0, 0x3c0, %o0	! 40013bc0 <test_state_strings+0x44>

  printk(
                                                            
4000c0bc:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1
                        
4000c0c0:	11 10 00 4e 	sethi  %hi(0x40013800), %o0
                   
4000c0c4:	7f ff e3 31 	call  40004d88 <printk>
                       
4000c0c8:	90 12 23 d8 	or  %o0, 0x3d8, %o0	! 40013bd8 <test_state_strings+0x5c>

  _Thread_Get_name(running, name, sizeof(name));
                     
4000c0cc:	94 10 20 20 	mov  0x20, %o2
                                
4000c0d0:	92 07 bf e0 	add  %fp, -32, %o1
                            
4000c0d4:	40 00 07 c0 	call  4000dfd4 <_Thread_Get_name>
             
4000c0d8:	90 10 00 18 	mov  %i0, %o0
                                 
  printk("task name string: %s\n", name);
                            
4000c0dc:	92 07 bf e0 	add  %fp, -32, %o1
                            
4000c0e0:	11 10 00 4e 	sethi  %hi(0x40013800), %o0
                   
4000c0e4:	7f ff e3 29 	call  40004d88 <printk>
                       
4000c0e8:	90 12 23 f0 	or  %o0, 0x3f0, %o0	! 40013bf0 <test_state_strings+0x74>

    (unsigned long) stack->size,
                                     
4000c0ec:	d2 06 20 cc 	ld  [ %i0 + 0xcc ], %o1
                       
    (intptr_t) stack->area,
                                          
4000c0f0:	d4 06 20 d0 	ld  [ %i0 + 0xd0 ], %o2
                       
  printk(
                                                            
4000c0f4:	96 02 80 09 	add  %o2, %o1, %o3
                            
4000c0f8:	11 10 00 4f 	sethi  %hi(0x40013c00), %o0
                   
4000c0fc:	7f ff e3 23 	call  40004d88 <printk>
                       
4000c100:	90 12 20 08 	or  %o0, 8, %o0	! 40013c08 <test_state_strings+0x8c>

  if (!pattern_ok) {
                                                 
4000c104:	80 a6 e0 00 	cmp  %i3, 0
                                   
4000c108:	12 80 00 05 	bne  4000c11c <rtems_stack_checker_switch_extension+0xec>
<== ALWAYS TAKEN
4000c10c:	96 07 60 18 	add  %i5, 0x18, %o3
                           
4000c110:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1
                        <== NOT EXECUTED
4000c114:	7f ff ea 5d 	call  40006a88 <_Terminate>
                   
4000c118:	90 10 20 08 	mov  8, %o0
                                   
    printk(
                                                          
4000c11c:	94 10 00 1c 	mov  %i4, %o2
                                 
4000c120:	92 10 20 10 	mov  0x10, %o1
                                
4000c124:	11 10 00 4f 	sethi  %hi(0x40013c00), %o0
                   
4000c128:	7f ff e3 18 	call  40004d88 <printk>
                       
4000c12c:	90 12 20 38 	or  %o0, 0x38, %o0	! 40013c38 <test_state_strings+0xbc>

4000c130:	10 bf ff f9 	b  4000c114 <rtems_stack_checker_switch_extension+0xe4>

4000c134:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1