Verdix Exception Traceback history

Verdix Exception Traceback history

[Walt Barnes]

My company is currently evaluating the Verdix compile
on Sun platform.  One problem we have run into is 
that when an exception is raised the only traceback
history that is printed is 

  Main Program Abandon Exception ________

Other compilers I have used provided a text description
of all the subprograms and line numbers the exception 
was propergated thru.  

How do I get the Verdix compiler to do this?


Walt Barnes  Software Engineer
Melbourne, Fl 

Re: Verdix Exception Traceback history

[Bob Duff]

In article <388@hathor.css.gov>, Walt Barnes <walt@hathor.CSS.GOV> wrote:
>Other compilers I have used provided a text description
>of all the subprograms and line numbers the exception 
>was propergated thru.  
>
>How do I get the Verdix compiler to do this?

I believe you can get the debugger (a.db?) to do this.

- Bob
-- 
Bob Duff                                bobduff@inmet.com
Oak Tree Software, Inc.
Ada 9X Mapping/Revision Team (Intermetrics, Inc.)

Re: Verdix Exception Traceback history

[Esther Lumsdon]

Walt Barnes (walt@hathor.CSS.GOV) wrote:
: My company is currently evaluating the Verdix compile
: on Sun platform.  One problem we have run into is 
: that when an exception is raised the only traceback
: history that is printed is 

:   Main Program Abandon Exception ________

You can get this information in the debugger, a.db.  Do these commands in
the debugger:
a.db executable
bx
set signal all g
set stack [look this up in the manual -- I'm blanking on this]
g  (to run the program)
After you hit the exception, look at the stack.  It shows how you
propagated to this exception.

Customers doing an evaluation usually have the right to call tech support
to ask these sorts of questions.  Talk to the salesperson to see whether
you should call Sun support or Rational Software (Verdix) support.
--
-- Esther Lumsdon, speaking only for myself     esther@cybernetics.net
   Seeking C/C++/Ada/Unix programming job in Raleigh/RTP, NC area 
   Finally living where the sky is Carolina blue!

Re: Verdix Exception Traceback history

[Kevin Cline]

I suggest calling Alsys/TeleSoft in San Diego and getting a copy
of the TeleSoft Ada Compiler (Not Alsys AdaWorld!).  I spent 3 years
using both the Telesoft Compiler (on Suns) and the Verdix Compiler 
(on SGI) and found the Telesoft Compiler with IEEE Posix bindings
a much better environment.  The Verdix debugger is truly weird.

Re: Verdix Exception Traceback history

[Corey Ashford]

Esther Lumsdon (esther@cybernetics.net) wrote:
: Walt Barnes (walt@hathor.CSS.GOV) wrote:
: : My company is currently evaluating the Verdix compile
: : on Sun platform.  One problem we have run into is 
: : that when an exception is raised the only traceback
: : history that is printed is 

: :   Main Program Abandon Exception ________

: You can get this information in the debugger, a.db.  Do these commands in
: the debugger:
: a.db executable
: bx
: set signal all g
: set stack [look this up in the manual -- I'm blanking on this]

The right incantation is:

set except_stack

Also, use the "bx" command only if you want to break on every exception.

- Corey

Internet: corey@rational.com
Sneakernet: down_the_hall!right_at_the_mens_room!past_the_stain_on_the_wall!...
Rational Software Corporation
1600 N.W. Compton Drive, Suite #357
Aloha, OR 97006
ph# (503) 690-1116 x6710

Re: Verdix Exception Traceback history

[Selig Ted]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 14855 bytes --]

>My company is currently evaluating the Verdix compile
>on Sun platform.  One problem we have run into is 
>that when an exception is raised the only traceback
>history that is printed is 
>
>  Main Program Abandon Exception ________
>
>Other compilers I have used provided a text description
>of all the subprograms and line numbers the exception 
>was propergated thru.  
>
>How do I get the Verdix compiler to do this?
>
>
>Walt Barnes  Software Engineer

Walt I have been in your shoes!   At one time I used the DEC Ada
compiler on a VAX and became very dependent on their beautiful
exception-crash stack trace. As you stated the Verdix compiler does not
provide this useful information.


NEAT SOLUTION:

A friend and I put together a stack trace program for Sun/OS SPARC
Verdix/Rational Ada(See below).  This exception handler is really a
signal handler.  Verdix/Rational uses various UNIX signals for some of
their predefined exceptions.  This exception handler catches these
signals, walks up the call stack, and prints each of the program
counters in the call stack.  Example output below:

======= Example START =========

Dead from

Signal: 4 Code 133  (Constraint Error)
...

  Program_Counter = 1218B4
  Program_Counter = 120704
  Program_Counter = 41C7E4
  Program_Counter = 25927C
  Program_Counter = 11851C


======= Example END =========

In the above example the Ada program crashed when an exception was
raised by the instruction at address 1218B4.  At that time the call
stack was 5 calls deep.

The program counters can then be used in the debugger to display each
of the procedure names in the call stack. To view the procedure name,
start the ASCII debugger. Do not start your program executing.  For
example type:

 $    a.db  my_ada_executable

When in the debugger type the commands:

>   wi 1218B4
>   vi

(wi = window instruction, vi = view source code). The cursor will be
over the line of code that  raised the exception.  Sometimes the
debugger gets confused and can not display the source line. In this
case I can usually find the line by trying each of the other program
counters until the source appears.  I then press the �I� debugger
command to show source and machine instructions and scroll down to the
next higher program counter.  In most cases I can find the bottom of
the call stack by continuing this manual method.

PROBLEMS:

There are several problems with this exception handler.  1) It only
catches the predefined exceptions (it does not catch user defined
exceptions).  2) When it catches a predefined exception the program
crashes (even if there is a handler for the exception.  3) The
procedure names are not printed by the handler (i.e. must use the
debugger)(this can be fixed by using the UNIX �nm -n� command to get
exe symbols; see code comments below). 4) This exception handler only
works with the SPARC.  5) Verdix/Rational does not deliver a program
like this with their compiler.

