Stacktrace - Unwinding

Stacktrace - Unwinding

Post by Kuma » Wed, 22 Jan 1997 04:00:00



Hello,

I am trying to get the stack trace of an execution. I can get the frame
information from the unwind table but I need to know how I can get the
symbolic names of the modules executed in the frame. I also need to get
information about the source file where the symbol is defined. Solaris
provides dlopen/dlsym and func_dladdr to get a mapping of function
address to symbol information. Does anybody know of any equivalent or how
I go about getting the above information.

Any lead towards this would be greatly appreciated.

Thanks

- Kumar.

 
 
 

Stacktrace - Unwinding

Post by Avi Cohen Stua » Thu, 23 Jan 1997 04:00:00


   Hello,

   I am trying to get the stack trace of an execution. I can get the frame
   information from the unwind table but I need to know how I can get the
   symbolic names of the modules executed in the frame. I also need to get
   information about the source file where the symbol is defined. Solaris
   provides dlopen/dlsym and func_dladdr to get a mapping of function
   address to symbol information. Does anybody know of any equivalent or how
   I go about getting the above information.

In /usr/lib/libcl.a there is a function called U_STACK_TRACE(). It
takes no parameters and dumps the stack trace to stderr (I think)...

Avi.
--
A. B. Cohen Stuart, M.Sc.    |Baron van Nagellstraat 89|Phone: +31 342 428229
Software Engineer            |P.O. Box 143             |Fax  : +31 342 428787

Baan Research & Development  |The Netherlands          |Home : +31 33 4728194

 
 
 

Stacktrace - Unwinding

Post by Stan Siel » Thu, 23 Jan 1997 04:00:00


Kumar asks about stack trace, and Avi mentions U_STACK_TRACE...

