Uses of Class
org.jikesrvm.compilers.opt.ir.Register

Packages that use Register

Package	Description
org.jikesrvm.adaptive.recompilation.instrumentation
org.jikesrvm.compilers.opt
org.jikesrvm.compilers.opt.bc2ir	Provides classes that implement the transformation from bytecode to the high-level intermediate representation (HIR).
org.jikesrvm.compilers.opt.depgraph	Provides classes that implement a dependence graph.
org.jikesrvm.compilers.opt.escape
org.jikesrvm.compilers.opt.ir
org.jikesrvm.compilers.opt.ir.ia32
org.jikesrvm.compilers.opt.ir.operand
org.jikesrvm.compilers.opt.ir.ppc
org.jikesrvm.compilers.opt.lir2mir.ia32	Provides classes that implement the IA32-specific parts of the transition from low-level IR to machine-specific IR.
org.jikesrvm.compilers.opt.liveness
org.jikesrvm.compilers.opt.mir2mc.ia32
org.jikesrvm.compilers.opt.regalloc
org.jikesrvm.compilers.opt.regalloc.ia32
org.jikesrvm.compilers.opt.ssa	SSA implementation (disabled because of bugs, see entry in issue tracker).

Uses of Register in org.jikesrvm.adaptive.recompilation.instrumentation

Method parameters in org.jikesrvm.adaptive.recompilation.instrumentation with type arguments of type Register

Modifier and Type	Method and Description
private static RegisterOperand	InstrumentationSamplingFramework.getOrCreateDupReg(RegisterOperand ro, IR ir, Map<Register,Register> dupMappings) The given register a) does not span multiple basic block, and b) is used in a basic block that is being duplicated.
private static RegisterOperand	InstrumentationSamplingFramework.getOrCreateDupReg(RegisterOperand ro, IR ir, Map<Register,Register> dupMappings) The given register a) does not span multiple basic block, and b) is used in a basic block that is being duplicated.

Uses of Register in org.jikesrvm.compilers.opt

Fields in org.jikesrvm.compilers.opt declared as Register

Modifier and Type	Field and Description
(package private) Register	LocalCSE.AvailableExpression.tmp temporary register holding the result of the available expression

Methods in org.jikesrvm.compilers.opt that return Register

Modifier and Type	Method and Description
private static Register	ExpressionFolding.isCandidateExpression(Instruction s, boolean ssa) Does instruction s compute a register r = candidate expression?

Methods in org.jikesrvm.compilers.opt with parameters of type Register

Modifier and Type	Method and Description
static Enumeration<RegisterOperand>	DefUse.defs(Register reg)
(package private) static boolean	DefUse.exactlyOneUse(Register reg)
private static void	DefUse.logAppearance(Register reg, int bbNum, int[] bbNums) Mark that we have seen a register in a particular basic block.
static void	DefUse.mergeRegisters(IR ir, Register reg1, Register reg2) Merges a register into another register and removes the merged register from the DU information.
(package private) static void	DefUse.printDefs(Register reg)
(package private) static void	DefUse.printUses(Register reg)
private static boolean	DefUse.seenInDifferentBlock(Register reg, int bbNum, int[] bbNums)
static Enumeration<RegisterOperand>	DefUse.uses(Register reg)

Method parameters in org.jikesrvm.compilers.opt with type arguments of type Register

Modifier and Type	Method and Description
private static void	ExpressionFolding.pruneCandidates(HashSet<Register> candidates) Prune the candidate set; restrict candidates to only allow transformations that result in dead code to be eliminated.

Constructors in org.jikesrvm.compilers.opt with parameters of type Register

Constructor and Description
AvailableExpression(Instruction i, Operator op, Operand[] ops, LocationOperand loc, Register t)

Uses of Register in org.jikesrvm.compilers.opt.bc2ir

Fields in org.jikesrvm.compilers.opt.bc2ir declared as Register

Modifier and Type	Field and Description
private Register[]	GenerationContext.addressLocals
private Register[]	GenerationContext.doubleLocals
private Register[]	GenerationContext.floatLocals
private Register[]	GenerationContext.intLocals
private Register[]	GenerationContext.longLocals
private Register	GenerationContext.resultReg The Register to which BC2IR should assign the return value(s) of the method.

Fields in org.jikesrvm.compilers.opt.bc2ir with type parameters of type Register

Modifier and Type	Field and Description
private HashMap<Register,RegisterOperand>	GenerationContext._ncGuards

Methods in org.jikesrvm.compilers.opt.bc2ir that return Register

Modifier and Type	Method and Description
private Register[]	GenerationContext.getPool(TypeReference type)
(package private) Register	GenerationContext.getResultReg()
(package private) Register	GenerationContext.localReg(int i, TypeReference type) Returns the Register used to for local i of TypeReference type.

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type Register

Modifier and Type	Method and Description
(package private) int	GenerationContext.getLocalNumberFor(Register reg, TypeReference type) Gets the local number for a given register
(package private) RegisterOperand	GenerationContext.makeNullCheckGuard(Register ref) Makes a register operand to use as a null check guard for the given register.

Uses of Register in org.jikesrvm.compilers.opt.depgraph

Methods in org.jikesrvm.compilers.opt.depgraph with parameters of type Register

Modifier and Type	Method and Description
private void	DepGraph.clearDepGraphNodeForRegister(Register r)
private void	DepGraph.computeImplicitBackwardDependencesDef(Register r, DepGraphNode destNode) Compute implicit backward dependences from a given register def to a given node.
private void	DepGraph.computeImplicitBackwardDependencesUse(Register r, DepGraphNode destNode) Compute implicit backward dependences from a given register use to a given node.
private void	DepGraph.computeImplicitForwardDependencesDef(Register r, DepGraphNode destNode) Compute implicit forward dependences from a given register def to a given node.
private void	DepGraph.computeImplicitForwardDependencesUse(Register r, DepGraphNode destNode) Compute implicit forward dependences from a given register use to a given node.
private DepGraphNode	DepGraph.getDepGraphNode(Register r)
private void	DepGraph.setDepGraphNodeForRegister(DepGraphNode dNode, Register r)

Uses of Register in org.jikesrvm.compilers.opt.escape

Fields in org.jikesrvm.compilers.opt.escape declared as Register

Modifier and Type	Field and Description
private Register	UnsyncReplacer.reg The register to replace
private Register	ObjectReplacer.reg the register holding the object reference
private Register	ShortArrayReplacer.reg the register holding the array reference

Fields in org.jikesrvm.compilers.opt.escape with type parameters of type Register

Modifier and Type	Field and Description
private HashMap<Register,Object>	FI_EscapeSummary.hash A mapping that holds the analysis result for thread-locality for each Register.
private HashMap<Register,Object>	FI_EscapeSummary.hash2 A mapping that holds the analysis result for method-locality for each Register.

Methods in org.jikesrvm.compilers.opt.escape with parameters of type Register