PLEASE IMPROVE:

I developed this exception handler to locate exceptions crashes. I
would like to improve it by adding the capability of logging the
exception and then jumping to the appropriate exception handler.  I
work in real-time systems and thus would like to log the exception for
debugging and still continue executing my real-time process.  I would
love help figuring how I can return control to the Ada run-time so that
the program can continue processing at the next exception handler. 

Verdix/Rational provides a pragma called RTS_INTERFACE that allows you
to substitute your own exception handler (your custom handler logs the
exception and call stack and then calls the predefined exception
handler). I have not been able to get this pragma to work for the
exception handler (even with Verdix support).


A SECOND SOLUTION:

The call stack can be viewed using the core dump file. The
Verdix/Rational Ada debugger version I am using (version 1.1) does not
work with core dumps (I hear that future versions will/do).  Instead
the dbx tool can be used to view the Ada call stack. To use dbx with a
core file follow the steps below.

  1) Attach the exception handler as shown in the example below. 
  2) Change the core file size limit in your .cshrc file.
 
       limit coredumpsize 10000

  3) Run program and recreate exception.  A core file will be created.
  4) Run dbx debugger in directory of the core and executable files.
 
       dbx <executable name>

  5) Type the dbx command �where� to see the call stack trace back.


Good Luck

Ted Selig
Software System Engineering
Delcom Inc.


ps

I am a happy Verdix/Rational Ada user.



---------  SAMPLE MAIN PROGRAM START ------------

with EXCEPTION_HANDLE_PKG;

procedure My_Big_Faulty_Program is

begin

  -- Attach signal handler.
  EXCEPTION_HANDLE_PKG.Attach;

  -- Execute Haystack with one needle exception. 

  Run_Stuff;

   ...

end My_Big_Faulty_Program ;

---------  SAMPLE MAIN PROGRAM END ------------


---------  EXCEPTION HANDLER PACKAGE START ------------

--- You may have to add Special Verdix libraries to get the packages
used in the body.
with LANGUAGE;
with CURRENT_EXCEPTION ;

package EXCEPTION_HANDLE_PKG is

  -- Start exception handling.
  procedure ATTACH ;

  -- Print Exception Information if available.
  procedure PRINT ;

  -- Return exception name if available.
  function NAME return string renames CURRENT_EXCEPTION.EXCEPTION_NAME
