Function calling conventions and other conventions regarding the use of machine registers and stack slots.

Classification of machine registers

Machine registers (type mreg in module Locations) are divided in the following groups:

• Temporaries used for spilling, reloading, and parallel move operations.
• Allocatable registers, that can be assigned to RTL pseudo-registers. These are further divided into:
  • Callee-save registers, whose value is preserved across a function call.
  • Caller-save registers that can be modified during a function call.

We follow the PowerPC/MacOSX application binary interface (ABI) in our choice of callee- and caller-save registers.

The index_int_callee_save and index_float_callee_save associate a unique positive integer to callee-save registers. This integer is used in Stacking to determine where to save these registers in the activation record if they are used by the current function.

The following lemmas show that (temporaries, destroyed at call, integer callee-save, float callee-save) is a partition of the set of machine registers.

Acceptable locations for register allocation

The following predicate describes the locations that can be assigned to an RTL pseudo-register during register allocation: a non-temporary machine register or a Local stack slot are acceptable.

Function calling conventions

The functions in this section determine the locations (machine registers and stack slots) used to communicate arguments and results between the caller and the callee during function calls. These locations are functions of the signature of the function and of the call instruction. Agreement between the caller and the callee on the locations to use is guaranteed by our dynamic semantics for Cminor and RTL, which demand that the signature of the call instruction is identical to that of the called function.

Calling conventions are largely arbitrary: they must respect the properties proved in this section (such as no overlapping between the locations of function arguments), but this leaves much liberty in choosing actual locations. To ensure binary interoperability of code generated by our compiler with libraries compiled by another PowerPC compiler, we implement the standard conventions defined in the PowerPC/MacOS X application binary interface.

Location of function result

The result value of a function is passed back to the caller in registers R3 or F1, depending on the type of the returned value. We treat a function without result as a function with one integer result.

The result location has the type stated in the signature.

The result location is acceptable.

The result location is a caller-save register.

The result location is not a callee-save register.

Location of function arguments

The PowerPC ABI states the following convention for passing arguments to a function:

• The first 8 integer arguments are passed in registers R3 to R10.
• The first 10 float arguments are passed in registers F1 to F10.
• Each float argument passed in a float register ``consumes'' two integer arguments.
• Extra arguments are passed on the stack, in Outgoing slots, consecutively assigned (1 word for an integer argument, 2 words for a float), starting at word offset 0.
• Stack space is reserved (as unused Outgoing slots) for the arguments that are passed in registers.

These conventions are somewhat baroque, but they are mandated by the ABI.

loc_arguments s returns the list of locations where to store arguments when calling a function with signature s.

size_arguments s returns the number of Outgoing slots used to call a function with signature s.

A tail-call is possible for a signature if the corresponding arguments are all passed in registers.

Argument locations are either non-temporary registers or Outgoing stack slots at nonnegative offsets.

Arguments are parwise disjoint (in the sense of Loc.norepet).

The offsets of Outgoing arguments are below size_arguments s.

Temporary registers do not overlap with argument locations.

Argument registers are caller-save.

Callee-save registers do not overlap with argument locations.

Argument locations agree in number with the function signature.

Argument locations agree in types with the function signature.

There is no partial overlap between an argument location and an acceptable location: they are either identical or disjoint.

Decide whether a tailcall is possible.

Location of function parameters

A function finds the values of its parameter in the same locations where its caller stored them, except that the stack-allocated arguments, viewed as Outgoing slots by the caller, are accessed via Incoming slots (at the same offsets and types) in the callee.