4.1.6 Sending Data

This section defines the Windows NT for Alpha Systems Calling Standard requirements for mechanisms to send data and order of argument evaluation.

Sending Mechanism

As previously defined, the argument-passing mechanisms allowed are immediate value, reference, and descriptor. Requirements for use of these mechanisms follow.

• By immediate value — An argument may be passed by immediate value only if the argument is one of the following:
  • One of the noncomplex scalar data types with a size known (at compile time) to be ≤≤ 64 bits
    
    
  • A record with a known size (at compile time)
    
    
  • A set, implemented as a bit vector, with a size known (at compile time) to be ≤≤ 64 bits

  No form of string, array, or complex data type may be passed by immediate value in a standard call.

  A standard immediate argument item must fill 64 bits. This means that unused high-order bits of all data types (excluding records) must be zero-extended or sign-extended, as appropriate, depending on the data type, to fill all unused bits. (See Table 4-2, Unused Bits in Passed Data, for details.)

  Large immediate arguments — Record values are passed by immediate value as follows:

  • Allocate as many fully occupied argument item positions to the argument value as are needed to represent the argument.
    
    
  • The value of the unoccupied bits is undefined in a final, partially occupied argument item position.
    
    
  • An argument item that is passed in one of the registers is passed in the integer registers (never in a floating register).

  Nonstandard immediate arguments — Nonrecord argument values that are larger than 64 bits can be passed by immediate value using nonstandard conventions, typically using a method similar to that used for records. Thus, for example, a 26-byte string could be passed by value in four integer registers.

• By reference: Nonparametric — Nonparametric arguments (that is, arguments for which associated information such as string size and array bounds are not required) may be passed by reference in a standard call.
  
  
• By Reference: Parametric — Parametric arguments (that is, arguments for which associated information such as string size and array bounds must be passed to the caller) may be passed by reference followed by one or more immediate arguments for the parametric values. (The parametric values need not immediately follow the reference arguments to which they apply.)

  Note   Interlanguage conventions for such calls are not defined by this standard.

• By descriptor — Parametric arguments (that is, arguments for which associated information such as string size and array bounds must be passed to the caller) may be passed by a single descriptor.

  Note   A standard set of descriptors for interlanguage use is not defined by this standard.

Extended floating values are not passed using the immediate value mechanism; rather, they are passed using the by-reference mechanism. (When by-value semantics are required, however, it may be necessary to make a copy of the actual parameter and pass a reference to that copy in order to avoid improper alias effects.)

When a record is passed by immediate value, the component types are not material to how the argument is aligned; the record will always be quadword aligned.

Order of Argument Evaluation

Since most higher-level languages do not specify the order of evaluation (with respect to side effects) of arguments, those language processors can evaluate arguments in any convenient order. The choice of argument evaluation order and code generation strategy is constrained only by the definition of the particular language. Programs should not be written that depend on the order of evaluation of arguments.