Modifier and Type	Method and Description
private static SimpleEscape.AnalysisResult	SimpleEscape.checkAllAppearances(Register reg, IR ir) Checks all appearances of a register, to see if any instruction in this method causes the object pointed to by the register to escape this thread and/or method.
private static boolean	SimpleEscape.checkIfUseEscapesMethod(Register reg, IR ir, Set<Register> visited)
private static boolean	SimpleEscape.checkIfUseEscapesThread(Register reg, IR ir, Set<Register> visited)
private static boolean	ShortArrayReplacer.containsUnsupportedUse(IR ir, Register reg, int size, RVMArray vmArray, Set<Register> visited) Some cases we don't handle yet.
private static boolean	ObjectReplacer.containsUnsupportedUse(IR ir, Register reg, RVMClass klass, Set<Register> visited) Some cases we don't handle yet.
private UnsyncReplacer	EscapeTransformations.getUnsyncReplacer(Register reg, Instruction inst, IR ir) Generate an object which transforms defs & uses of "synchronized" objects to defs & uses of "unsynchronized" objects PRECONDITION: objects pointed to by reg do NOT escape
(package private) boolean	FI_EscapeSummary.isMethodLocal(Register r)
(package private) boolean	FI_EscapeSummary.isThreadLocal(Register r)
(package private) void	FI_EscapeSummary.setMethodLocal(Register r, boolean b) Records the fact that ALL object pointed to by a symbolic register MUST (or may) escape this method.
(package private) void	FI_EscapeSummary.setThreadLocal(Register r, boolean b) Records the fact that ALL object pointed to by a symbolic register MUST (or may) escape this thread.
private static boolean	EscapeTransformations.synchronizesOn(Register r) Is there an instruction in this IR which causes synchronization on an object pointed to by a particular register?
private void	ShortArrayReplacer.transform2(Register reg, Instruction defI, RegisterOperand[] scalars)
private void	ObjectReplacer.transform2(Register reg, Instruction defI, RegisterOperand[] scalars, ArrayList<RVMField> fields, Set<Register> visited)

Method parameters in org.jikesrvm.compilers.opt.escape with type arguments of type Register

Modifier and Type	Method and Description
private static boolean	SimpleEscape.checkEscapesMethod(RegisterOperand use, IR ir, Set<Register> visited) Checks a single use, to see if this use may cause the object referenced to escape from this method.
private static boolean	SimpleEscape.checkEscapesThread(RegisterOperand use, IR ir, Set<Register> visited) Checks a single use, to see if this use may cause the object referenced to escape from this thread.
private static boolean	SimpleEscape.checkIfUseEscapesMethod(Register reg, IR ir, Set<Register> visited)
private static boolean	SimpleEscape.checkIfUseEscapesThread(Register reg, IR ir, Set<Register> visited)
private static boolean	ShortArrayReplacer.containsUnsupportedUse(IR ir, Register reg, int size, RVMArray vmArray, Set<Register> visited) Some cases we don't handle yet.
private static boolean	ObjectReplacer.containsUnsupportedUse(IR ir, Register reg, RVMClass klass, Set<Register> visited) Some cases we don't handle yet.
private void	ObjectReplacer.scalarReplace(RegisterOperand use, RegisterOperand[] scalars, ArrayList<RVMField> fields, Set<Register> visited) Replace a given use of a object with its scalar equivalent
private void	ShortArrayReplacer.scalarReplace(RegisterOperand use, RegisterOperand[] scalars, Set<Register> visited) Replace a given use of an array with its scalar equivalent.
private void	ObjectReplacer.transform2(Register reg, Instruction defI, RegisterOperand[] scalars, ArrayList<RVMField> fields, Set<Register> visited)

Constructors in org.jikesrvm.compilers.opt.escape with parameters of type Register

Constructor and Description
ObjectReplacer(Register r, RVMClass _klass, IR i)
ShortArrayReplacer(Register r, RVMArray a, int s, IR i)
UnsyncReplacer(Register r, OptOptions options)

Uses of Register in org.jikesrvm.compilers.opt.ir

Fields in org.jikesrvm.compilers.opt.ir declared as Register

Modifier and Type	Field and Description
private Register	AbstractRegisterPool.end
Register	Register.mapsToRegister
(package private) Register	Register.next
(package private) Register	Register.prev
private Register	AbstractRegisterPool.start
private Register	RegSpillListElement.symbolicReg this should be a symbolic register

Fields in org.jikesrvm.compilers.opt.ir with type parameters of type Register

Modifier and Type	Field and Description
private HashMap<Register,Register>	AbstractRegisterPool._regPairs When 2 registers are necessary to encode a result, such as with a long on 32bit architectures, this hash map remembers the pairing of registers.
private HashMap<Register,Register>	AbstractRegisterPool._regPairs When 2 registers are necessary to encode a result, such as with a long on 32bit architectures, this hash map remembers the pairing of registers.
private Enumeration<Register>	IREnumeration.AllDefsEnum.implicitDefs Implicit definitions from the operator
private Enumeration<Register>	IREnumeration.AllUsesEnum.implicitUses Implicit uses from the operator

Methods in org.jikesrvm.compilers.opt.ir that return Register

Modifier and Type	Method and Description
abstract Register	GenericPhysicalRegisterSet.get(int n)
Register	AbstractRegisterPool.getAddress() Gets a new address register.
Register	AbstractRegisterPool.getCondition() Gets a new condition register.
Register	AbstractRegisterPool.getDouble() Gets a new double register.
abstract Register	GenericPhysicalRegisterSet.getFirstReturnGPR()
Register	AbstractRegisterPool.getFirstSymbolicRegister()
Register	AbstractRegisterPool.getFloat() Gets a new float register.
Register	GenericRegisterPool.getFP() Get the Framepointer (FP)
abstract Register	GenericPhysicalRegisterSet.getFP()
abstract Register	GenericPhysicalRegisterSet.getFPR(int n)
abstract Register	GenericPhysicalRegisterSet.getGPR(int n)
abstract Register	GenericPhysicalRegisterSet.getGPR(MachineRegister n)
Register	AbstractRegisterPool.getInteger() Gets a new integer register.
Register	AbstractRegisterPool.getLong() Gets a new long register.
Register	Register.getNext()
Register	Register.getPrev()
Register	AbstractRegisterPool.getReg(Register template) Get a new register of the same type as the argument register
Register	AbstractRegisterPool.getReg(RegisterOperand template) Get a new register of the same type as the argument RegisterOperand
Register	AbstractRegisterPool.getReg(TypeReference type) Get a new register of the appropriate type to hold values of 'type'
Register	Register.getRegisterAllocated()
Register	AbstractRegisterPool.getSecondReg(Register reg) MIR: Get the other half of the register pair that is associated with the argument register.
Register	RegSpillListElement.getSymbolicReg() returns the symbolic register associated with this object
abstract Register	GenericPhysicalRegisterSet.getTR()
Register	AbstractRegisterPool.getValidation() Gets a new validation register.
private Register	AbstractRegisterPool.makeNewReg()
(package private) Register	Register.remove()

