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.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	GenericRegisterRestrictions.RestrictedRegisterSet An instance of this class represents restrictions on physical register assignment.

Field Summary

Fields

Modifier and Type	Field and Description
private HashMap<Register,GenericRegisterRestrictions.RestrictedRegisterSet>	hash
private HashSet<Register>	noSpill
protected GenericPhysicalRegisterSet	phys
protected RegisterAllocatorState	regAllocState

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	GenericRegisterRestrictions(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.
protected void	addRestriction(Register symb, Register p) Record thats it is illegal to assign a symbolic register symb to a physical register p.
protected void	addRestrictions(Register symb, BitSet set) Records that it is illegal to assign a symbolic register symb to any of a set of physical registers.
boolean	allVolatilesForbidden(Register symb) Is it forbidden to assign symbolic register symb to any volatile register?
protected boolean	contains(LiveIntervalElement R, int n) Does a live range R contain an instruction with number n?
(package private) void	forbidAllVolatiles(Register symb) Records that it is illegal to assign a symbolic register symb to any volatile physical registerss.
(package private) GenericRegisterRestrictions.RestrictedRegisterSet	getRestrictions(Register symb)
void	init(IR ir) Records all the register restrictions dictated by an IR.
boolean	isForbidden(Register symb, Register phys) Is it forbidden to assign symbolic register symb to physical register phys?
abstract boolean	isForbidden(Register symb, Register r, Instruction s) Is it forbidden to assign symbolic register symb to physical register r in instruction s?
boolean	mustNotSpill(Register r)
protected void	noteMustNotSpill(Register r)
private boolean	overlaps(LiveIntervalElement li1, LiveIntervalElement li2) Do two live ranges overlap?
private void	processBlock(BasicBlock bb, LiveInterval liveness) Records all the register restrictions dictated by live ranges on a particular basic block.

Methods inherited from class java.lang.Object

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

Field Detail

hash

private final HashMap<Register,GenericRegisterRestrictions.RestrictedRegisterSet> hash

noSpill

private final HashSet<Register> noSpill

phys

protected final GenericPhysicalRegisterSet phys

regAllocState

protected RegisterAllocatorState regAllocState

Constructor Detail

GenericRegisterRestrictions

protected GenericRegisterRestrictions(GenericPhysicalRegisterSet phys)

Method Detail

noteMustNotSpill

protected final void noteMustNotSpill(Register r)

mustNotSpill

public final boolean mustNotSpill(Register r)

init

public final void init(IR ir)

Records all the register restrictions dictated by an IR. PRECONDITION: the instructions in each basic block are numbered in increasing order before calling this.

Parameters:

ir - the IR to process

processBlock

private void processBlock(BasicBlock bb,
                          LiveInterval liveness)

Records 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.

Parameters:

bb - the bb to process

liveness - liveness information for the IR

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.

Parameters:

R - the live range

n - the instruction number

Returns:

true if and only if the live range contains an instruction with the given number

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.

Parameters:

li1 - first live range

li2 - second live range

Returns:

true if and only if the live ranges overlap

forbidAllVolatiles

final void forbidAllVolatiles(Register symb)

Records that it is illegal to assign a symbolic register symb to any volatile physical registerss.

Parameters:

symb - the register that must not be assigned to a volatile physical register

addRestrictions

protected final void addRestrictions(Register symb,
                                     BitSet set)

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

Parameters:

symb - the symbolic register to be restricted

set - the physical registers that the symbolic register must not be assigned to

addRestriction

protected final void addRestriction(Register symb,
                                    Register p)

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

Parameters:

symb - the symbolic register to be restricted

p - the physical register that the symbolic register must not be assigned to

getRestrictions

final GenericRegisterRestrictions.RestrictedRegisterSet getRestrictions(Register symb)

Parameters:

symb - the register whose restrictions where interested in

Returns:

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

allVolatilesForbidden

public final boolean allVolatilesForbidden(Register symb)

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

Parameters:

symb - symbolic register to check

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?

Parameters:

symb - a symbolic register

phys - a physical register

Returns:

true if it's forbidden, false otherwise

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?

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