;

  -- Abort process and give core dump.
  function SYSTEM_ABORT return INTEGER ;

  function KILL(
    PID : INTEGER ;
    -- Description : Process ID to Send Signal to.
    SIG : INTEGER 
    -- Description : Signal to send.
    ) return INTEGER ;
    -- Description: Status returned.  0 = success. -1 = failure.
    
  function GETPID return INTEGER ;
  -- Description: Returns process ID.

private

  pragma INTERFACE(C, GETPID);
  pragma INTERFACE(C, KILL);

  pragma INTERFACE(C, SYSTEM_ABORT);
  pragma INTERFACE_NAME(SYSTEM_ABORT, LANGUAGE.C_SUBP_PREFIX &
"abort");

end EXCEPTION_HANDLE_PKG ;


with IFACE_INTR ;
with TEXT_IO ;
with SYSTEM ;
use SYSTEM ;
with UNIX_CALLS;
with ERRNO;
--with V_I_RAISE ;
with UNSIGNED_TYPES ;
use UNSIGNED_TYPES ;
with HEX ;
with raw_dump;
with unix_prcs ;
with a_strings;			use a_strings;

package body EXCEPTION_HANDLE_PKG is

  subtype NAME_T is string(1..100) ;

  BLANK_NAME_K : constant NAME_T := (others => ' ') ;

  type EXCEPTION_DATA_T is record 
    SET     : BOOLEAN := FALSE ; -- Flage set when data stored.
    NAME    : NAME_T := BLANK_NAME_K ; -- Name of exception.
    SIGNAL  : INTEGER := 0 ; -- The signal just raised.
    CODE    : INTEGER := 0 ; -- The subcode of the signal.
    CONTEXT : IFACE_INTR.SIGCONTEXT_T -- The Signal Context.
            := ( sc_onstack => 0, -- sigstack state to restore 
		 sc_mask    => 0, -- signal mask to restore 
		 sc_sp      => 0, -- sp to restore 
		 sc_pc      => 0, -- pc to retore 
		 sc_ps      => 0  -- psl to restore
		) ;
  end record ;

  LAST_EXCEPTION : EXCEPTION_DATA_T ;
  -- Description: Exception data is stored by handler until 
  --              "PRINT" called.
  
  package INT_IO is new TEXT_IO.INTEGER_IO(INTEGER) ;


  procedure PRINT is

  begin
  
    TEXT_IO.NEW_LINE ;

    if LAST_EXCEPTION.SET then

        TEXT_IO.PUT_LINE("Dead from " & LAST_EXCEPTION.NAME ) ;

	TEXT_IO.PUT("Signal: ") ;
	INT_IO.PUT( ITEM => LAST_EXCEPTION.SIGNAL, WIDTH => 0) ;
	TEXT_IO.PUT("  Code: ") ;
	INT_IO.PUT(ITEM => LAST_EXCEPTION.CODE, WIDTH => 0) ;
	TEXT_IO.NEW_LINE ;
	
	TEXT_IO.PUT("Context  SC_ONSTACK: ") ;
	INT_IO.PUT( LAST_EXCEPTION.CONTEXT.SC_ONSTACK, 
                    WIDTH => 0, BASE => 16 ) ;
	TEXT_IO.PUT("  SC_MASK: ") ;
	INT_IO.PUT( ITEM => LAST_EXCEPTION.CONTEXT.SC_MASK,  
                    WIDTH => 0, BASE => 16);
	TEXT_IO.PUT("  SC_SP: ") ;
	INT_IO.PUT( ITEM => LAST_EXCEPTION.CONTEXT.SC_SP,  
                    WIDTH => 0, BASE => 16 ) ;
	TEXT_IO.PUT("  SC_PC: ") ;
	INT_IO.PUT( ITEM => LAST_EXCEPTION.CONTEXT.SC_PC,  
                    WIDTH => 0, BASE => 16 ) ;
	TEXT_IO.PUT("  SC_PS: ") ;
	INT_IO.PUT( ITEM => LAST_EXCEPTION.CONTEXT.SC_PS,  
                    WIDTH => 0, BASE => 16 ) ;
	TEXT_IO.NEW_LINE ;

    else

        TEXT_IO.PUT_LINE(" No exception data stored." );

    end if ;

    TEXT_IO.NEW_LINE ;

  end PRINT ;

  procedure HANDLE(
    SIGNAL  : in INTEGER ; -- The signal just raised.
    CODE    : in INTEGER ; -- The subcode of the signal.
    CONTEXT : in IFACE_INTR.A_SIGCONTEXT -- The Signal Context.
    ) is

    pragma OPTIMIZE_CODE(OFF);

    LAST_SIGNAL : INTEGER ;
    LAST_MASK : INTEGER ;
    STATUS : INTEGER := 0;