Methods in org.jikesrvm.compilers.opt.ir that return types with arguments of type Register

Modifier and Type	Method and Description
static Enumeration<Register>	GenericPhysicalDefUse.enumerate(int code, IR ir)
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateAll()
static Enumeration<Register>	GenericPhysicalDefUse.enumerateAllImplicitDefUses(IR ir)
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateGPRs()
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateNonvolatileFPRs()
Enumeration<Register>	GenericPhysicalRegisterSet.enumerateNonvolatileFPRsBackwards()
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateNonvolatileGPRs()
Enumeration<Register>	GenericPhysicalRegisterSet.enumerateNonvolatileGPRsBackwards()
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateNonvolatilesBackwards(int type)
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateVolatileFPRs()
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateVolatileGPRs()
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateVolatiles()
abstract Enumeration<Register>	GenericPhysicalRegisterSet.enumerateVolatiles(int type)

Methods in org.jikesrvm.compilers.opt.ir with parameters of type Register

Modifier and Type	Method and Description
static RegisterOperand	IRTools.A(Register reg) Create an integer register operand for a given register.
void	Register.allocateRegister(Register reg)
void	Register.allocateToRegister(Register reg)
(package private) void	Register.append(Register l)
static RegisterOperand	IRTools.CR(Register reg) Create a condition register operand for a given register.
static RegisterOperand	IRTools.D(Register reg) Create a double register operand for a given register.
static boolean	IRTools.definedIn(Register r, Instruction s)
static RegisterOperand	IRTools.F(Register reg) Create a float register operand for a given register.
static int	GenericPhysicalRegisterSet.getPhysicalRegisterType(Register symbReg)
Register	AbstractRegisterPool.getReg(Register template) Get a new register of the same type as the argument register
Register	AbstractRegisterPool.getSecondReg(Register reg) MIR: Get the other half of the register pair that is associated with the argument register.
static RegisterOperand	IRTools.I(Register reg) Create an integer register operand for a given register.
abstract boolean	GenericPhysicalRegisterSet.isAllocatable(Register p)
static RegisterOperand	IRTools.L(Register reg) Create a long register operand for a given register.
void	Register.linkWithNext(Register Next)
boolean	MachineSpecificIR.mutateFMOVs(LiveIntervalElement live, Register register, int dfnbegin, int dfnend)
private void	AbstractRegisterPool.registerListappend(Register reg)
private void	AbstractRegisterPool.registerListremove(Register e)
void	AbstractRegisterPool.removeRegister(Register reg)
void	Instruction.replaceRegister(Register r, Register n) Replace all occurances of register r with register n
(package private) void	Register.setNext(Register e)
void	RegSpillListElement.setRealReg(Register reg) Sets the real (i.e., physical) register component associated with this object
static boolean	IRTools.usedIn(Register r, Instruction s)

Constructors in org.jikesrvm.compilers.opt.ir with parameters of type Register

Constructor and Description
RegSpillListElement(Register symbolicReg) Constructor

Uses of Register in org.jikesrvm.compilers.opt.ir.ia32

Fields in org.jikesrvm.compilers.opt.ir.ia32 declared as Register

Modifier and Type	Field and Description
private Register[]	PhysicalRegisterSet.PhysicalRegisterEnumeration.r
private Register[]	PhysicalRegisterSet.reg This array holds a pool of objects representing physical registers

Methods in org.jikesrvm.compilers.opt.ir.ia32 that return Register

Modifier and Type	Method and Description
Register	PhysicalRegisterSet.get(int n)
Register	PhysicalRegisterSet.getAF()
Register	PhysicalRegisterSet.getC0()
Register	PhysicalRegisterSet.getC1()
Register	PhysicalRegisterSet.getC2()
Register	PhysicalRegisterSet.getC3()
Register	PhysicalRegisterSet.getCF()
Register	PhysicalRegisterSet.getEAX()
Register	PhysicalRegisterSet.getEBP()
Register	PhysicalRegisterSet.getEBX()
Register	PhysicalRegisterSet.getECX()
Register	PhysicalRegisterSet.getEDI()
Register	PhysicalRegisterSet.getEDX()
Register	PhysicalRegisterSet.getESI()
Register	PhysicalRegisterSet.getESP()
Register	PhysicalRegisterSet.getFirstReturnGPR()
Register	PhysicalRegisterSet.getFP()
Register	PhysicalRegisterSet.getFPR(int n)
Register	PhysicalRegisterSet.getFPR(RegisterConstants.FloatingPointMachineRegister n)
Register	PhysicalRegisterSet.getFPRParam(int n)
Register	PhysicalRegisterSet.getGPR(int n)
Register	PhysicalRegisterSet.getGPR(MachineRegister n)
Register	PhysicalRegisterSet.getGPRParam(int n)
Register	PhysicalRegisterSet.getNativeFPRParam(int n)
Register	PhysicalRegisterSet.getNativeGPRParam(int n)
Register	PhysicalRegisterSet.getOF()
Register	PhysicalRegisterSet.getPF()
private static Register	PhysicalDefUse.PDUEnumeration.getReg(int m, PhysicalRegisterSet phys)
Register	PhysicalRegisterSet.getReturnFPR()
Register	PhysicalRegisterSet.getReturnGPR(int n)
Register	PhysicalRegisterSet.getSecondReturnGPR()
Register	PhysicalRegisterSet.getSF()
Register	PhysicalRegisterSet.getST0()
Register	PhysicalRegisterSet.getST1()
Register	PhysicalRegisterSet.getTR()
Register	PhysicalRegisterSet.getZF()
Register	PhysicalRegisterSet.PhysicalRegisterEnumeration.nextElement()
Register	PhysicalRegisterSet.RangeEnumeration.nextElement()
Register	PhysicalDefUse.PDUEnumeration.nextElement()

Methods in org.jikesrvm.compilers.opt.ir.ia32 that return types with arguments of type Register

Modifier and Type	Method and Description
Enumeration<Register>	PhysicalRegisterSet.enumerateAll()
Enumeration<Register>	PhysicalRegisterSet.enumerateFPRs()
Enumeration<Register>	PhysicalRegisterSet.enumerateGPRs()
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatileGPRsBackwards()
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatiles(int regClass)
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatilesBackwards(int regClass)
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatiles()
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatiles(int regClass)

Methods in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type Register

Modifier and Type	Method and Description
static int	PhysicalRegisterSet.getFPRIndex(Register r)
static int	PhysicalRegisterSet.getGPRIndex(Register r)
static int	PhysicalRegisterSet.getPhysicalRegisterType(Register r) Given a symbolic register, return a code that gives the physical register type to hold the value of the symbolic register.
boolean	PhysicalRegisterSet.isAllocatable(Register r)

Constructors in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type Register

Constructor and Description
PhysicalRegisterEnumeration(Register[] r)

Uses of Register in org.jikesrvm.compilers.opt.ir.operand

