The CALL command is one of the four debugger commands that
    can be used to execute your program (the others are GO, STEP,
    and EXIT). The CALL command enables you to execute a routine
    independently of the normal execution of your program. The CALL
    command executes a routine whether or not your program actually
    includes a call to that routine, as long as the routine was
    linked with your program.

    When you enter a CALL command, the debugger takes the following
    actions. For more information, see the qualifier descriptions.

    1. Saves the current values of the general registers.

    2. Constructs an argument list.

    3. Executes a call to the routine specified in the command and
       passes any arguments.

    4. Executes the routine.

    5. Displays the value returned by the routine in the return
       status register. By convention, after a called routine has
       executed, register R0 contains the function return value
       (if the routine is a function) or the procedure completion
       status (if the routine is a procedure that returns a status
       value). If a called procedure does not return a status value
       or function value, the value in R0 might be meaningless, and
       the "value returned" message can be ignored.

    6. Restores the values of the general registers to the values
       they had just before the CALL command was executed.

    7. Issues the prompt.

    The debugger assumes that the called routine conforms to the
    procedure calling standard (see the OpenVMS Calling Standard).
    However, the debugger does not know about all the argument-
    passing mechanisms for all supported languages. Therefore,
    you might need to specify how to pass parameters, for example,
    use CALL SUB1(%VAL X) rather than CALL SUB1(X). For complete
    information about how arguments are passed to routines, see your
    language documentation.

    When the current language is C or C++, the CALL command by
    default now passes arguments by value rather than by reference.
    In addition, you can now pass the following arguments without
    using a passing mechanism lexical (such as %REF or %VAL):

    o  Routine references

    o  Quoted strings (treated as %REF strings)

    o  Structures, records, and objects

    o  Floating-point parameters by value in F_, D_, G_, S_, and T_
       floating format by dereferencing a variable of that type.

    If the routine contains parameters that are not read-only, the
    values assigned to parameters may not be visible, and access
    to values is unreliable. This is because the debugger adjusts
    parameter values in an internal argument list, not the program
    argument list. To examine changing values, consider using static
    variables instead of parameters.

    The CALL command converts all floating-point literals to F_
    floating format for VAX and Alpha systems and T_floating format
    for Integrity servers.

    On Alpha, passing a floating-point literal in a format other than
    F_floating is not supported, as shown in the example below.

    A common debugging technique at an exception breakpoint
    (resulting from a SET BREAK/EXCEPTION or STEP/EXCEPTION command)
    is to call a dump routine with the CALL command. When you enter
    the CALL command at an exception breakpoint, any breakpoints,
    tracepoints, or watchpoints that were previously set within the
    called routine are temporarily disabled so that the debugger does
    not lose the exception context. However, such eventpoints are
    active if you enter the CALL command at a location other than an
    exception breakpoint.