Identifies the currently active routine calls.

    Format

      SHOW CALLS  [integer]

1  –  Parameters

 integer

    A decimal integer that specifies the number of routine calls to
    be identified. If you omit the parameter, the debugger identifies
    all routine calls for which it has information.

2  –  Qualifiers

2.1    /IMAGE

    Displays the image name for each active call on the call stack.

3  –  Description

    The SHOW CALLS command shows a traceback that lists the sequence
    of active routine calls that lead to the routine in which
    execution appears suspended. Each recursive routine call is shown
    in the display, that is, you can use the SHOW CALLS command to
    examine the chain of recursion.

    SHOW CALLS displays one line of information for each call frame
    on the call stack, starting with the most recent call. The top
    line identifies the currently executing routine, the next line
    identifies its caller, the following line identifies the caller
    of the caller, and so on.

    Even if your program contains no routine calls, the SHOW CALLS
    command displays an active call because your program has at least
    one stack frame built for it when it is first activated.

    On Alpha and Integrity server processors, you also usually
    see a system and sometimes a DCL base frame. Note that if the
    SHOW CALLS display shows no active calls, either your program
    has terminated or the call stack has been corrupted. As your
    program executes, whenever a call is made to a routine a new
    call frame is built on the stack(s) or in the register set.
    Each call frame stores information about the calling or current
    routine. For example, the frame PC value enables the SHOW CALLS
    command to symbolize to module and routine information. On Alpha
    processors, a routine invocation results in either a stack frame
    procedure (with a call frame on the memory stack), a register
    frame procedure (with a call frame stored in the register set),
    or a null frame procedure (without a call frame).

    On Integrity server processors, a routine invocation can result
    in a memory stack frame and/or a register stack frame. That is,
    there two stacks on Integrity servers, register and memory. An
    Integrity server routine invocation could result in call frames
    on one or the other or both of those stacks. Also, an Integrity
    server leaf routine invocation (that does not itself make calls)
    can result in a null frame procedure, without a call frame on
    either stack. SHOW CALLS provides one line of information,
    regardless of the which stack or register results. (See the
    examples below.)

4  –  Description, Continued...

    The following information is provided for each line of the SHOW
    CALLS display:

    o  The name of the enclosing module. An asterisk (*)  to the left
       of a module name indicates that the module is set.

    o  The name of the calling routine, provided the module is set
       (the first line shows the currently executing routine).

    o  The line number where the call was made in that routine,
       provided the module is set (the first line shows the line
       number at which execution is suspended).

    o  The value of the PC in the calling routine at the time
       that control was transferred to the called routine. On VAX
       processors, the PC value is shown as a memory address relative
       to the nearest preceding symbol value (for example, a routine)
       and also as an absolute address. On Alpha and Integrity server
       processors, the PC is shown as a memory address relative to
       the first code address in the module and also as an absolute
       address.

       When you specify the /IMAGE qualifier, the debugger first does
       a SET IMAGE command for each image that has debug information
       (that is, it was linked using the /DEBUG or /TRACEBACK
       qualifier). The debugger then displays the image name for
       each active call on the calls stack. The output display has
       been expanded and displays the image name in the first column.

       The debugger suppresses the share$image_name module name,
       because that information is provided by the /IMAGE qualifier.

       The SET IMAGE command lasts only for the duration of the SHOW
       CALLS/IMAGE command. The debugger restores the set image state
       when the SHOW CALLS/IMAGE command is complete.

    Related commands:

       SHOW SCOPE
       SHOW STACK

5  –  Examples

    1.DBG> SHOW CALLS
       module name routine name  line     rel PC           abs PC
      *MAIN         FFFF          31  00000000000002B8 00000000000203C4
      -the above appears to be a null frame
                                     in the same scope as the frame below
      *MAIN         MAIN          13  00000000000000A8 00000000000200A8
                                      0000000000000000 FFFFFFFF8255A1F8

      This example has been reformatted for Help, and may appear
      slightly different from the actual output display. This example
      is on an Alpha system. Note that sections of routine prologues
      and epilogues appear to the debugger to be null frames. The
      portion of the prologue before the change in the frame pointer
      (FP) and the portion of the epilogue after restoration of the
      FP each look like a null frame, and are reported accordingly.

    2.DBG> SHOW CALLS

       module name    routine name     line           rel PC           abs PC
      *MAIN           FFFF               18       0000000000000190 0000000000010190
      *MAIN           MAIN               14       0000000000000180 0000000000010180
                                                  FFFFFFFF80C2A200 FFFFFFFF80C2A200

      This example has been reformatted for Help, and may appear
      slightly different from the actual output display. This example
      is on Integrity servers. Note that Integrity server prologues
      do not appear to be null frames to the debugger.