org.jikesrvm.compilers.opt.regalloc
Class GenericRegisterRestrictions

java.lang.Object
  org.jikesrvm.compilers.opt.regalloc.GenericRegisterRestrictions

Direct Known Subclasses:

RegisterRestrictions

public abstract class GenericRegisterRestrictions
extends Object

An instance of this class provides a mapping from symbolic register to a set of restricted registers.

Each architecture will subclass this in a class RegisterRestrictions.

hash

private final HashMap<Register,GenericRegisterRestrictions.RestrictedRegisterSet> hash

noSpill

private final HashSet<Register> noSpill

phys

protected final ArchitectureSpecificOpt.PhysicalRegisterSet phys

GenericRegisterRestrictions

protected GenericRegisterRestrictions(ArchitectureSpecificOpt.PhysicalRegisterSet phys)

Default Constructor

noteMustNotSpill

protected final void noteMustNotSpill(Register r)

Record that the register allocator must not spill a symbolic register.

mustNotSpill

public final boolean mustNotSpill(Register r)

Is spilling a register forbidden?

init

public final void init(IR ir)

Record all the register restrictions dictated by an IR. PRECONDITION: the instructions in each basic block are numbered in increasing order before calling this. The number for each instruction is stored in its scratch field.

processBlock

private void processBlock(BasicBlock bb)

Record all the register restrictions dictated by live ranges on a particular basic block.

PRECONDITION: the instructions in each basic block are numbered in increasing order before calling this. The number for each instruction is stored in its scratch field.

addArchRestrictions

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

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

Parameters:

bb - the basic block

symbolics - the live intervals for symbolic registers on this block

contains

protected final boolean contains(LiveIntervalElement R,
                                 int n)

Does a live range R contain an instruction with number n?

PRECONDITION: the instructions in each basic block are numbered in increasing order before calling this. The number for each instruction is stored in its scratch field.

overlaps

private boolean overlaps(LiveIntervalElement li1,
                         LiveIntervalElement li2)

Do two live ranges overlap?

PRECONDITION: the instructions in each basic block are numbered in increasing order before calling this. The number for each instruction is stored in its scratch field.

forbidAllVolatiles

final void forbidAllVolatiles(Register symb)

Record that it is illegal to assign a symbolic register symb to any volatile physical registers

addRestrictions

protected final void addRestrictions(Register symb,
                                     BitSet set)

Record that it is illegal to assign a symbolic register symb to any of a set of physical registers

addRestriction

protected final void addRestriction(Register symb,
                                    Register p)

Record that it is illegal to assign a symbolic register symb to a physical register p

getRestrictions

final GenericRegisterRestrictions.RestrictedRegisterSet getRestrictions(Register symb)

Return the set of restricted physical register for a given symbolic register. Return null if no restrictions.

allVolatilesForbidden

public final boolean allVolatilesForbidden(Register symb)

Is it forbidden to assign symbolic register symb to any volatile register?

Returns:

true: yes, all volatiles are forbidden. false :maybe, maybe not

isForbidden

public final boolean isForbidden(Register symb,
                                 Register phys)

Is it forbidden to assign symbolic register symb to physical register phys?

isForbidden

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

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