--    EXCEPTION_NAME : constant string 
--      := NAME & BLANK_NAME_K ;

    SP : UNSIGNED_TYPES.UNSIGNED_INTEGER := 
           UNSIGNED_TYPES.UNSIGNED_INTEGER(CONTEXT.SC_SP) ;
    PC : UNSIGNED_TYPES.UNSIGNED_INTEGER := 
           UNSIGNED_TYPES.UNSIGNED_INTEGER(CONTEXT.SC_PC) ;
    LONGWORD : constant := 4 ;
    
    type Process_T is record
      PC : UNSIGNED_TYPES.UNSIGNED_INTEGER ;
      Offset : UNSIGNED_TYPES.UNSIGNED_INTEGER ;
      Symbol : string(1..132) ;
    end record ;
    
    Stack : array(1..20) of Process_T := ( others => ( 0, 0, (others
=>' ')));

  begin

  
    LAST_EXCEPTION := (
      SET     => TRUE,
      NAME    => BLANK_NAME_K, --EXCEPTION_NAME(NAME_T'range),
      SIGNAL  => SIGNAL,
      CODE    => CODE,
      CONTEXT => CONTEXT.all
      ) ;

    PRINT ;

    --raw_dump(SYSTEM.MEMORY_ADDRESS(SP-200),500);

    -- Walk the stack.
    Stack_Walk:
    for Level in Stack'range loop
    
      declare

        FP : UNSIGNED_TYPES.UNSIGNED_INTEGER ;
        for FP use at SYSTEM.MEMORY_ADDRESS(SP + 14 * LONGWORD);

      begin
      
        exit Stack_Walk when FP = 0;
        Stack(Level).PC := PC ;
        
        --TEXT_IO.PUT("SP; " & hex.unsigned_to_hex(SP,10)) ;
        TEXT_IO.PUT("  Program_Counter = " & hex.unsigned_to_hex(PC)) ;
        --TEXT_IO.PUT("  Frame_Pointer = " & hex.unsigned_to_hex(FP)) ;
        TEXT_IO.NEW_LINE ;

        declare
          NEXT_PC : UNSIGNED_TYPES.UNSIGNED_INTEGER ;
          for NEXT_PC use at SYSTEM.MEMORY_ADDRESS(SP + (15*LONGWORD));
        begin
          PC := NEXT_PC;
        end;

        SP := FP ;
      end ;

    end loop Stack_Walk;
    
    Get_Symbols:
    declare
      Program_Name : constant string := "crash" ; -- TBD
      Temporary_File : constant string := "tmp" ; -- TBD
       
      -- UNIX command to get symbol table.
      Command : constant string := "nm -n " & Program_Name &
                            --" | grep \"" T  \"" > " 
                            " > " & Temporary_File ;
                            
      Status_I : INTEGER ;

      function system( Command : a_string ) return INTEGER ;
      pragma interface(C, system);

      
    begin
    
      TEXT_IO.PUT_LINE(Command);
      Status_I := system(to_a(Command));
      TEXT_IO.PUT_LINE("STATUS = " & INTEGER'IMAGE(STATUS));

    end Get_Symbols ;
    
        
    --IFACE_INTR.SIGNAL(SIGTYPE => 17, HANDLER => IFACE_INTR.SIG_DFL) ;

    -- Enable all signals
    LAST_MASK := IFACE_INTR.sigsetmask(mask => IFACE_INTR.ENABLE_MASK);

 
    TEXT_IO.PUT("  Previous Signal Mask: ") ;
    INT_IO.PUT( ITEM => LAST_MASK, WIDTH => 0, BASE => 16);
    TEXT_IO.NEW_LINE;

    --STATUS := SYSTEM_ABORT ;
    --if STATUS < 0 then
    --  TEXT_IO.PUT("  System abort error number: " &
    --    ERRNO.ERROR_CODES'image(ERRNO.errno)) ;
    --end if ;

    TEXT_IO.PUT("  Process ID: " & INTEGER'image(GETPID));
    TEXT_IO.NEW_LINE(2);

    if KILL(PID => GETPID, SIG => 3) < 0 then
      TEXT_IO.PUT("  Sig 3 error number: " &
        ERRNO.ERROR_CODES'image(ERRNO.errno)) ;
    end if ; 
    if KILL(PID => GETPID, SIG => 10) < 0 then
      TEXT_IO.PUT("  Sig 10 error number: " &
        ERRNO.ERROR_CODES'image(ERRNO.errno)) ;
    end if ; 
    if KILL(PID => GETPID, SIG => 11) < 0 then
      TEXT_IO.PUT("  Sig 11 error number: " &
        ERRNO.ERROR_CODES'image(ERRNO.errno)) ;
    end if ; 
    if KILL(PID => GETPID, SIG => 19) < 0 then
      TEXT_IO.PUT("  Sig 19 error number: " &
        ERRNO.ERROR_CODES'image(ERRNO.errno)) ;
    end if ; 
    
    TEXT_IO.NEW_LINE;
    
    
    -- Reset the routine that catched the signal.
    --IFACE_INTR.SIGNAL(SIGTYPE => SIGNAL, HANDLER =>
IFACE_INTR.SIG_DFL) ;
    --IFACE_INTR.SIGNAL(SIGTYPE => 4, HANDLER => IFACE_INTR.SIG_DFL) ;
    -- Unblock the signal.
    --LAST_SIGNAL := IFACE_INTR.SIGBLOCK(16#7FFA_F007#) ;
    --UNIX_CALLS.SYS_EXIT(-1);

    --V_I_RAISE.raise_exception(identifier =>
    -- 
SYSTEM.MEMORY_ADDRESS(UNSIGNED_TYPES.UNSIGNED_INTEGER(CONTEXT.SC_PC)));

  exception

    when others =>

      -- Process will die if handler is exited via an exception.
      null ;

  end HANDLE ;

  procedure ATTACH is
  
    STATUS : INTEGER := 0 ;
    -- 0    on success.
    -- -1   on failure and sets errno to indicate the error.


    HANDLE_INFO_K : constant IFACE_INTR.SIGVEC_T :=
     (sv_handler => HANDLE'ADDRESS , -- signal handler 
      sv_mask    => IFACE_INTR.ENABLE_MASK, --ENABLE_MASK, 
                    -- signal mask to apply (disable all signals)
      sv_onstack => 16#00# -- if non-zero, take on signal stack
      ) ;
      
    SIGHUP : constant INTEGER := IFACE_INTR.SIGHUP ; -- hangup
    SIGUSR1 : constant INTEGER :=  30 ; -- user-defined signal 1
    SIGUSR2 : constant INTEGER :=  31 ; -- user-defined signal 2

    
      
  begin
  
    -- Set all signals. Note: SIGKILL and SIGSTOP are set 
    -- and ignored by UNIX.
    

      -- Contraint error.
      STATUS :=
        IFACE_INTR.SIGVEC(
          SIG  => IFACE_INTR.SIGILL, --illegal instruction (not reset)
4
          VEC  => HANDLE_INFO_K'address,
          OVEC => SYSTEM.NO_ADDR
        ) ;
     if ( STATUS /= 0)
     then

        TEXT_IO.PUT( "Signal SIGILL Status " ) ;
        INT_IO.PUT( ITEM => STATUS,  
                   WIDTH => 0, BASE => 16 ) ;
        TEXT_IO.NEW_LINE ;
     end if;


      -- Numeric error.
      STATUS :=
        IFACE_INTR.SIGVEC(
          SIG  => IFACE_INTR.SIGFPE, --floating point exception
          VEC  => HANDLE_INFO_K'address,
          OVEC => SYSTEM.NO_ADDR
        ) ;
     if ( STATUS /= 0)
     then
      TEXT_IO.PUT( "Signal SIGFPE Status " ) ;
      INT_IO.PUT( ITEM => STATUS,  
                  WIDTH => 0, BASE => 16 ) ;
      TEXT_IO.NEW_LINE ;
     end if;

      -- Storage error.
      STATUS :=
        IFACE_INTR.SIGVEC(
          SIG  => IFACE_INTR.SIGSEGV, -- 11
          VEC  => HANDLE_INFO_K'address,
          OVEC => SYSTEM.NO_ADDR
        ) ;

     if ( STATUS /= 0)
     then
       TEXT_IO.PUT( "Signal SIGSEGV Status " ) ;
       INT_IO.PUT( ITEM => STATUS,  
                   WIDTH => 0, BASE => 16 ) ;
       TEXT_IO.NEW_LINE ;
     end if;

  end ATTACH ;

end EXCEPTION_HANDLE_PKG ;

---------  EXCEPTION HANDLER PACKAGE END ------------

Re: Verdix Exception Traceback history

[Bennett, Chip (KTR) ~U]

> >My company is currently evaluating the Verdix compile
> >on Sun platform.  One problem we have run into is
> >that when an exception is raised the only traceback
> >history that is printed is
> >
> >  Main Program Abandon Exception ________
> >
> >Other compilers I have used provided a text description
> >of all the subprograms and line numbers the exception
> >was propergated thru.
> >
> >How do I get the Verdix compiler to do this?
> >
> >
> >Walt Barnes  Software Engineer
>
> ...
> ...
>
> A SECOND SOLUTION:
>
> The call stack can be viewed using the core dump file. The
> Verdix/Rational Ada debugger version I am using (version 1.1) does not
> work with core dumps (I hear that future versions will/do).  Instead
> the dbx tool can be used to view the Ada call stack. To use dbx with a
> core file follow the steps below.
>
>   1) Attach the exception handler as shown in the example below.
>   2) Change the core file size limit in your .cshrc file.
>
>        limit coredumpsize 10000
>
>   3) Run program and recreate exception.  A core file will be created.
>   4) Run dbx debugger in directory of the core and executable files.
>
>        dbx <executable name>
>
>   5) Type the dbx command RwhereS to see the call stack trace back.

Am I missing something here?  If re-running the program is an option, you
don't need a core dump.  Just run the program under a.db until you get the
exception, and use the "cs" subcommand to print out the call stack.

*****************************************************************
* Chip Bennett                  | BennettC@j64.stratcom.af.mil  *
* USSTRATCOM/J64213             | Voice (402)294-7360           *
* 901 SAC Blvd, Suite 2B24      | FAX   (402)294-7912           *
* Offutt AFB, NE 68113-6600     |                               *
*****************************************************************

Re: Verdix Exception Traceback history

[Selig Ted]

> > >My company is currently evaluating the Verdix compile
> > >on Sun platform.  One problem we have run into is
> > >that when an exception is raised the only traceback
> > >history that is printed is
> > >
> > >  Main Program Abandon Exception ________
> > >
> > >Other compilers I have used provided a text description
> > >of all the subprograms and line numbers the exception
> > >was propergated thru.
> > >
> > >How do I get the Verdix compiler to do this?
> > >
> > >
> > >Walt Barnes  Software Engineer
> >
> > ...
> > ...
> >
> > A SECOND SOLUTION:
> >
> > The call stack can be viewed using the core dump file. The
> > Verdix/Rational Ada debugger version I am using (version 1.1) does not
> > work with core dumps (I hear that future versions will/do).  Instead
> > the dbx tool can be used to view the Ada call stack. To use dbx with a
> > core file follow the steps below.
> >
...
> 
> Am I missing something here?  If re-running the program is an option, you
> don't need a core dump.  Just run the program under a.db until you get the
> exception, and use the "cs" subcommand to print out the call stack.
> 

Your idea works well when the extra memory and processing required by
the debugger is acceptable.

We do not perform System Test while executing in the debugger and we do
not deliver our product with the ada debugger.