Fields in org.jikesrvm.compilers.opt.ir.operand declared as Register

Modifier and Type	Field and Description
private Register	RegisterOperand.register Register object that this operand uses.

Methods in org.jikesrvm.compilers.opt.ir.operand that return Register

Modifier and Type	Method and Description
Register	RegisterOperand.getRegister()

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type Register

Modifier and Type	Method and Description
static Operand	Operand.meet(Operand op1, Operand op2, Register reg) Meet two operands based on their positions in the operand lattice.
void	RegisterOperand.setRegister(Register register)

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type Register

Constructor and Description
RegisterOperand(Register reg, TypeReference typ) Constructs a new register operand with the given register and data type.
RegisterOperand(Register reg, TypeReference typ, byte inFlags, boolean isPrecise, boolean isDeclared) Constructs a new register operand with the given register, data type and flags.

Uses of Register in org.jikesrvm.compilers.opt.ir.ppc

Fields in org.jikesrvm.compilers.opt.ir.ppc declared as Register

Modifier and Type	Field and Description
private Register[]	PhysicalRegisterSet.reg This array holds a pool of objects representing physical registers

Methods in org.jikesrvm.compilers.opt.ir.ppc that return Register

Modifier and Type	Method and Description
Register	PhysicalRegisterSet.get(int n)
Register	PhysicalRegisterSet.getConditionRegister(int n)
Register	PhysicalRegisterSet.getCR()
Register	PhysicalRegisterSet.getCTR()
Register	PhysicalRegisterSet.getFirstConditionRegister()
Register	PhysicalRegisterSet.getFirstNonvolatileFPR()
Register	PhysicalRegisterSet.getFirstNonvolatileGPR()
Register	PhysicalRegisterSet.getFirstReturnGPR()
Register	PhysicalRegisterSet.getFirstScratchFPR()
Register	PhysicalRegisterSet.getFirstScratchGPR()
Register	PhysicalRegisterSet.getFirstVolatile(int regClass)
Register	PhysicalRegisterSet.getFirstVolatileConditionRegister()
Register	PhysicalRegisterSet.getFirstVolatileFPR()
Register	PhysicalRegisterSet.getFirstVolatileGPR()
Register	PhysicalRegisterSet.getFP()
Register	PhysicalRegisterSet.getFPR(int n)
Register	PhysicalRegisterSet.getGPR(int n)
Register	PhysicalRegisterSet.getGPR(MachineRegister n)
Register	PhysicalRegisterSet.getJTOC()
Register	RegisterPool.getJTOC() Get the JTOC register
Register	PhysicalRegisterSet.getLastNonvolatile(int regClass)
Register	PhysicalRegisterSet.getLastNonvolatileFPR()
Register	PhysicalRegisterSet.getLastNonvolatileGPR()
Register	PhysicalRegisterSet.getLastScratchFPR()
Register	PhysicalRegisterSet.getLastScratchGPR()
Register	PhysicalRegisterSet.getLR()
private static Register	PhysicalDefUse.PDUEnumeration.getReg(int m, PhysicalRegisterSet phys)
Register	PhysicalRegisterSet.getSecondHalf(Register r)
Register	PhysicalRegisterSet.getTemp()
Register	PhysicalRegisterSet.getTL()
Register	PhysicalRegisterSet.getTR()
Register	PhysicalRegisterSet.getTSR()
Register	PhysicalRegisterSet.getTU()
Register	PhysicalRegisterSet.getXER()
Register	PhysicalRegisterSet.PhysicalRegisterEnumeration.nextElement()
Register	PhysicalDefUse.PDUEnumeration.nextElement()

Methods in org.jikesrvm.compilers.opt.ir.ppc that return types with arguments of type Register

Modifier and Type	Method and Description
Enumeration<Register>	PhysicalRegisterSet.enumerateAll()
Enumeration<Register>	PhysicalRegisterSet.enumerateFPRParameters(int n) Enumerates the first n FPR parameters.
Enumeration<Register>	PhysicalRegisterSet.enumerateGPRParameters(int n) Enumerate the first n GPR parameters.
Enumeration<Register>	PhysicalRegisterSet.enumerateGPRs()
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatileConditionRegisters() Enumerates the non-volatile physical condition registers.
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatileFPRs()
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatileGPRs()
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatileGPRsBackwards()
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatiles(int regClass) Enumerate the nonvolatile physical registers of a given class.
Enumeration<Register>	PhysicalRegisterSet.enumerateNonvolatilesBackwards(int regClass)
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatileConditionRegisters() Enumerates the volatile physical condition registers.
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatileFPRs() Enumerates all the volatile FPRs in this set.
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatileGPRs()
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatiles()
Enumeration<Register>	PhysicalRegisterSet.enumerateVolatiles(int regClass) Enumerate the volatile physical registers of a given class.

Methods in org.jikesrvm.compilers.opt.ir.ppc with parameters of type Register

Modifier and Type	Method and Description
int	PhysicalRegisterSet.getFPRParamIndex(Register r)
int	PhysicalRegisterSet.getGPRParamIndex(Register r)
static int	PhysicalRegisterSet.getPhysicalRegisterType(Register r) Given a symbolic register, return a cdoe that gives the physical register type to hold the value of the symbolic register.
Register	PhysicalRegisterSet.getSecondHalf(Register r)
byte	PhysicalRegisterSet.getSPR(Register r) Given a physical register (XER, LR, or CTR), return the integer that denotes the PowerPC Special Purpose Register (SPR) in the PPC instruction set.
boolean	PhysicalRegisterSet.isAllocatable(Register r) Is a certain physical register allocatable?

Uses of Register in org.jikesrvm.compilers.opt.lir2mir.ia32

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 that return Register

Modifier and Type	Method and Description
protected Register	BURS_Helpers.getEAX()
protected Register	BURS_Helpers.getEBP()
protected Register	BURS_Helpers.getEBX()
protected Register	BURS_Helpers.getECX()
protected Register	BURS_Helpers.getEDI()
protected Register	BURS_Helpers.getEDX()
protected Register	BURS_Helpers.getESI()
protected Register	BURS_Helpers.getESP()
protected Register	BURS_Helpers.getFPR(int n)
protected Register	BURS_Helpers.getST0()

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 with parameters of type Register

Modifier and Type	Method and Description
private static void	ComplexLIR2MIRExpansion.basic_long_ifcmp(Instruction s, IR ir, ConditionOperand cond, Register xh, Register xl, Operand yh, Operand yl)

Uses of Register in org.jikesrvm.compilers.opt.liveness

Methods in org.jikesrvm.compilers.opt.liveness that return Register

Modifier and Type	Method and Description
Register	LiveSetElement.getRegister() Returns the register associated with this element

Methods in org.jikesrvm.compilers.opt.liveness that return types with arguments of type Register

