===============================================================================
40006e74 <rtems_stack_checker_begin_extension>:
                      

                                                                     
void rtems_stack_checker_begin_extension( Thread_Control *executing )

{
                                                                    
40006e74:	9d e3 bf a0 	save  %sp, -96, %sp
                           
#endif
                                                               

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

                                                                     
  if ( stack->area == NULL ) {
                                       
40006e78:	03 10 00 68 	sethi  %hi(0x4001a000), %g1
                   
40006e7c:	84 10 61 a4 	or  %g1, 0x1a4, %g2	! 4001a1a4 <Stack_check_Interrupt_stack>

40006e80:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3
                          
40006e84:	80 a0 e0 00 	cmp  %g3, 0
                                   
40006e88:	22 80 00 04 	be,a   40006e98 <rtems_stack_checker_begin_extension+0x24>

40006e8c:	f0 01 a0 08 	ld  [ %g6 + 8 ], %i0
                          
  }
                                                                  

                                                                     
#if defined(RTEMS_SMP)
                                               
  _Thread_Dispatch_enable( cpu_self );
                               
#endif
                                                               
}
                                                                    
40006e90:	81 c7 e0 08 	ret 
                                          
40006e94:	81 e8 00 00 	restore 
                                      
    stack->size = (size_t) ( (char *) cpu_self->interrupt_stack_high -

40006e98:	f4 01 a0 0c 	ld  [ %g6 + 0xc ], %i2
                        
40006e9c:	b4 26 80 18 	sub  %i2, %i0, %i2
                            
    stack->area = cpu_self->interrupt_stack_low;
                     
40006ea0:	f0 20 a0 04 	st  %i0, [ %g2 + 4 ]
                          
  return memcmp(
                                                     
40006ea4:	94 10 20 10 	mov  0x10, %o2
                                
    stack->size = (size_t) ( (char *) cpu_self->interrupt_stack_high -

40006ea8:	f4 20 61 a4 	st  %i2, [ %g1 + 0x1a4 ]
                      
  return memcmp(
                                                     
40006eac:	90 10 00 18 	mov  %i0, %o0
                                 
40006eb0:	13 10 00 4d 	sethi  %hi(0x40013400), %o1
                   
40006eb4:	40 00 2c b6 	call  4001218c <memcmp>
                       
40006eb8:	92 12 60 fc 	or  %o1, 0xfc, %o1	! 400134fc <Stack_check_Sanity_pattern>

    if ( !Stack_check_Is_sanity_pattern_valid( stack ) ) {
           
40006ebc:	80 a2 20 00 	cmp  %o0, 0
                                   
40006ec0:	12 80 00 05 	bne  40006ed4 <rtems_stack_checker_begin_extension+0x60>
<== NEVER TAKEN
40006ec4:	b4 06 bf f0 	add  %i2, -16, %i2
                            
  memset(
                                                            
40006ec8:	b2 10 20 a5 	mov  0xa5, %i1
                                
40006ecc:	40 00 2d 15 	call  40012320 <memset>
                       
40006ed0:	91 ee 20 10 	restore  %i0, 0x10, %o0
                       
40006ed4:	13 12 53 95 	sethi  %hi(0x494e5400), %o1
                   <== NOT EXECUTED
40006ed8:	90 10 20 08 	mov  8, %o0
                                   <== NOT EXECUTED
40006edc:	40 00 17 5b 	call  4000cc48 <_Terminate>
                   <== NOT EXECUTED
40006ee0:	92 12 60 52 	or  %o1, 0x52, %o1
                            <== NOT EXECUTED
40006ee4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40006ee8 <rtems_stack_checker_switch_extension>:
                     
 */
                                                                  
void rtems_stack_checker_switch_extension(
                           
  Thread_Control *running,
                                           
  Thread_Control *heir
                                               
)
                                                                    
{
                                                                    
40006ee8:	9d e3 bf 80 	save  %sp, -128, %sp
                          
    if ( sp < the_stack->area ) {
                                    
40006eec:	fa 06 20 d0 	ld  [ %i0 + 0xd0 ], %i5
                       
40006ef0:	80 a7 80 1d 	cmp  %fp, %i5
                                 
40006ef4:	0a 80 00 19 	bcs  40006f58 <rtems_stack_checker_switch_extension+0x70>
<== NEVER TAKEN
40006ef8:	94 10 20 10 	mov  0x10, %o2
                                
40006efc:	39 10 00 4d 	sethi  %hi(0x40013400), %i4
                   
40006f00:	90 10 00 1d 	mov  %i5, %o0
                                 
40006f04:	40 00 2c a2 	call  4001218c <memcmp>
                       
40006f08:	92 17 20 fc 	or  %i4, 0xfc, %o1
                            
    if ( sp > (the_stack->area + the_stack->size) ) {
                
40006f0c:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1
                       
40006f10:	82 07 40 01 	add  %i5, %g1, %g1
                            
40006f14:	80 a7 80 01 	cmp  %fp, %g1
                                 
40006f18:	18 80 00 15 	bgu  40006f6c <rtems_stack_checker_switch_extension+0x84>
<== NEVER TAKEN
40006f1c:	b6 10 00 08 	mov  %o0, %i3
                                 
#else
                                                                
  sp_ok = Stack_check_Frame_pointer_in_range( running );
             

                                                                     
  pattern_ok = Stack_check_Is_sanity_pattern_valid( &running->Start.Initial_stack );


                                                                     
  if ( !sp_ok || !pattern_ok ) {
                                     
40006f20:	80 a2 20 00 	cmp  %o0, 0
                                   
40006f24:	12 80 00 12 	bne  40006f6c <rtems_stack_checker_switch_extension+0x84>

40006f28:	03 10 00 68 	sethi  %hi(0x4001a000), %g1
                   
  }
                                                                  
#endif
                                                               

                                                                     
  stack = &Stack_check_Interrupt_stack[ _SMP_Get_current_processor() ];


                                                                     
  if ( stack->area != NULL && !Stack_check_Is_sanity_pattern_valid( stack ) ) {

40006f2c:	d0 00 61 a8 	ld  [ %g1 + 0x1a8 ], %o0	! 4001a1a8 <Stack_check_Interrupt_stack+0x4>

40006f30:	80 a2 20 00 	cmp  %o0, 0
                                   
40006f34:	02 80 00 07 	be  40006f50 <rtems_stack_checker_switch_extension+0x68>
<== NEVER TAKEN
40006f38:	94 10 20 10 	mov  0x10, %o2
                                
  return memcmp(
                                                     
40006f3c:	40 00 2c 94 	call  4001218c <memcmp>
                       
40006f40:	92 17 20 fc 	or  %i4, 0xfc, %o1
                            
  if ( stack->area != NULL && !Stack_check_Is_sanity_pattern_valid( stack ) ) {

40006f44:	80 a2 20 00 	cmp  %o0, 0
                                   
40006f48:	12 80 00 2c 	bne  40006ff8 <rtems_stack_checker_switch_extension+0x110>
<== NEVER TAKEN
40006f4c:	13 12 53 95 	sethi  %hi(0x494e5400), %o1
                   
    rtems_fatal(
                                                     
      RTEMS_FATAL_SOURCE_STACK_CHECKER,
                              
      rtems_build_name( 'I', 'N', 'T', 'R' )
                         
    );
                                                               
  }
                                                                  
}
                                                                    
40006f50:	81 c7 e0 08 	ret 
                                          
40006f54:	81 e8 00 00 	restore 
                                      
40006f58:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
40006f5c:	13 10 00 4d 	sethi  %hi(0x40013400), %o1
                   <== NOT EXECUTED
40006f60:	40 00 2c 8b 	call  4001218c <memcmp>
                       <== NOT EXECUTED
40006f64:	92 12 60 fc 	or  %o1, 0xfc, %o1	! 400134fc <Stack_check_Sanity_pattern>
<== NOT EXECUTED
40006f68:	b6 10 00 08 	mov  %o0, %i3
                                 <== NOT EXECUTED
  printk("BLOWN STACK!!!\n");
                                        
40006f6c:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40006f70:	7f ff f2 86 	call  40003988 <printk>
                       
40006f74:	90 12 20 20 	or  %o0, 0x20, %o0	! 40013420 <rtems_filesystem_null_handlers+0x44>

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

40006f78:	92 10 00 18 	mov  %i0, %o1
                                 
40006f7c:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40006f80:	7f ff f2 82 	call  40003988 <printk>
                       
40006f84:	90 12 20 30 	or  %o0, 0x30, %o0	! 40013430 <rtems_filesystem_null_handlers+0x54>

  printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
  
40006f88:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1
                          
40006f8c:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40006f90:	7f ff f2 7e 	call  40003988 <printk>
                       
40006f94:	90 12 20 50 	or  %o0, 0x50, %o0	! 40013450 <rtems_filesystem_null_handlers+0x74>

  printk(
                                                            
40006f98:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1
                        
40006f9c:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40006fa0:	7f ff f2 7a 	call  40003988 <printk>
                       
40006fa4:	90 12 20 68 	or  %o0, 0x68, %o0	! 40013468 <rtems_filesystem_null_handlers+0x8c>

  _Thread_Get_name(running, name, sizeof(name));
                     
40006fa8:	94 10 20 20 	mov  0x20, %o2
                                
40006fac:	92 07 bf e0 	add  %fp, -32, %o1
                            
40006fb0:	40 00 12 07 	call  4000b7cc <_Thread_Get_name>
             
40006fb4:	90 10 00 18 	mov  %i0, %o0
                                 
  printk("task name string: %s\n", name);
                            
40006fb8:	92 07 bf e0 	add  %fp, -32, %o1
                            
40006fbc:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40006fc0:	7f ff f2 72 	call  40003988 <printk>
                       
40006fc4:	90 12 20 80 	or  %o0, 0x80, %o0	! 40013480 <rtems_filesystem_null_handlers+0xa4>

    (unsigned long) stack->size,
                                     
40006fc8:	d2 06 20 cc 	ld  [ %i0 + 0xcc ], %o1
                       
    (intptr_t) stack->area,
                                          
40006fcc:	d4 06 20 d0 	ld  [ %i0 + 0xd0 ], %o2
                       
  printk(
                                                            
40006fd0:	96 02 80 09 	add  %o2, %o1, %o3
                            
40006fd4:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40006fd8:	7f ff f2 6c 	call  40003988 <printk>
                       
40006fdc:	90 12 20 98 	or  %o0, 0x98, %o0	! 40013498 <rtems_filesystem_null_handlers+0xbc>

  if (!pattern_ok) {
                                                 
40006fe0:	80 a6 e0 00 	cmp  %i3, 0
                                   
40006fe4:	12 80 00 08 	bne  40007004 <rtems_stack_checker_switch_extension+0x11c>
<== ALWAYS TAKEN
40006fe8:	96 07 60 10 	add  %i5, 0x10, %o3
                           
40006fec:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1
                        <== NOT EXECUTED
40006ff0:	40 00 17 16 	call  4000cc48 <_Terminate>
                   
40006ff4:	90 10 20 08 	mov  8, %o0
                                   
40006ff8:	90 10 20 08 	mov  8, %o0
                                   <== NOT EXECUTED
40006ffc:	40 00 17 13 	call  4000cc48 <_Terminate>
                   <== NOT EXECUTED
40007000:	92 12 60 52 	or  %o1, 0x52, %o1
                            <== NOT EXECUTED
    printk(
                                                          
40007004:	94 10 00 1d 	mov  %i5, %o2
                                 
40007008:	92 10 20 10 	mov  0x10, %o1
                                
4000700c:	11 10 00 4d 	sethi  %hi(0x40013400), %o0
                   
40007010:	7f ff f2 5e 	call  40003988 <printk>
                       
40007014:	90 12 20 c8 	or  %o0, 0xc8, %o0	! 400134c8 <rtems_filesystem_null_handlers+0xec>

40007018:	10 bf ff f6 	b  40006ff0 <rtems_stack_checker_switch_extension+0x108>

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