All integer parameters are promoted (that is, sign- or zero-extended to 64-bit integers and passed in a single register). Typically, no code is required for the promotion.

All pointers and addresses are 32-bit objects. [Using the -64 command option, pointers and addresses are 64 bits.]

Floating point parameters are passed as single- or double-precision according to the ANSI C rules. [This is the same as when the -64 option is used.]

All stack parameter slots become 64-bit doublewords, even for parameters that are smaller (for example, floats and 32-bit integers). [This is also true for -64.]

All stack regions are quadword aligned. [The o32-bit ABI specifies only doubleword alignment.]

Up to eight integer registers ($4 .. $11) may be used to pass integer arguments. [The o32-bit ABI uses only the four registers $4 .. $7.]

Up to eight floating point registers ($f12 .. $f19) may be used to pass floating point arguments. [The o32-bit ABI uses only the four registers $f12 .. $f15, with the odd registers used only for halves of double-precision arguments.]

The argument registers may be viewed as an image of the initial eight doublewords of a structure containing all of the arguments, where each of the argument fields is a multiple of 64 bits in size with doubleword alignment. The integer and floating point registers are distinct images, that is, the first doubleword is passed in either $4 or $f1, depending on its type; the second in either $5 or $f1; and so on. [The o32-bit ABI associates each floating point argument with an even/odd pair of integer or floating point argument registers. ]

Within each of the 64-bit save area slots, smaller scalar parameters are right-justified; that is, they are placed at the highest possible address (for big-endian targets). This is relevant to integer parameters of 32 or fewer bits. Float parameters are left-justified. Only int parameters arise in C except for prototyped cases. Smaller integers are promoted to int and floats are promoted to doubles . [This is true for the o32-bit ABI, but is relevant only to prototyped small integers because all the other types were at least register-sized.]

32-bit integer (int) parameters are always sign-extended when passed in registers, whether of signed or unsigned type. [This issue does not arise in the o32-bit ABI.]

Quad-precision floating point parameters (C long double or Fortran REAL*16) are always 16-byte aligned. This requires that they be passed in even-odd floating point register pairs, even if doing so requires skipping a register parameter and/or a 64-bit save area slot. [ The o32-bit ABI does not consider long double parameters, because they were not supported.]

Complex types (C99 and Fortran %val) are passed in multiple floating point registers, as available. Float complex is passed as 2 floats, double complex as 2 doubles, and long double complex as 2 long doubles. Because the size of a float complex is 8 bytes (two 4-byte floats) but two float argument registers take 16 bytes of space, the float complex is padded with an extra 8 bytes of empty space in the stack image of the argument registers. For example, if the float complex is passed in $f12 and $f13, with the next parameters in $f14, the stack home of the float complex would be at n($sp) ($f12 would be stored in n($sp) and $f13 into n+4(s0)) and the stack home of $f14 would be at n+16($sp).

Structs, unions, or other composite types are treated as a sequence of doublewords, and are passed in integer or floating point registers as though they were simple scalar parameters to the extent that they fit, with any excess on the stack packed according to the normal memory layout of the object. More specifically:

Whenever possible, floating point arguments are passed in floating point registers regardless of whether they are preceded by integer parameters. [The o32-bit ABI allows only leading floating point (FP) arguments to be passed in FP registers; those coming after integer registers must be moved to integer registers. ]

Variable argument routines require an exception to the previous rule. Any floating point parameters in the variable part of the argument list (leading or otherwise) are passed in integer registers. Several important cases are involved:

The portion of the argument structure beyond the initial eight doublewords is passed in memory on the stack and pointed to by the stack pointer at the time of call. The caller does not reserve space for the register arguments; the callee is responsible for reserving it if required (either adjacent to any caller-saved stack arguments if required, or elsewhere as appropriate.) No requirement is placed on the callee either to allocate space and save the register parameters, or to save them in any particular place. [The o32-bit ABI requires the caller to reserve space for the register arguments as well.]

Function results are returned in $2 (and $3 if needed), or$f0 (and $f2 if needed), as appropriate for the type. Composite results (struct , union, or array) are returned in $2/$f0 and $3/ $f2 according to the following rules:

There are eight callee-saved floating point registers, $f24..$f31 for the 64-bit interface. There are six for the n32 ABI, the six even registers in $f20..$f30 . [The o32-bit ABI specifies the six even registers, or even/odd pairs, $f20..$f31.]

Routines are not to be restricted to a single exit block. [The o32-bit ABI makes this restriction, though it is not observed under all optimization options.]

d1..d5 are double precision floating point arguments.

s1..s4 are single precision floating point arguments.

n1..n3 are integer arguments.