All registers saved in the variable portion of the register save area must have the corresponding bit set to 1 in the appropriate procedure descriptor register save mask. This bit must be set to 1 even if the register is not a member of the set of registers required to be saved across a standard call. If the bit is not set to 1, the offsets within the save area cannot be calculated correctly.

The algorithm for packing saved registers in the quadword-aligned register save area is as follows:

• The entry return address register is $26 (PDSC_RPD_ENTRY_RA = 26).

• The return address is not saved in any other register (PDSC_RPD_SAVE_RA = PDSC_RDP_ENTRY_RA).

• No stack space is allocated (PDSC_RPD_SP_SET = 0 and PDSC_RPD_FRAME_SIZE = 0).

• As a result of these characteristics, the prologue requires no instructions (PDSC_RPD_ENTRY_LENGTH = 0).

• There is no associated exception handler (PDSC_RPD_HANDLER_ADDRESS = 0).

For example, suppose $4 contains such a computed procedure value (simple or bound). The following code fragment calls the procedure that $4 describes:

mov    $4,$27               #Move the procedure value to $27.
jsr    $26,($4)             #Call the entry address.
ldah   GP,fix_hi($26)       #Reload the GP register.
lda    GP,fix_lo(GP)

• Simple procedures

• Bound procedures

Bound procedure values are designed for multilanguage use. They allow callers of procedures to use common code to call both bound and simple procedures.

When a bound procedure is called, the caller must pass some kind of pointer to the called code to allow it to reference its up-level environment. Typically, such a pointer is the frame pointer for that environment, though many variations are possible. When the caller is itself executing within that outer environment, it usually can make such a call directly to the code for the nested procedure without recourse to any additional mechanism. However, when a procedure value for the nested procedure must be passed outside of that environment to a call site that has no knowledge of the target procedure, a special bound procedure is created so the nested procedure can be called in the same way as a simple procedure.

The procedure value of a bound procedure is defined as the address of the first instruction of a sequence of instructions that establishes the proper environment for the bound procedure and then transfers control to that procedure.

Except as noted, the exact instruction sequences are not specified; any instruction sequence that produces the defined effects is legal.

• All registers specified by this standard as saved across a standard-conforming call must contain their original (at entry) contents.

• The register designated by PDSC_RPD_ENTRY_RA ($26 in a standard call) must contain its original (at entry) contents. This requirement also applies to nonstandard procedures to allow for proper unwinding.

• No standard calls can be made.

For fixed frame procedures, the frame pointer is the stack pointer. In these cases, the stack pointer is not modified by that procedure after the instruction in that procedure prologue specified by PDSC_RPD_SP_SET.

• Registers $9 - $11 and $f2 - $f3 are saved and restored.

• PDSC_RPD_RSA_OFFSET is equal to 16 bytes.

• The procedure has a static exception handler that does not re-raise arithmetic traps.

• The procedure uses a fixed amount of stack (PDSC_FLAGS_BASE_REG_IS_FP is 0 ).

The following example illustrates a Stack Frame Procedure.

ldah   GP, off_hi($27)    #Compute the correct GP value.
lda    GP, off_lo(GP)
lda    SP,-SIZE(SP)       #Allocate space for a new stack frame.
stq    $26,16(SP)         #Save the return address.
stq    $9,24(SP)          #Save the first integer register.
stq    $10,32(SP)         #Save the next integer register.
stq    $11,40(SP)         #Save the next integer register.
stt    $f2,48(SP)         #Save the first floating-point register.
stt    $f3,56(SP)         #Save the last floating-point register.
trapb                     #Force any pending hardware exceptions
                          #   to be raised.
#The called procedure is now the current procedure.

• The called procedure has no static exception handler.

• PDSC_RPD_SAVE_RA and PDSC_RPD_ENTRY_RA specify $26.

• The procedure utilizes a fixed amount of stack storage (PDSC_FLAGS_BASE_REG_IS_FP is 0).

The following example illustrates a Register Frame Procedure.

ldah   GP, off_hi($27)     #Compute the correct GP value.
lda    GP, off_lo(GP)
lda    SP,-SIZE(SP)        #Allocate space for a new stack frame.
#The called procedure is now the current procedure.

The next sections provide the following information:

• A discussion of the reserved instruction sequence

• The steps involved in an exit code sequence

• An example of exit code for a stack frame

• An example of exit code for a register frame

The following reserved instruction must appear at every exit point from any procedure that uses the stack (PDSC_RPD_FRAME_SIZE is not 0):

ret  $31,($n),0001   #Return to the caller with usage hint 0001

lda    SP,*               #Reset the stack.
ret    $31,(*),0001       #Return to the caller with usage hint.

addq   *,*,SP             #Reset the stack.
ret    $31,(*),0001       #Return to the caller with usage hint.

Thus, any lda instruction whose destination is the SP register or any addq instruction whose destination is the SP register is interpreted as part of a procedure exit sequence when it is immediately followed by the reserved procedure return instruction.

A stack-resetting instruction might not be present in the case of a procedure that returns a result on the top of the stack. However, if such an instruction is present, it will immediately preced the reserved ret instruction.

Furthermore, for any such procedure that has PDSC_FLAGS_BASE_REG_IS_FP set to 1, the resulting sequence must immediately follow the FP reloading instruction as in the following example:

ldq    FP,*               #Restore the FP.
lda    SP,*               #Or addq *,*,SP to reset the stack.
ret    $31,(*),0001       #Return to the caller with usage hint.

Procedures that do not use the stack do not need to use these reserved instruction sequences.