org.jikesrvm.compilers.opt.regalloc.ia32

Class CallingConvention

java.lang.Object

org.jikesrvm.compilers.opt.ir.IRTools

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

public abstract class CallingConvention
extends IRTools

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.

Field Summary

Fields

Modifier and Type	Field and Description
private static int	WORDSIZE Size of a word, in bytes
private static TypeReference	wordType

Constructor Summary

Constructors

Constructor and Description
CallingConvention()

Method Summary

Modifier and Type	Method and Description
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.
private static void	callExpand(Instruction call, IR ir) Expands the calling convention for a particular call instruction.
private static int	countFPRParams(Instruction call)
private static int	countFPRParamsInPrologue(Instruction p)
static void	expandCallingConventions(IR ir) Expands calling conventions to make physical registers explicit in the IR when required for calls, returns, and the prologue.
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.
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.
private static void	expandPrologue(IR ir)
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.
static void	expandSysCall(Instruction s, IR ir) Calling convention to implement calls to native (C) routines using the Linux linkage conventions.
private static boolean	paramIsNativeLongOn64Bit(Operand param)
(package private) static void	restoreNonvolatilesAfterSysCall(Instruction call, IR ir) Restore all nonvolatile registers after a syscall.
private static void	returnExpand(Instruction ret, IR ir) Expands the calling convention for a particular return instruction.
static void	saveNonvolatilesAroundSysCall(Instruction call, IR ir) Save and restore all nonvolatile registers around a syscall.
(package private) static void	saveNonvolatilesBeforeSysCall(Instruction call, IR ir) Save all nonvolatile registers before a syscall.

Methods inherited from class org.jikesrvm.compilers.opt.ir.IRTools

A, AC, AC, CPOS, CR, D, DC, defDoublesAsUse, definedIn, F, FC, getCondMoveOp, getDefaultOperand, getLoadOp, getLoadOp, getMoveOp, getStoreOp, getStoreOp, I, IC, insertInstructionsAfter, L, LC, makeBlockOnEdge, mayBeVolatileFieldLoad, moveInstruction, moveIntoRegister, moveIntoRegister, nonPEIGC, offsetOperand, TG, usedIn, useDoublesAsDef

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

WORDSIZE

private static final int WORDSIZE

Size of a word, in bytes

See Also:

Constant Field Values

wordType

private static final TypeReference wordType

Constructor Detail

CallingConvention

public CallingConvention()

Method Detail

expandCallingConventions

public static void expandCallingConventions(IR ir)

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

Parameters:

ir - the governing IR

callExpand

private static void callExpand(Instruction call,
                               IR ir)

Expands the calling convention for a particular call instruction.

Parameters:

call - the call instruction

ir - the IR that contains the call instruction

returnExpand

private static void returnExpand(Instruction ret,
                                 IR ir)

Expands the calling convention for a particular return instruction.

Parameters:

ret - the return instruction

ir - the IR that contains the 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.

Parameters:

call - the call instruction

isSysCall - whether the call is a SysCall

ir - the IR that contains the call

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.

Parameters:

call - the call instruction

ir - the IR that contains the call

Returns:

number of bytes necessary to hold the parameters

paramIsNativeLongOn64Bit

private static boolean paramIsNativeLongOn64Bit(Operand param)

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

ir - the IR that contains the 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

ir - the IR that contains the 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

ir - the IR that contains the 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

Note: Assumes that ESP points to the word before the slot where the first parameter should be stored.

TODO: much of this code is exactly the same as in expandParametersToCall(). factor out the common code.

Parameters:

call - the call instruction

ir - the IR that contains the call

Returns:

the number of bytes necessary to hold the parameters

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.

Parameters:

ir - the governing IR

expandSysCall

public static void expandSysCall(Instruction s,
                                 IR ir)

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

Parameters:

s - the call instruction

ir - the IR that contains the call

countFPRParams

private static int countFPRParams(Instruction call)

countFPRParamsInPrologue

private static int countFPRParamsInPrologue(Instruction p)

expandPrologue

private static void expandPrologue(IR ir)