<plug>
I used our AVATAR product, a PA-RISC disassembler/patcher/mini-assembler to
look at U_STACK_TRACE. (http://www.allegro.com/avatar.hpux.info.html for info)

It shows that U_STACK_TRACE does have a single parameter (in R26), but
it's apparently ignored (stored into memory, and never accessed).

Here's the decompile of U_STACK_TRACE, and the start of the decompile
for U_TRAP_STACK_TRACE, which is called by U_STACK_TRACE.  In
U_TRAP_STACK_TRACE you can see interesting calls to routines that
presumably get the information you are looking for.

My "test2" program was a trivial C program that called U_STACK_TRACE.

----------------------------------cut here for AVATAR output----------------
AVATAR 95A                        Copyright (c) 1995 Allegro Consultants, Inc.

For help, type: HELP

AVATAR: open test2
opening file: test2 ...
FILE TYPE : sharable, executable SOM
Found 215 unwind entries.
Searching 574 symbol dictionary entries
Sorting 560 symbols

AVATAR[test2]: dc U_STACK_TRACE

U_STACK_TRACE                     3 3 CODE      UNIVERSAL      b58     9693

         ; *********************************************************************
[C]    9690:      6bc23fd9 STW       2,-20(0,30)      ; $ffffffec, sp-20
[C]    9694:      6fc30080 STWM      3,64(0,30)       ; $40,       sp+64
[C]    9698:      6bc43f89 STW       4,-60(0,30)      ; $ffffffc4, sp-60
[C]    969c:      37df3f81 LDO       -64(30),31       ; $ffffffc0, sp-64
[C]    96a0:      6bda3f39 STW       26,-100(0,30)    ; $ffffff9c, sp-100

[SS: notice the store of R26...but sp-100 is never accessed after this]

[C]    96a4:      4be33fd9 LDW       -20(0,31),3
[C]    96a8:      4be43fd1 LDW       -24(0,31),4
[C]    96ac:      d4601c1e DEPI      0,31,2,3
[C]    96b0:      6bdf3f99 STW       31,-52(0,30)     ; $ffffffcc, sp-52
[C]    96b4:      e8401e4c BL        U_is_archived_pc,2 ; b5e0
[C]    96b8:      0803025a COPY      3,26

[C]    96bc:      d4801c1e DEPI      0,31,2,4
[C]    96c0:      87802048 COMIB,=   0,28,.+0x2c      ; 96ec
[C]    96c4:      6bc03f91 STW       0,-56(0,30)      ; $ffffffc8, sp-56
[C]    96c8:      08030244 COPY      3,4
[C]    96cc:      4bda3f99 LDW       -52(0,30),26     ; $ffffffcc, sp-52
[C]    96d0:      4bd83f91 LDW       -56(0,30),24     ; $ffffffc8, sp-56
[C]    96d4:      e8400888 BL        U_TRAP_STACK_TRACE,2 ; 9b20
[C]    96d8:      08040259 COPY      4,25

[C]    96dc:      4bc23f59 LDW       -84(0,30),2      ; $ffffffac, sp-84
[C]    96e0:      4bc43f89 LDW       -60(0,30),4      ; $ffffffc4, sp-60
[C]    96e4:      e840c000 BV        0(2)

[C]    96e8:      4fc33f81 LDWM      -64(0,30),3      ; $ffffffc0, sp-64
         ;    ---------------------------------------------------------------

[SS: I noticed that U_STACK_TRACE calls U_TRAP_STACK_TRACE (with 3 ]
[SS: parameters), so let's look at that routine...                 ]

AVATAR[test2]: dc U_TRAP_STACK_TRACE

U_TRAP_STACK_TRACE                3 3 CODE      UNIVERSAL      be4     9b23

         ; *********************************************************************
[C]    9b20:     >6bc23fd9 STW       2,-20(0,30)      ; $ffffffec, sp-20
[C]    9b24:      6fc30c00 STWM      3,1536(0,30)     ; $600,      sp+1536
[C]    9b28:      6bc43409 STW       4,-1532(0,30)    ; $fffffa04, sp-1532
[C]    9b2c:      6bc53411 STW       5,-1528(0,30)    ; $fffffa08, sp-1528
[C]    9b30:      6bc63419 STW       6,-1524(0,30)    ; $fffffa0c, sp-1524
[C]    9b34:      6bc73421 STW       7,-1520(0,30)    ; $fffffa10, sp-1520
[C]    9b38:      6bc83429 STW       8,-1516(0,30)    ; $fffffa14, sp-1516
[C]    9b3c:      081a0245 COPY      26,5
[C]    9b40:      08190246 COPY      25,6
[C]    9b44:      6bc03681 STW       0,-1216(0,30)    ; $fffffb40, sp-1216
[C]    9b48:      08180247 COPY      24,7
[C]    9b4c:      e84019f4 BL        U_GET_ARGV0,2    ; b84c
[C]    9b50:      6bc03689 STW       0,-1212(0,30)    ; $fffffb44, sp-1212

[C]    9b54:      081c0244 COPY      28,4
[C]    9b58:      e8401664 BL        U_FINDPATH,2     ; b690
[C]    9b5c:      081c025a COPY      28,26

[C]    9b60:      089c3884 COMCLR,<> 28,4,4
[C]    9b64:      34040002 LDI       1,4
[C]    9b68:      081c0243 COPY      28,3
[C]    9b6c:      e840194c BL        U__GET_FRAME_INFO,2 ; b818
[C]    9b70:      37da35f9 LDO       -1284(30),26     ; $fffffafc, sp-1284

[C]    9b74:      4bda3641 LDW       -1248(0,30),26   ; $fffffb20, sp-1248
[C]    9b78:      4bdf3659 LDW       -1236(0,30),31   ; $fffffb2c, sp-1236
[C]    9b7c:      6bda34e1 STW       26,-1424(0,30)   ; $fffffa70, sp-1424
[C]    9b80:      0806025a COPY      6,26
[C]    9b84:      6bdf34e9 STW       31,-1420(0,30)   ; $fffffa74, sp-1420
[C]    9b88:      e8401068 BL        U_get_space_id,2 ; a3c4
[C]    9b8c:      6bc53601 STW       5,-1280(0,30)    ; $fffffb00, sp-1280

[C]    9b90:      6bdc3609 STW       28,-1276(0,30)   ; $fffffb04, sp-1276
[C]    9b94:      0806025a COPY      6,26
[C]    9b98:      6bc73621 STW       7,-1264(0,30)    ; $fffffb10, sp-1264
[C]    9b9c:      e840147c BL        U_is_archived_pc,2 ; b5e0

...

</plug>

Stan Sieler

 
 
 

Stacktrace - Unwinding

Post by David Pete » Fri, 24 Jan 1997 04:00:00


Avi Cohen Stuart wrote:

> In article <Pine.SUN.3.90.970121181027.16655B-100000@ws7> Kumar <mku...@compuware.com> writes:

>    Hello,

>    I am trying to get the stack trace of an execution. I can get the frame
>    information from the unwind table but I need to know how I can get the
>    symbolic names of the modules executed in the frame. I also need to get
>    information about the source file where the symbol is defined. Solaris
>    provides dlopen/dlsym and func_dladdr to get a mapping of function
>    address to symbol information. Does anybody know of any equivalent or how
>    I go about getting the above information.

> In /usr/lib/libcl.a there is a function called U_STACK_TRACE(). It
> takes no parameters and dumps the stack trace to stderr (I think)...

Here's a little utility (attached) which you might be able to munge into
something useful.

--
David Peter                   | It happens sometimes
Insignia Solutions plc        | People just explode
da...@isltd.insignia.com      | Natural Causes
Voice: +44 (0)1494 453351     | http://www.insignia.com/

[ cfile.c 5K ]
/* program for testing stack unwinding.
 *
 * DP Peter April 1994
 *
 * compile using:
 *
 *      cc cfile.c dfile.c sfile.s -o cfile -Wl,-a,archive -lcl -Ae -g; chmod +x cfile
 *
 * sccs id:     @(#)cfile.c     1.11 04/21/94
 */

#include <stdio.h>
#include <memory.h>

typedef struct current_frame_def {
        unsigned cur_frsize;
        unsigned cursp;
        unsigned currls;
        unsigned currlo;
        unsigned curdp;
        unsigned toprp;
        unsigned topmrp;
        unsigned topsr0;
        unsigned topsr4;
        unsigned r3;
        unsigned cur_r19;

} UWREC;

typedef struct utable {
        unsigned unwind_table_start;
        unsigned unwind_table_end;

} UTABLE;

/* externals */
extern int dcall();
extern int wrapc();
extern int get_cspace();
extern int get_dspace();
extern int get_space();
extern int *gen_ocall();
extern UTABLE U_get_unwind_table();
extern int U_get_unwind_entry();
extern int U_get_previous_frame();

/* forwards */
int display_stack_trace();
int icall();
int main();
int gen_stack_trace();
int get_NextFrame();

display_stack_trace(int dummy)
{
        char str[1024];

        sprintf(str, "\n");
        gen_stack_trace(str);
        printf("%s\n",str);

}

icall(int (*fptr)())
{
        (*fptr)();

}

char array[1024];

int *m_ptr;
int *s_ptr;
int *e_ptr;

main(int argc, char **argv)
{
        unsigned cspace = get_cspace();
        unsigned dspace = get_dspace();
        UTABLE utab = U_get_unwind_table(0);
        int stat;
        int (*dptr)() = &dcall;
        int (*iptr)() = &icall;
        int (*optr)();

        /* table for functions to display unwind info for */
        static int (*ftable[])() = {get_cspace, get_dspace, get_space, wrapc, display_stack_trace,
                                        main, gen_stack_trace, get_NextFrame, dcall, icall, 0};
        static char *fname[] = {"get_cspace", "get_dspace", "get_space", "wrapc", "display_stack_trace",
                                        "main", "gen_stack_trace", "get_NextFrame", "dcall", "icall", 0};
        int index;

        /* set up pointers to uninitialised and malloc'd data areas */
        m_ptr = (int *)malloc(1024);
        s_ptr = (int *)array;

        /* display the code and data spaces */
        printf("code space 0x%08x\n",cspace);
        printf("data space 0x%08x\n",dspace);

        /* display the unwind table location */
        printf("unwind table [0x%08x...0x%08x]\n", utab.unwind_table_start, utab.unwind_table_end);

        for (index = 0; fname[index] != 0; index++) {

                int *p_start, *p_end, *callinfo_1, *callinfo_2;

                /* display the function address */
                printf("Function '%s' @ %08x.%08x\n", fname[index], get_space(ftable[index]), ftable[index]);

                /* get the unwind table entry for the function */
                stat = U_get_unwind_entry(ftable[index], cspace, utab.unwind_table_start, utab.unwind_table_end);
                printf("\tunwind table offset for '%s' @ 0x%08x\n", fname[index], stat);

                /* unwind descriptors consist of 4-word entries: .PROC (1 word), .PROCEND (1 word) and .CALLINFO (2 words) */
                p_start = (int *)stat, p_end = (int *)(stat + 4), callinfo_1 = (int *)(stat + 8), callinfo_2 = (int *)(stat + 12);
                printf("\tunwind table data for '%s'\n", fname[index]);
                printf("\t\t.PROC        0x%08x\n", *p_start);
                printf("\t\t.PROCEND     0x%08x\n", *p_end);
                printf("\t\t.CALLINFO_1  0x%08x\n", *callinfo_1);
                printf("\t\t.CALLINFO_2  0x%08x\n", *callinfo_2);
        }
        printf("\n");

        /* see what we get for something malloc'd and something static */
        printf("Data '%s' @ %08x.%08x\n", "static", get_space(s_ptr), s_ptr);
        stat = U_get_unwind_entry(s_ptr, cspace, utab.unwind_table_start, utab.unwind_table_end);
        printf("\tunwind table offset for '%s' @ 0x%08x\n", "static", stat);

        printf("Data '%s' @ %08x.%08x\n", "malloc", get_space(m_ptr), m_ptr);
        stat = U_get_unwind_entry(m_ptr, cspace, utab.unwind_table_start, utab.unwind_table_end);
        printf("\tunwind table offset for '%s' @ 0x%08x\n", "malloc", stat);

        printf("\n");

        /* generate a version of 'dcall' in malloc'd data space and point optr at it so
        that it can be called. */
        e_ptr = gen_ocall(m_ptr);
        optr = (int (*)(int))m_ptr;

        printf("Function '%s' starts @ %08x.%08x, ends @ %08x.%08x\n", "ocall",
                        get_space(m_ptr), m_ptr, get_space(e_ptr), e_ptr);

        /* generate a dynamic unwind descriptor for 'ocall' but in the static space */
        *(s_ptr+0) = (int)m_ptr;
        *(s_ptr+1) = (int)e_ptr;
        *(s_ptr+2) = 0x00000008;
        *(s_ptr+3) = 0x00000008;

        printf("\n");

        /* finally do the stack trace using all the indirections we have */
        (*iptr)(&display_stack_trace);
        (*dptr)(&display_stack_trace);
        (*optr)(&display_stack_trace);

}

gen_stack_trace(outstr)
char *outstr;
{
        unsigned sp, pc, rp;
        UWREC rec1;
        int depth;

        sp = (unsigned)(&outstr + 9);
        pc = (* (int *) (sp - 20));
        rp = 0;

        rec1.currls = get_cspace();
        rec1.cursp = sp;
        rec1.currlo = pc;
        rec1.toprp = rp;
        rec1.curdp = 0;
        rec1.cur_frsize = 0;

        for (depth = 0; rec1.currlo; depth++) {
                sprintf(outstr, "%s (%2d) pc=0x%08x.0x%08x sr=0x%08x dp=0x%08x\n", outstr, depth,
                                get_space(rec1.currlo), rec1.currlo, rec1.currls, rec1.curdp);
                if (get_NextFrame(&rec1) == -1) {
                        return;
                }
        }
        U_STACK_TRACE();

}

int get_NextFrame(prec1)
UWREC *prec1;
{
        int stat;
        UWREC rec2;

        stat = U_get_previous_frame(prec1, &rec2);
        if (stat) {
                fprintf(stderr, "Stack_Trace: error (%d) while unwinding stack\n", stat);
                return (-1);
        }

        prec1->currlo                = rec2.currlo;
        prec1->cur_frsize    = rec2.cur_frsize;
        prec1->cursp         = rec2.cursp;
        prec1->currls                = rec2.currls;
        prec1->curdp         = rec2.curdp;

        return 0;

- Show quoted text -

}

[ sfile.s 3K ]
; auxiliary file for cfile.c
; sccs id @(#)sfile.s   1.10 04/21/94

        .space  $TEXT$
        .subspa $CODE$

; get the current code space value
        .export get_cspace,code
get_cspace
        .proc
        .callinfo
        .entry
        bv      0(2)
        .exit
        mfsp    sr4,r28
        .procend
;
; get the current data space value
        .export get_dspace,code
get_dspace
        .proc
        .callinfo
        .entry
        bv      0(2)
        .exit
        mfsp    sr5,r28
        .procend
;
; get the space value corresponding to an address
        .export get_space,code
get_space
        .proc
        .callinfo
        .entry
        bv      0(2)
        .exit
        ldsid   (0,26),28
        .procend
;
; put a function in data space to see if we can unwind it
        .SPACE  $PRIVATE$
        .SUBSPA $DATA$,QUAD=0,ALIGN=4,ACCESS=44,CODE_ONLY,SORT=24

        .export dcall,code
dcall
; synopsis:

;       void (*fptr) = &dcall;
;       (*fptr)(&function);
;
; so the address of 'function' gets passed to 'dcall' in r26
;
        .PROC
        .CALLINFO CALLER,FRAME=16,SAVE_RP
        .ENTRY
        STW     %r2,-20(0,%r30)
        LDO     64(%r30),%r30  
; go to 'wrapc' in code space
        LDIL    L'wrapc,%r1
        BLE     R'wrapc,(%sr4,%r1)
        COPY    %r31,%r2
        LDW     -84(0,%r30),%r2
        LDSID   (0,2),1
        MTSP    1,0
        BE      0(0,2)
        .EXIT
        LDO     -64(%r30),%r30
        .PROCEND ;out=28;

; define something after dcall so we can see it in the stack trace
        .export dcont,code
dcont
        nop

        .SPACE  $TEXT$
        .SUBSPA $CODE$,QUAD=0,ALIGN=4,ACCESS=44,CODE_ONLY,SORT=24

; wrapper to call C from 'dcall' above

        .export wrapc,code
wrapc
        .PROC
        .CALLINFO CALLER,FRAME=16,SAVE_RP
        .ENTRY
; we get here from 'dcall' with r26 as the address of
; the routine to call
        STW     %r2,-20(0,%r30)
        LDO     64(%r30),%r30  
; do the indirect call to the function address that was
; passed to 'dcall'
        STW     %r26,-100(0,%r30)
        LDW     -100(0,%r30),%r22
        BL      $$dyncall,%r31
        COPY    %r31,%r2      
; return to 'dcall' in data space
        LDW     -84(0,%r30),%r2
        LDSID   (0,2),1
        MTSP    1,0
        BE      0(0,2)
        .EXIT
        LDO     -64(%r30),%r30
        .PROCEND ;out=28;

; this replaces the call from U_get_previous_frame
; the value in r29 is the location of the unwind
; descriptor for 'calld' and the value of r28 is the
; space where the unwind table lives. This is in code
; space (sr4).
        .export _find_dyn_unwind_desc,code
_find_dyn_unwind_desc
        .proc
        .callinfo caller,frame=16,save_rp
        .entry
        STW     %r2,-20(0,%r30)
        LDO     64(%r30),%r30  
        STW     %r26,-100(0,%r30)
; find out where the unwind table is by calling
; U_get_unwind_table passing the current DP value
; as arg0. The start and end of the table (in code
; space) are returned in r28 and r29 respecvively.
        BL      U_get_unwind_table,r2
        copy    %r27,%r26
; get the unwind entry corresponding to the originally
; passed address
        ldw     -100(0,r30),r26
        mfsp    sr4,r25
        copy    r28,r24
        BL      U_get_unwind_entry,r2
        copy    r29,r23
; check for there being no entry at the specified address
; this is indicated by a return value of -1
        comibt,=,n      -1,r28,try_data_space
; return with the code space id in r28 and
; with the offset of the required unwind
; descriptor in r29
        copy    r28,r29
        mfsp    sr4,r28
        B,N     return
; try an unwind descriptor in data space. This is assumed to be
; for function 'ocall'.
try_data_space
        LDIL    L's_ptr,r1
        LDW     R's_ptr(r1),29
        mfsp    sr5,r28
return
        LDW     -84(0,%r30),%r2
        BV      0(2)
        .exit
        LDO     -64(%r30),%r30
        .procend

        .import $$dyncall,millicode
        .import U_get_unwind_table,code
        .import U_get_unwind_entry,code
        .import s_ptr,data
        .import m_ptr,data
        .end

[ dfile.c 3K ]
/* auxilliary file for cfile.c  */
/* sccs id      @(#)dfile.c     1.1 04/21/94            */

/* this file contains stuff for generating an 'online subroutine'
   which should be identical in operation to 'dcall' in sfile.s.
   This will be called 'ocall'. */

/* opcode defines */
#define HP800_LDO       0x0d
#define HP800_LDIL      0x08
#define HP800_BLE       0x39

/* some useful macros */
#define LOW_SIGN_EXT5(imm)                                              \
        ((((imm) & 0xf) << 1) | (((imm) & 0x10) ? 1:0))

#define LOW_SIGN_EXT11(imm)                                             \
        ((((imm) & 0x3ff) << 1) | (((imm) & 0x400) ? 1:0))

#define LOW_SIGN_EXT14(imm)                                             \
        ((((imm) & 0x1fff) << 1) | (((imm) & 0x2000) ? 1:0))

#define ASSEMBLE_3(imm)                                                 \
        ((((imm) & 0x4) ? 1:0) | (((imm) & 0x3) << 1))

#define ASSEMBLE_12(imm)                                                \
        ((((imm) & 0x800) ? 1:0) | (((imm) & 0x400) ? 4:0) |            \
        (((imm) & 0x3ff) << 3))

#define ASSEMBLE_17(imm)                                                \
        ((((imm) & 0x10000) ? 1:0) | (((imm) & 0xf800) << 5) |          \
        (((imm) & 0x400) ? 4:0) | (((imm) & 0x3ff) << 3))

#define ASSEMBLE_21(imm)                                                \
        ((((imm) & 0x100000) ? 1:0) | (((imm) & 0xffe00) >> 8) |        \
        (((imm) & 0x180) << 7) | (((imm) & 0x7c) << 14) |               \
        (((imm) & 0x03) << 12))

#define hp800_imm14instr(opc, dst, src, imm14)                          \
        (((opc) << 26) | ((src) << 21) | ((dst) << 16) | LOW_SIGN_EXT14(imm14))

#define hp800_imm21instr(opc, dst, imm21)                               \
        (((opc) << 26) | ((dst) << 21) | ASSEMBLE_21(imm21))

#define hp800_branchimm17(opc, cond, src, imm, nul)                     \
        (((opc) << 26) | ((src) << 21) | ASSEMBLE_17(imm) |             \
        ((nul) ? 2:0) | ((cond) << 13))

#define Hi21BitsOf(bigkonst)    (((long)(bigkonst)) >> 11)
#define Lo11BitsOf(bigkonst)    (((long)(bigkonst)) & 0x7ff)

#define OFFLINE_SPACE_ID        1

extern wrapc();

/* generate an online version of 'dcall' in malloc'd data space at opcodePtr.
   The function returns a pointer to the last instruction of the procodure. */
int *gen_ocall(int *opcodePtr)
{
        int *dest = (int *)wrapc;

        /* generate the online subroutine code. This should look like

                (6BC23FD9)      STW     %r2,-20(0,%r30)
                (37DE0080)      LDO     64(%r30),%r30
                                LDIL    L'wrapc,%r1
                                BLE     R'wrapc,(%sr4,%r1)
                (081F0242)      COPY    %r31,%r2
                (4BC23F59)      LDW     -84(0,%r30),%r2
                (004010A1)      LDSID   (0,2),1
                (00011820)      MTSP    1,0
                (E0400000)      BE      0(0,2)
                (37DE3F81)      LDO     -64(%r30),%r30

        */
        *opcodePtr++ = 0x6BC23FD9;
        *opcodePtr++ = 0x37DE0080;
        *opcodePtr++ = hp800_imm21instr(HP800_LDIL, 1, Hi21BitsOf(dest));
        *opcodePtr++ = hp800_branchimm17(HP800_BLE, OFFLINE_SPACE_ID, 1, Lo11BitsOf(dest)/4, 0);
        *opcodePtr++ = 0x081F0242;
        *opcodePtr++ = 0x4BC23F59;
        *opcodePtr++ = 0x004010A1;
        *opcodePtr++ = 0x00011820;
        *opcodePtr++ = 0xE0400000;
        *opcodePtr   = 0x37DE3F81;

        return opcodePtr;

- Show quoted text -

}

 
 
 

1. Attunity: %SYSTEM-W-UNWIND, unwind currently in progress

Dear Sirs

We are installing Attunity 3.2 in our development
server: OpenVMS 7.3 / TCPIP 5.1
and we are receive the message below in our logs.
We didnt understand the reason of this message and I
looked for some informaion at the Wizard and didnt
discover anythig.

$ HELP/MESSAGE unwind

 UNWIND,  unwind currently in progress

  Facility:     SYSTEM, System Services

  Explanation:  This status code is used as a call
argument for condition
                handlers called during the search of
the call stack during
                an unwind operation. The operating
system does not normally
                display this message.

  User Action:  Modify the source program, if
necessary, to detect and respond
                to the condition.

=====
==========================
Fbio dos Santos Cardoso
OpenVMS System Manager
Rio de Janeiro - Brazil

==========================

__________________________________________________
Do You Yahoo!?
Great stuff seeking new owners in Yahoo! Auctions!
http://auctions.yahoo.com

2. 8051 FAQ Update

3. stacktrace for HP_UX binaries

4. Use LXPic w/ Nettamer.. Is it possible ?

5. StackTrace also _fixes_ stack problems ??!!

6. slides class and other environments

7. StackTrace class, where did my exception get thrown?

8. Can't do the spelling (Key F7)

9. Exceptions without the StackTrace

10. Any function to get stacktrace?

11. source of stackTrace (tt)

12. help with 2.0.2 and stacktrace.c

13. Memory leak detection / stack unwind HP-UX