Modifier and Type	Method and Description
HashSet<Register>	LiveAnalysis.getLiveRegistersOnEdge(BasicBlock bb1, BasicBlock bb2) Return the set of registers that are live on the control-flow edge basic block bb1 to basic block bb2
(package private) HashSet<Register>	LiveAnalysis.getLiveRegistersOnEntry(BasicBlock bb)
(package private) HashSet<Register>	LiveAnalysis.getLiveRegistersOnExit(BasicBlock bb)

Methods in org.jikesrvm.compilers.opt.liveness with parameters of type Register

Modifier and Type	Method and Description
private void	LiveAnalysis.addToRegisterMap(Register r, LiveIntervalElement i)
boolean	LiveSet.contains(Register item) Determines if the item passed is in the current set
private boolean	LiveInterval.containsUnresolvedElement(BasicBlock block, Register reg) Check to see if an unresolved LiveIntervalElement node for the register passed exists for the basic block passed.
void	LiveInterval.createEndLiveRange(Register reg, BasicBlock block, Instruction inst) This method checks if an existing unresolved live interval node, i.e., one that has an end instruction, but no beginning instruction, is present for the register and basic block passed.
Iterator<LiveIntervalElement>	LiveAnalysis.iterateLiveIntervals(Register r)
void	LiveAnalysis.merge(Register r1, Register r2) Update the data structures to reflect that all live intervals for r2 are now intervals for r1.
void	LiveInterval.setStartLiveRange(Register reg, Instruction inst, BasicBlock block) This method finds the LiveInterval node for the register and basic block passed.

Uses of Register in org.jikesrvm.compilers.opt.mir2mc.ia32

Fields in org.jikesrvm.compilers.opt.mir2mc.ia32 declared as Register

Modifier and Type	Field and Description
private Register	AssemblerBase.EBP Hold EBP register object for use in estimating size of memory operands.
private Register	AssemblerBase.ESP Hold EBP register object for use in estimating size of memory operands.

Methods in org.jikesrvm.compilers.opt.mir2mc.ia32 with parameters of type Register

Modifier and Type	Method and Description
private RegisterConstants.GPR	AssemblerBase.getGPMachineRegister(Register reg) Return the machine-level register number corresponding to a given integer Register.
private MachineRegister	AssemblerBase.getMachineRegister(Register reg) Return the machine-level register number corresponding to a given Register.

Uses of Register in org.jikesrvm.compilers.opt.regalloc

Fields in org.jikesrvm.compilers.opt.regalloc declared as Register

Modifier and Type	Field and Description
Register	GenericStackManager.ScratchRegister.currentContents The current contents of scratch
(package private) Register	CoalesceGraph.Node.r
private Register	CompoundInterval.reg The register this compound interval represents or null if this interval is not associated with a register (i.e. if it represents a spill location).
private Register	LiveIntervalElement.register register that this live interval is for
protected Register	ScratchMap.Interval.scratch The physical scratch register or register evicted.
Register	GenericStackManager.ScratchRegister.scratch The physical register used as scratch.
private Register	ScratchMap.SymbolicInterval.symbolic The symbolic register

Fields in org.jikesrvm.compilers.opt.regalloc with type parameters of type Register

Modifier and Type	Field and Description
private HashMap<Instruction,HashSet<Register>>	ScratchMap.dirtyMap For each GC Point s, a set of symbolic registers that are cached in dirty scratch registers before s.
private HashMap<Register,GenericRegisterRestrictions.RestrictedRegisterSet>	GenericRegisterRestrictions.hash
private HashMap<Register,Double>	SpillCostEstimator.map
private HashMap<Register,ArrayList<ScratchMap.Interval>>	ScratchMap.map For each register, the set of intervals describing the register.
(package private) HashMap<Register,CoalesceGraph.Node>	CoalesceGraph.nodeMap Mapping register -> Node
private HashSet<Register>	GenericRegisterRestrictions.noSpill
private HashMap<Register,ScratchMap.Interval>	ScratchMap.pending For each register, a pending (incomplete) interval under construction.

Methods in org.jikesrvm.compilers.opt.regalloc that return Register

Modifier and Type	Method and Description
Register	GenericStackManager.allocateNonVolatileRegister(Register symbReg) Find a nonvolatile register to allocate starting at the reg corresponding to the symbolic register passed.
Register	GenericStackManager.allocateVolatileRegister(Register symbReg) Find an volatile register to allocate starting at the reg corresponding to the symbolic register passed
(package private) Register	ActiveSet.findAvailableRegister(CompoundInterval ci)
(package private) Register	ActiveSet.findAvailableRegister(Register symb)
(package private) Register	CompoundInterval.getAssignment(RegisterAllocatorState regAllocState)
private Register	GenericStackManager.getFirstDeadFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a FPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
private Register	GenericStackManager.getFirstDeadGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a GPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
private Register	GenericStackManager.getFirstFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Returns a FPR that does not appear in instruction s, to be used as a scratch register to hold register r.
private Register	GenericStackManager.getFirstGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a GPR that does not appear in instruction s, to hold symbolic register r.
(package private) Register	RegisterAllocatorState.getMapping(Register r)
private Register	ActiveSet.getPhysicalPreference(CompoundInterval ci) Given the current state of the register allocator, compute the available physical register to which an interval has the highest preference.
private Register	ActiveSet.getPhysicalPreference(Register r) Given the current state of the register allocator, compute the available physical register to which a symbolic register has the highest preference.
(package private) Register	CompoundInterval.getRegister()
(package private) Register	CoalesceGraph.Node.getRegister()
Register	LiveIntervalElement.getRegister()
(package private) Register	ScratchMap.getScratch(Register r, int n) Gets the scratch register if a matching one exists.
private Register	GenericStackManager.spillLocationUse(int loc, Instruction s) Assuming instruction s uses the spill location loc, return the symbolic register that embodies that use.
private Register	GenericStackManager.spillLocationUse(Register r, Instruction s)

Methods in org.jikesrvm.compilers.opt.regalloc that return types with arguments of type Register

Modifier and Type	Method and Description
private ArrayList<Register>	GenericStackManager.getReservedScratchRegisters(Instruction s)

Methods in org.jikesrvm.compilers.opt.regalloc with parameters of type Register

