org.jikesrvm.compilers.opt.regalloc.ia32
Class CallingConvention

java.lang.Object
  org.jikesrvm.compilers.opt.ir.IRTools
      org.jikesrvm.compilers.opt.regalloc.ia32.CallingConvention

All Implemented Interfaces:

Operators, PhysicalRegisterConstants, RegisterConstants

Direct Known Subclasses:

ArchitectureSpecificOpt.CallingConvention

public abstract class CallingConvention
extends IRTools
implements Operators, PhysicalRegisterConstants

This class contains IA32 calling conventions The two public methods are: (1) expandCallingConventions(IR) which is called by the register allocator immediately before allocation to make manifest the use of registers by the calling convention. (2) expandSysCall(Instruction, IR) which is called to expand a SYSCALL HIR instruction into the appropriate sequence of LIR instructions. TODO: Much of this code could still be factored out as architecture-independent.

WORDSIZE

private static final int WORDSIZE

Size of a word, in bytes

See Also:

Constant Field Values

CallingConvention

public CallingConvention()

expandCallingConventions

public static void expandCallingConventions(IR ir)

Expand calling conventions to make physical registers explicit in the IR when required for calls, returns, and the prologue.

callExpand

private static void callExpand(Instruction call,
                               IR ir)

Expand the calling convention for a particular call instruction

returnExpand

private static void returnExpand(Instruction ret,
                                 IR ir)

Expand the calling convention for a particular return instruction

expandResultOfCall

private static void expandResultOfCall(Instruction call,
                                       boolean isSysCall,
                                       IR ir)

Explicitly copy the result of a call instruction from the result register to the appropriate symbolic register, as defined by the calling convention.

expandParametersToCall

private static int expandParametersToCall(Instruction call,
                                          IR ir)

Explicitly copy parameters to a call into the appropriate physical registers as defined by the calling convention. Note: Assumes that ESP points to the word before the slot where the first parameter should be stored.

saveNonvolatilesAroundSysCall

public static void saveNonvolatilesAroundSysCall(Instruction call,
                                                 IR ir)

Save and restore all nonvolatile registers around a syscall. We do this in case the sys call does not respect our register conventions. We save/restore all nonvolatiles and the PR, whether or not this routine uses them. This may be a tad inefficient, but if you're making a system call, you probably don't care. Side effect: changes the operator of the call instruction to IA32_CALL.

Parameters:

call - the sys call

saveNonvolatilesBeforeSysCall

static void saveNonvolatilesBeforeSysCall(Instruction call,
                                          IR ir)

Save all nonvolatile registers before a syscall. We do this in case the sys call does not respect our register conventions. We save/restore all nonvolatiles and the PR, whether or not this routine uses them. This may be a tad inefficient, but if you're making a system call, you probably don't care.

Parameters:

call - the sys call

restoreNonvolatilesAfterSysCall

static void restoreNonvolatilesAfterSysCall(Instruction call,
                                            IR ir)

Restore all nonvolatile registers after a syscall. We do this in case the sys call does not respect our register conventions. We save/restore all nonvolatiles and the PR, whether or not this routine uses them. This may be a tad inefficient, but if you're making a system call, you probably don't care.

Parameters:

call - the sys call

expandParametersToSysCall

private static int expandParametersToSysCall(Instruction call,
                                             IR ir)

Explicitly copy parameters to a system call into the appropriate physical registers as defined by the calling convention. Note that for a system call (ie., a call to C), the order of parameters on the stack is reversed compared to the normal RVM calling convention TODO: much of this code is exactly the same as in expandParametersToCall(). factor out the common code. Note: Assumes that ESP points to the word before the slot where the first parameter should be stored.

allocateSpaceForSysCall

public static void allocateSpaceForSysCall(IR ir)

We have to save/restore the non-volatile registers around syscalls, to protect ourselves from malicious C compilers and Linux kernels. Although the register allocator is not yet ready to insert these spills, allocate space on the stack in preparation. For now, we naively save/restore all nonvolatiles.

expandSysCall

public static void expandSysCall(Instruction s,
                                 IR ir)

Calling convention to implement calls to native (C) routines using the Linux linkage conventions.

countFPRParams

private static int countFPRParams(Instruction call)

Count the number of FPR parameters in a call instruction.

countFPRParamsInPrologue

private static int countFPRParamsInPrologue(Instruction p)

Count the number of FPR parameters in a prologue instruction.

expandPrologue

private static void expandPrologue(IR ir)

Expand the prologue instruction.