VMS Help MACRO, /MIGRATION, Macros for 64-Bit Addressing  *Conan The Librarian (sorry for the slow response - running on an old VAX)

    The following macros manipulate 64-bit addresses:

    o  $SETUP_CALL64

    o  $PUSH_ARG64

    o  $CALL64

    These macros check the sign extension and descriptor format:

    o  $IS_32BITS

    o  $IS_DESC64

1 - $SETUP CALL64

    Initializes the call sequence.

    Format

      $SETUP_CALL64  arg_count, inline=true or false

 1.1 - Parameters

 arg_count

    The number of arguments in the call.

 inline

    Forces inline expansion, rather than creation of a JSB routine,
    when set to TRUE. If there are six or fewer arguments, the
    default is INLINE=FALSE.

 1.2 - Description

    This macro initializes the state for a 64-bit call. It must be
    used before using $PUSH_ARG64 and $CALL64.

    If there are six or fewer arguments, the code is always in line.

    By default, if there are more than six arguments, this macro
    creates a JSB routine that is invoked to perform the actual call.
    However, if the inline option is specified as INLINE=TRUE, the
    code is generated in line. This option should be enabled only
    if the code in which it appears has a fixed stack depth. A fixed
    stack depth can be assumed if no RUNTIMSTK or VARSIZSTK messages
    have been reported. Otherwise, if the stack alignment is not
    at least quadword, there might be many alignment faults in the
    called routine and in anything the called routine calls. The
    default behavior (INLINE=FALSE) does not have this problem.

    If there are more than six arguments, there can be no references
    to AP or SP between a $SETUP_CALL64 and the matching $CALL64,
    because the $CALL64 code may be in a separate JSB routine. In
    addition, temporary registers (R16 and above) may not survive the
    $SETUP_CALL64. However, they can be used within the range, except
    where R16 through R21 interfere with the argument registers
    already set up. In such cases, higher temporary registers should
    be used instead.

                                   NOTE

       The $SETUP_CALL64, $PUSH_ARG64, and $CALL64 macros are
       intended to be used in an inline sequence. That is, you
       cannot branch into the middle of a $SETUP_CALL64/$PUSH_
       ARG64/$CALL64 sequence, nor can you branch around $PUSH_
       ARG64 macros or branch out of the sequence to avoid the
       $CALL64.

2 - $PUSH ARG64

    Does the equivalent of argument pushes for a call.

    Format

      $PUSH_ARG64  argument

 2.1 - Parameters

 argument

    The argument to be pushed.

 2.2 - Description

    This macro pushes a 64-bit argument for a 64-bit call. The macro
    $SETUP_CALL64 must be used before you can use $PUSH_ARG64.

    Arguments will be read as aligned quadwords. That is, $PUSH_ARG64
    4(R0) will read the quadword at 4(R0), and push the quadword. Any
    indexed operations will be done in quadword mode.

    To push a longword value from memory as a quadword, first move it
    into a register with a longword instruction, and then use $PUSH_
    ARG64 on the register. Similarly, to push a quadword value that
    you know is not aligned, move it to a temporary register first,
    and then use $PUSH_ARG64.

    If the call contains more than six arguments, this macro checks
    for SP or AP references in the argument. If the call contains
    more than six arguments, SP references are not allowed, and AP
    references are allowed only if the inline option is used.

    The macro also checks for references to argument registers that
    have already been set up for the current $CALL64. If it finds
    such references, a warning is reported to advise the user to be
    careful not to overwrite an argument register before it is used
    as the source in a $PUSH_ARG64.

    The same checking is done for AP references when there are six
    or fewer arguments; they are allowed, but the compiler cannot
    prevent you from overwriting one before you use it. Therefore, if
    such references are found, an informational message is reported.

    Note that if the operand uses a symbol whose name includes one
    of the strings R16 through R21, not as a register reference,
    this macro might report a spurious error. For example, if the
    invocation $PUSH_ARG64 SAVED_R21 is made after R21 has been set
    up, this macro will unnecessarily report an informational message
    about overwriting argument registers.

    Also note that $PUSH_ARG64 cannot be in conditional code. $PUSH_
    ARG64 updates several symbols, such as the remaining argument
    count. Attempting to write code that branches around a $PUSH_
    ARG64 in the middle of a $SETUP_CALL64/$CALL64 sequence will not
    work properly.

3 - $CALL64

    Invokes the target routine.

    Format

      $CALL64  call_target

 3.1 - Parameters

 call_target

    The routine to be invoked.

 3.2 - Description

    This macro calls the specified routine, assuming $SETUP_CALL64
    has been used to specify the argument count, and $PUSH_ARG64 has
    been used to push the quadword arguments. This macro checks that
    the number of pushes matches what was specified in the setup
    call.

    The call_target operand must not be AP- or SP-based.

    The macros in this section are used for checking certain values
    and directing program flow based on the outcome of the check.

4 - $IS 32BITS

    Checks the sign extension of the low 32 bits of a 64-bit value
    and directs the program flow based on the outcome of the check.

    Format

      $IS_32BITS  quad_arg, leq_32bits, gtr_32bits, temp_reg=22

 4.1 - Parameters

 quad_arg

    A 64-bit quantity, either in a register or in an aligned quadword
    memory location.

 leq_32bits

    Label to branch to if quad_arg is a 32-bit sign-extended value.

 gtr_32bits

    Label to branch to if quad_arg is greater than 32 bits.

 temp_reg=22

    Register to use as a temporary register for holding the low
    longword of the source value-R22 is the default.

 4.2 - Description

    $IS_32BITS checks the sign extension of the low 32 bits of a 64-
    bit value and directs the program flow based on the outcome of
    the check.

 4.3 - Examples

    1.$is_32bits  R9, 10$

      In this example, the compiler checks the sign extension of
      the low 32 bits of the 64-bit value at R9 using the default
      temporary register, R22. Depending on the type of branch
      and the outcome of the test, the program either branches or
      continues in line.

    2.$is_32bits  4(R8), 20$, 30$, R28

      In this example, the compiler checks the sign extension of
      the low 32 bits of the 64-bit value at 4(R8) using R28 as a
      temporary register and, based on the check, branches to either
      20$ or 30$.

5 - $IS DESC64

    Tests the specified descriptor to determine if it is a 64-bit
    format descriptor, and directs the program flow based on the
    outcome of the test.

    Format

      $IS_DESC  desc_addr, target, size=long or quad

 5.1 - Parameters

 desc_addr

    The address of the descriptor to test.

 target

    The label to branch to if the descriptor is in 64-bit format.

  size=long

    The size of the address pointing to the descriptor. Acceptable
    values are "long" (the default) and "quad".

 5.2 - Description

    $IS_DESC64 tests the fields which distinguish a 64-bit descriptor
    from a 32-bit descriptor. If it is in 64-bit form, a branch is
    taken to the specified target. The address to be tested is read
    as a longword, unless SIZE=QUAD is specified.

 5.3 - Examples

    1.$is_desc64 r9, 10$

      In this example, the descriptor pointed to by R9 is tested, and
      if it is in 64-bit form, a branch to 10$ is taken.

    2.$is_desc64 8(r0), 20$, size=quad

      In this example, the quadword at 8(R0) is read, and the
      descriptor it points to is tested. If it is in 64-bit form,
      a branch to 20$ is taken.