Modifier and Type	Method and Description
(package private) void	GenericRegisterRestrictions.RestrictedRegisterSet.add(Register r)
(package private) void	CoalesceGraph.addAffinity(int w, Register r1, Register r2)
protected void	GenericRegisterPreferences.addAffinity(int w, Register r1, Register r2) Adds a affinity of weight w between two registers.
protected void	GenericRegisterRestrictions.addRestriction(Register symb, Register p) Record thats it is illegal to assign a symbolic register symb to a physical register p.
protected void	GenericRegisterRestrictions.addRestrictions(Register symb, BitSet set) Records that it is illegal to assign a symbolic register symb to any of a set of physical registers.
private boolean	ActiveSet.allocateNewSymbolicToPhysical(Register symb, Register p) NOTE: This routine assumes we're processing the first interval of register symb; so p.isAvailable() is the key information needed.
Register	GenericStackManager.allocateNonVolatileRegister(Register symbReg) Find a nonvolatile register to allocate starting at the reg corresponding to the symbolic register passed.
private boolean	ActiveSet.allocateToPhysical(CompoundInterval i, Register p) Checks whether it's ok to allocate an interval to a physical register.
Register	GenericStackManager.allocateVolatileRegister(Register symbReg) Find an volatile register to allocate starting at the reg corresponding to the symbolic register passed
boolean	GenericRegisterRestrictions.allVolatilesForbidden(Register symb) Is it forbidden to assign symbolic register symb to any volatile register?
private boolean	GenericStackManager.appearsIn(Register r, Instruction s)
(package private) void	CompoundInterval.assign(Register r) Assign this compound interval to a physical register.
boolean	Coalesce.attempt(LiveAnalysis live, Register r1, Register r2) Attempt to coalesce register r2 into register r1.
(package private) void	ScratchMap.beginScratchInterval(Register r, Instruction begin) Begin a new interval of scratch-ness for a physical register.
(package private) void	ScratchMap.beginSymbolicInterval(Register r, Register scratch, Instruction begin) Begin a new interval of scratch-ness for a symbolic register.
(package private) void	RegisterAllocatorState.clearOneToOne(Register r) Clears any 1-to-1 mapping for a register.
(package private) boolean	GenericRegisterRestrictions.RestrictedRegisterSet.contains(Register r)
(package private) CompoundInterval	CompoundInterval.copy(Register r) Copies the ranges from this interval into a new interval associated with a register.
(package private) CompoundInterval	CompoundInterval.copy(Register r, BasicInterval stop) Copies the basic intervals up to and including stop into a new interval.
private GenericStackManager.ScratchRegister	GenericStackManager.createScratchBefore(RegisterAllocatorState regAllocState, Instruction s, Register r, Register symb) Make physicals register r available to be used as a scratch register before instruction s.
(package private) boolean	ActiveSet.currentlyActive(Register r)
private boolean	GenericStackManager.definesSpillLocation(Register r, Instruction s)
void	ScratchMap.endScratchInterval(Register r, Instruction end) End an interval of scratch-ness for a physical register.
void	ScratchMap.endSymbolicInterval(Register r, Instruction end) End an interval of scratch-ness for a symbolic register.
(package private) Register	ActiveSet.findAvailableRegister(Register symb)
(package private) CoalesceGraph.Node	CoalesceGraph.findNode(Register r)
private ArrayList<ScratchMap.Interval>	ScratchMap.findOrCreateIntervalSet(Register r) Find or create the set of intervals corresponding to a register r.
private CoalesceGraph.Node	CoalesceGraph.findOrCreateNode(Register r)
(package private) void	GenericRegisterRestrictions.forbidAllVolatiles(Register symb) Records that it is illegal to assign a symbolic register symb to any volatile physical registerss.
(package private) BasicInterval	ActiveSet.getBasicInterval(Register r, Instruction s) Finds a basic interval for a register so that the interval contains the instruction.
(package private) double	SpillCostEstimator.getCost(Register r) Returns a number that represents an estimate of the relative cost of spilling register r.
(package private) CompoundInterval	ActiveSet.getCurrentInterval(Register r)
private GenericStackManager.ScratchRegister	GenericStackManager.getCurrentScratchRegister(Register r, Instruction s) If there is a scratch register available which currently holds the value of symbolic register r, then return that scratch register.
private GenericStackManager.ScratchRegister	GenericStackManager.getFirstAvailableScratchRegister(Register r, Instruction s) Finds the first available register which can serve as a scratch register for symbolic register r in instruction s.
private Register	GenericStackManager.getFirstDeadFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a FPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
private Register	GenericStackManager.getFirstDeadGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a GPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
private Register	GenericStackManager.getFirstFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Returns a FPR that does not appear in instruction s, to be used as a scratch register to hold register r.
private Register	GenericStackManager.getFirstGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a GPR that does not appear in instruction s, to hold symbolic register r.
(package private) CompoundInterval	RegisterAllocatorState.getInterval(Register reg) Returns the interval associated with the passed register.
(package private) Register	RegisterAllocatorState.getMapping(Register r)
private Register	ActiveSet.getPhysicalPreference(Register r) Given the current state of the register allocator, compute the available physical register to which a symbolic register has the highest preference.
private GenericStackManager.ScratchRegister	GenericStackManager.getPhysicalScratchRegister(Register r)
(package private) GenericRegisterRestrictions.RestrictedRegisterSet	GenericRegisterRestrictions.getRestrictions(Register symb)
(package private) Register	ScratchMap.getScratch(Register r, int n) Gets the scratch register if a matching one exists.
private GenericStackManager.ScratchRegister	GenericStackManager.getScratchRegister(Register symb, Instruction s, boolean beCheap) Gets a scratch register to hold symbolic register symb in instruction s.
private GenericStackManager.ScratchRegister	GenericStackManager.getScratchRegisterUsingIntervals(Register r, Instruction s) Finds a register which can serve as a scratch register for symbolic register r in instruction s.
int	RegisterAllocatorState.getSpill(Register reg)
byte	GenericStackManager.getValueType(Register r) Given a symbolic register, return a code that indicates the type of the value stored in the register.
private GenericStackManager.ScratchRegister	GenericStackManager.holdInScratchAfter(Instruction s, Register symb, boolean beCheap) Inserts code as needed so that after instruction s, the value of a symbolic register will be held in a particular scratch physical register.
void	GenericStackManager.insertSpillAfter(Instruction s, Register r, byte type, int location) Insert a spill of a physical register after instruction s.
abstract void	GenericStackManager.insertSpillBefore(Instruction s, Register r, byte type, int location) Insert a spill of a physical register before instruction s.
void	GenericStackManager.insertUnspillAfter(Instruction s, Register r, byte type, int location) Insert a load of a physical register from a spill location before instruction s.
abstract void	GenericStackManager.insertUnspillBefore(Instruction s, Register r, byte type, int location) Insert a load of a physical register from a spill location before instruction s.
boolean	GenericStackManager.isDeadBefore(Register r, Instruction s)
boolean	ScratchMap.isDirty(Instruction s, Register r) At GC point s, is the value of register r cached in a dirty scratch register?
boolean	GenericRegisterRestrictions.isForbidden(Register symb, Register phys) Is it forbidden to assign symbolic register symb to physical register phys?
abstract boolean	GenericRegisterRestrictions.isForbidden(Register symb, Register r, Instruction s) Is it forbidden to assign symbolic register symb to physical register r in instruction s?
protected boolean	GenericStackManager.isLegal(Register symb, Register phys, Instruction s)
private boolean	Coalesce.isLiveAtDef(Register r1, Register r2, LiveAnalysis live) Is register r1 live at any def of register r2?
(package private) boolean	ScratchMap.isScratch(Register r, int n) Is the given physical register being used as a scratch register in the given instruction?
(package private) void	RegisterAllocatorState.mapOneToOne(Register A, Register B) Records that register A and register B are associated with each other in a bijection.
void	ScratchMap.markDirty(Instruction s, Register symb) Records that the real value of a symbolic register is cached in a dirty scratch register at a given instruction that is a GC point.
private GenericStackManager.ScratchRegister	GenericStackManager.moveToScratchBefore(Instruction s, Register symb, boolean beCheap) Assigns symbolic register symb to a physical register, and inserts code before instruction s to load the register from the appropriate stack location.
boolean	GenericRegisterRestrictions.mustNotSpill(Register r)
private boolean	IntervalAnalysis.mutateFMOVs(LiveIntervalElement live, Register register, int dfnbegin, int dfnend) Mutate FMOVs that end live ranges
abstract boolean	GenericStackManager.needScratch(Register r, Instruction s) Given symbolic register r in instruction s, do we need to ensure that r is in a scratch register is s (as opposed to a memory operand)
protected void	GenericRegisterRestrictions.noteMustNotSpill(Register r)
private void	GenericStackManager.replaceRegisterWithScratch(Instruction s, Register r1, Register r2) Replaces all occurrences of register r1 in an instruction with register r2.
(package private) void	RegisterAllocatorState.setInterval(Register reg, CompoundInterval interval) Associates the passed live interval with the passed register.
(package private) void	UpdateOSRMaps.setRealPosition(IR ir, LocalRegPair tuple, Register sym_reg)
void	LiveIntervalElement.setRegister(Register r)
(package private) void	RegisterAllocatorState.setSpill(Register reg, int spill)
private Register	GenericStackManager.spillLocationUse(Register r, Instruction s)
private boolean	Coalesce.split(Register r1, Register r2) Is there an instruction r1 = split r2 or r2 = split r1??
protected void	SpillCostEstimator.update(Register r, double delta) Updates the cost for a particular register.
private void	ActiveSet.updatePhysicalInterval(Register p, BasicInterval i) Updates the interval representing the allocations of a physical register p to include a new interval i.
private void	ActiveSet.updatePhysicalInterval(Register p, CompoundInterval c, BasicInterval stop) Update the interval representing the allocations of a physical register p to include a new compound interval c.
private boolean	GenericStackManager.usesSpillLocation(Register r, Instruction s)

