routine-name

    Specifies the name or the memory address of the routine to be
    called.

 argument

    Specifies an argument required by the routine. Arguments can be
    passed by address, by descriptor, by reference, and by value, as
    follows:

    %ADDR   (Default, except for C and C++.) Passes the argument by
            address. The format is as follows:

            CALL routine-name (%ADDR address-expression)

            The debugger evaluates the address expression and
            passes that address to the routine specified. For
            simple variables (such as X), the address of X is
            passed into the routine. This passing mechanism is how
            Fortran implements ROUTINE(X). In other words, for named
            variables, using %ADDR corresponds to a call by reference
            in Fortran. For other expressions, however, you must use
            the %REF function to call by reference. For complex or
            composite variables (such as arrays, records, and access
            types), the address is passed when you specify %ADDR,
            but the called routine might not handle the passed data
            properly. Do not specify a literal value (a number or an
            expression composed of numbers) with %ADDR.
    %DESCR  Passes the argument by descriptor. The format is as
            follows:

            CALL routine-name (%DESCR language-expression)

            The debugger evaluates the language expression and
            builds a standard descriptor to describe the value. The
            descriptor is then passed to the routine you named. You
            would use this technique to pass strings to a Fortran
            routine.
    %REF    Passes the argument by reference. The format is as
            follows:

            CALL routine-name (%REF language-expression)

            The debugger evaluates the language expression and passes
            a pointer to the value, into the called routine. This
            passing mechanism corresponds to the way Fortran passes
            the result of an expression.
    %VAL    (Default for C and C++.) Passes the argument by value.
            The format is as follows:

            CALL routine-name (%VAL language-expression)

            The debugger evaluates the language expression and passes
            the value directly to the called routine.