org.jikesrvm.compilers.opt.regalloc.ia32

Class RegisterRestrictions

java.lang.Object

org.jikesrvm.compilers.opt.regalloc.GenericRegisterRestrictions

org.jikesrvm.compilers.opt.regalloc.ia32.RegisterRestrictions

public final class RegisterRestrictions
extends GenericRegisterRestrictions

An instance of this class encapsulates restrictions on register assignment.

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	SCRATCH_IN_PEI Allow scratch registers in PEIs?

Fields inherited from class org.jikesrvm.compilers.opt.regalloc.GenericRegisterRestrictions

phys, regAllocState

Constructor Summary

Constructors

Constructor and Description
RegisterRestrictions(GenericPhysicalRegisterSet phys)

Method Summary

Modifier and Type	Method and Description
void	addArchRestrictions(BasicBlock bb, ArrayList<LiveIntervalElement> symbolics) Add architecture-specific register restrictions for a basic block.
(package private) void	handle8BitRestrictions(Instruction s) Ensure that if an operand has an 8 bit memory operand that all of its register operands are in 8 bit registers.
(package private) boolean	has8BitMemoryOperand(Instruction s)
boolean	isForbidden(Register symb, Register r, Instruction s) Is it forbidden to assign symbolic register symb to physical register r in instruction s?
static boolean	mustBeInRegister(Register r, Instruction s) Given symbolic register r that appears in instruction s, does the architecture demand that r be assigned to a physical register in s?
private boolean	okFor8(Register r)
(package private) void	restrictTo8Bits(Register r) Ensures that a particular register is only assigned to AL, BL, CL, or DL, since these are the only 8-bit registers we normally address.

Methods inherited from class org.jikesrvm.compilers.opt.regalloc.GenericRegisterRestrictions

addRestriction, addRestrictions, allVolatilesForbidden, contains, init, isForbidden, mustNotSpill, noteMustNotSpill

Methods inherited from class java.lang.Object

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

Field Detail

SCRATCH_IN_PEI

public static final boolean SCRATCH_IN_PEI

Allow scratch registers in PEIs?

See Also:

Constant Field Values

Constructor Detail

RegisterRestrictions

public RegisterRestrictions(GenericPhysicalRegisterSet phys)

Method Detail

addArchRestrictions

public void addArchRestrictions(BasicBlock bb,
                                ArrayList<LiveIntervalElement> symbolics)

Description copied from class: GenericRegisterRestrictions

Add architecture-specific register restrictions for a basic block. Override as needed.

Overrides:

addArchRestrictions in class GenericRegisterRestrictions

Parameters:

bb - the basic block

symbolics - the live intervals for symbolic registers on this block

has8BitMemoryOperand

boolean has8BitMemoryOperand(Instruction s)

Parameters:

s - the instruction to check

Returns:

true if and only if the instruction contains an 8-bit memory operand

handle8BitRestrictions

void handle8BitRestrictions(Instruction s)

Ensure that if an operand has an 8 bit memory operand that all of its register operands are in 8 bit registers.

Parameters:

s - the instruction to restrict

restrictTo8Bits

void restrictTo8Bits(Register r)

Ensures that a particular register is only assigned to AL, BL, CL, or DL, since these are the only 8-bit registers we normally address.

Parameters:

r - the register that needs to be restricted to 8 bits

mustBeInRegister

public static boolean mustBeInRegister(Register r,
                                       Instruction s)

Given symbolic register r that appears in instruction s, does the architecture demand that r be assigned to a physical register in s?

Parameters:

r - a symbolic register

s - instruction where the register appears

Returns:

true if the symbolic register r must use a physical register in the instruction, false if we can use a spill location

okFor8

private boolean okFor8(Register r)

Parameters:

r - the register to check

Returns:

true if the physical register r hold an 8-bit value?

isForbidden

public boolean isForbidden(Register symb,
                           Register r,
                           Instruction s)

Description copied from class: GenericRegisterRestrictions

Is it forbidden to assign symbolic register symb to physical register r in instruction s?

Specified by:

isForbidden in class GenericRegisterRestrictions

Parameters:

symb - a symbolic register

r - a physical register

s - the instruction that's the scope for the check

Returns:

true if it's forbidden, false otherwise