Method parameters in org.jikesrvm.compilers.opt.regalloc with type arguments of type Register

Modifier and Type	Method and Description
private Register	GenericStackManager.getFirstDeadFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a FPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
private Register	GenericStackManager.getFirstDeadGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a GPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
private Register	GenericStackManager.getFirstFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Returns a FPR that does not appear in instruction s, to be used as a scratch register to hold register r.
private Register	GenericStackManager.getFirstGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved) Return a GPR that does not appear in instruction s, to hold symbolic register r.

Constructors in org.jikesrvm.compilers.opt.regalloc with parameters of type Register

Constructor and Description
CompoundInterval(BasicInterval i, Register register) Creates a new compound interval of a single Basic interval.
CompoundInterval(int dfnBegin, int dfnEnd, Register register) Creates a new compound interval of a single Basic interval.
CompoundInterval(Register r) Dangerous constructor: use with care.
Interval(Register scratch)
LiveIntervalElement(Register reg) Use this constructor when the live interval spans a basic block boundary.
LiveIntervalElement(Register reg, Instruction begin, Instruction end) Use this constructur when the live interval is within a basic block
Node(Register r)
PhysicalInterval(Register scratch)
ScratchRegister(Register scratch, Register currentContents)
SymbolicInterval(Register symbolic, Register scratch)

Uses of Register in org.jikesrvm.compilers.opt.regalloc.ia32

Methods in org.jikesrvm.compilers.opt.regalloc.ia32 with parameters of type Register

Modifier and Type	Method and Description
void	StackManager.insertSpillBefore(Instruction s, Register r, byte type, int location)
void	StackManager.insertUnspillBefore(Instruction s, Register r, byte type, int location)
boolean	RegisterRestrictions.isForbidden(Register symb, Register r, Instruction s)
static boolean	RegisterRestrictions.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?
boolean	StackManager.needScratch(Register r, Instruction s)
private boolean	RegisterRestrictions.okFor8(Register r)
(package private) void	RegisterRestrictions.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.

Method parameters in org.jikesrvm.compilers.opt.regalloc.ia32 with type arguments of type Register

Modifier and Type	Method and Description
private static RegisterOperand	MIRSplitRanges.findOrCreateTemp(RegisterOperand rOp, HashMap<Register,Register> map, IR ir) Finds or creates a temporary register to cache a symbolic register.
private static RegisterOperand	MIRSplitRanges.findOrCreateTemp(RegisterOperand rOp, HashMap<Register,Register> map, IR ir) Finds or creates a temporary register to cache a symbolic register.
private static void	MIRSplitRanges.splitAllLiveRanges(Instruction s, HashMap<Register,Register> newMap, IR ir, boolean rootOnly) Split the live ranges of all register operands of an instruction
private static void	MIRSplitRanges.splitAllLiveRanges(Instruction s, HashMap<Register,Register> newMap, IR ir, boolean rootOnly) Split the live ranges of all register operands of an instruction

Uses of Register in org.jikesrvm.compilers.opt.ssa

Fields in org.jikesrvm.compilers.opt.ssa with type parameters of type Register

Modifier and Type	Field and Description
private HashMap<Register,Register>	LeaveSSA.associatedRegisters
private HashMap<Register,Register>	LeaveSSA.associatedRegisters
private HashSet<Register>	LeaveSSA.globalRenamePhis
private HashMap<Register,Integer>	LeaveSSA.guardRegUnion
private HashSet<Register>	LoopVersioning.loopRegisterSet Set used to store the loop related register
private HashSet<Register>	EnterSSA.nonLocalRegisters A set of registers determined to span basic blocks

Methods in org.jikesrvm.compilers.opt.ssa that return Register

Modifier and Type	Method and Description
(package private) static Register	LoadElimination.findOrCreateRegister(Object heapType, int valueNumber, HashMap<LoadElimination.UseRecord,Register> registers, GenericRegisterPool pool, TypeReference type) Given a value number, return the temporary register allocated for that value number.
(package private) static Register	LoadElimination.findOrCreateRegister(Object heapType, int v1, int v2, HashMap<LoadElimination.UseRecord,Register> registers, GenericRegisterPool pool, TypeReference type) Given a pair of value numbers, return the temporary register allocated for that pair.
private Register[]	EnterSSA.getSymbolicRegisters() Set up a mapping from symbolic register number to the register.
private Register	LeaveSSA.guardFind(Register r)
private Register	LeaveSSA.guardUnion(Register from, Register to)

Methods in org.jikesrvm.compilers.opt.ssa that return types with arguments of type Register

Modifier and Type	Method and Description
private static HashSet<Register>	LiveRangeSplitting.LiveRangeSplittingPhase.findOrCreateSplitSet(HashMap<LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair,HashSet<Register>> map, BasicBlock b1, BasicBlock b2) Given a mapping from BasicBlockPair -> HashSet, find or create the hash set corresponding to a given basic block pair
private static HashMap<LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair,HashSet<Register>>	LiveRangeSplitting.LiveRangeSplittingPhase.findSplitPoints(IR ir, LiveAnalysis live, LSTGraph lst) Find the points the IR where live ranges should be split.

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type Register

Modifier and Type	Method and Description
(package private) static void	LoadElimination.appendMove(Register r, Operand src, Instruction store) Append a move instruction after a store instruction that caches value in register r.
private ValueGraphVertex	ValueGraph.findOrCreateVertex(Register r) Find or create an ValueGraphVertex corresponding to a given register
private TypeReference	EnterSSA.findParameterType(Register p)
private Register	LeaveSSA.guardFind(Register r)
private Register	LeaveSSA.guardUnion(Register from, Register to)
private void	EnterSSA.insertPhi(BasicBlock bb, Register r) Insert a phi function for a symbolic register at the head of a basic block.
private void	EnterSSA.insertPhiFunctions(IR ir, BitVector[] defs, Register[] symbolics, boolean excludeGuards) Insert the necessary phi functions into an IR.
private boolean	LoopVersioning.isOptimizedLoop(Register reg) Check whether the loop that contain such iterator register had been optimized
(package private) static Instruction	SSA.makeMoveInstruction(IR ir, Register r1, ConstantOperand c) Create a move instruction r1 := c.
(package private) static Instruction	SSA.makeMoveInstruction(IR ir, Register r1, Register r2, TypeReference t) Create a move instruction r1 := r2.
private Instruction	EnterSSA.makePhiInstruction(Register r, BasicBlock bb) Create a phi-function instruction
(package private) Operand	LeaveSSA.VariableStacks.peek(Register s) Get the name at the top of the stack for a particular register
(package private) Operand	LeaveSSA.VariableStacks.pop(Register s) Pop the name at the top of the stack for a particular register
(package private) void	LeaveSSA.VariableStacks.push(Register s, Operand name) Push a name at the top of the stack for a particular register
private void	EnterSSA.renameSymbolicRegisters(Register[] symbolicRegisters) Rename the symbolic registers so that each register has only one definition.
(package private) static void	LoadElimination.replaceLoadWithMove(Register r, Instruction load) Replace a Load instruction s with a load from a scalar register r TODO: factor this functionality out elsewhere
private void	LoopVersioning.setOptimizedLoop(Register reg) Put the optimized loop's iterator register into the hash set
private boolean	LeaveSSA.usedBelowCopy(BasicBlock bb, Register r)

Method parameters in org.jikesrvm.compilers.opt.ssa with type arguments of type Register

Modifier and Type	Method and Description
private static void	LiveRangeSplitting.LiveRangeSplittingPhase.addEntriesForInfrequentBlocks(IR ir, LiveAnalysis live, HashMap<LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair,HashSet<Register>> result) Split live ranges on entry and exit to infrequent regions.
private boolean	LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop, BasicBlock block, ArrayList<Instruction> checksToEliminate, BasicBlock unoptimizedLoopEntry, BasicBlock optimizedLoopEntry, HashMap<Register,Register> optimalRegMap)
private boolean	LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop, BasicBlock block, ArrayList<Instruction> checksToEliminate, BasicBlock unoptimizedLoopEntry, BasicBlock optimizedLoopEntry, HashMap<Register,Register> optimalRegMap)
private HashMap<BasicBlock,BasicBlock>	LoopVersioning.createCloneLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, HashMap<Register,BasicBlock> regToBlockMap) Create a clone of the loop replacing definitions in the cloned loop with those found in the register map
private HashMap<BasicBlock,BasicBlock>	LoopVersioning.createCloneLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, HashMap<Register,BasicBlock> regToBlockMap) Create a clone of the loop replacing definitions in the cloned loop with those found in the register map
private HashMap<BasicBlock,BasicBlock>	LoopVersioning.createCloneLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, HashMap<Register,BasicBlock> regToBlockMap) Create a clone of the loop replacing definitions in the cloned loop with those found in the register map
private HashMap<BasicBlock,BasicBlock>	LoopVersioning.createOptimizedLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, ArrayList<Instruction> instrToEliminate, HashMap<Register,BasicBlock> regToBlockMap) Create a clone of the loop replacing definitions in the cloned loop with those found in the register map and eliminate unnecessary bound checks
private HashMap<BasicBlock,BasicBlock>	LoopVersioning.createOptimizedLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, ArrayList<Instruction> instrToEliminate, HashMap<Register,BasicBlock> regToBlockMap) Create a clone of the loop replacing definitions in the cloned loop with those found in the register map and eliminate unnecessary bound checks
private HashMap<BasicBlock,BasicBlock>	LoopVersioning.createOptimizedLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, ArrayList<Instruction> instrToEliminate, HashMap<Register,BasicBlock> regToBlockMap) Create a clone of the loop replacing definitions in the cloned loop with those found in the register map and eliminate unnecessary bound checks
(package private) static Register	LoadElimination.findOrCreateRegister(Object heapType, int valueNumber, HashMap<LoadElimination.UseRecord,Register> registers, GenericRegisterPool pool, TypeReference type) Given a value number, return the temporary register allocated for that value number.
(package private) static Register	LoadElimination.findOrCreateRegister(Object heapType, int v1, int v2, HashMap<LoadElimination.UseRecord,Register> registers, GenericRegisterPool pool, TypeReference type) Given a pair of value numbers, return the temporary register allocated for that pair.
private static HashSet<Register>	LiveRangeSplitting.LiveRangeSplittingPhase.findOrCreateSplitSet(HashMap<LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair,HashSet<Register>> map, BasicBlock b1, BasicBlock b2) Given a mapping from BasicBlockPair -> HashSet, find or create the hash set corresponding to a given basic block pair
private BasicBlock	LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate bound check branch blocks
private BasicBlock	LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate bound check branch blocks
private BasicBlock	LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop, ArrayList<Instruction> checksToEliminate, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate null check branch blocks
private BasicBlock	LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop, ArrayList<Instruction> checksToEliminate, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate null check branch blocks
private void	LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap) Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
private void	LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap) Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
private void	LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap) Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
private void	LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap) Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
private void	LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap) Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
private void	LoopVersioning.getRegistersDefinedInLoop(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> definingInstructions) Get registers defined in the given loop.
private void	LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
private void	LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
(package private) static void	LoadElimination.replaceDefs(IR ir, LoadElimination.UseRecordSet UseRepSet, HashMap<LoadElimination.UseRecord,Register> registers) Perform scalar replacement actions for a Def of a heap variable.
(package private) static LoadElimination.UseRecordSet	LoadElimination.replaceLoads(IR ir, DF_Solution available, HashMap<LoadElimination.UseRecord,Register> registers) Walk over each instruction.
private static void	LiveRangeSplitting.LiveRangeSplittingPhase.transform(IR ir, HashMap<LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair,HashSet<Register>> xform) Perform the transformation