|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||
| Uses of Register in org.jikesrvm.compilers.opt |
|---|
| Fields in org.jikesrvm.compilers.opt declared as Register | |
|---|---|
(package private) Register |
LocalCSE.AvailableExpression.tmp
temporary register holding the result of the available expression |
| Methods in org.jikesrvm.compilers.opt that return Register | |
|---|---|
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 | |
|---|---|
static Enumeration<RegisterOperand> |
DefUse.defs(Register reg)
Enumerate all operands that def a given register. |
(package private) static boolean |
DefUse.exactlyOneUse(Register reg)
Does a given register have exactly one use? |
private static void |
DefUse.logAppearance(Register reg,
int bbNum)
Mark that we have seen a register in a particular basic block, and whether we saw a use |
static void |
DefUse.mergeRegisters(IR ir,
Register reg1,
Register reg2)
Merge register reg2 into register reg1. |
(package private) static void |
DefUse.printDefs(Register reg)
Print all the instructions that def a register. |
(package private) static void |
DefUse.printUses(Register reg)
Print all the instructions that usea register. |
private static boolean |
DefUse.seenInDifferentBlock(Register reg,
int bbNum)
Have we seen this register in a different basic block? |
static Enumeration<RegisterOperand> |
DefUse.uses(Register reg)
Enumerate all operands that use a given register. |
| Method parameters in org.jikesrvm.compilers.opt with type arguments of type Register | |
|---|---|
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 | |
|---|---|
LocalCSE.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 | |
|---|---|
private Register[] |
GenerationContext.addressLocals
|
private Register[] |
GenerationContext.doubleLocals
|
private Register[] |
GenerationContext.floatLocals
|
private Register[] |
GenerationContext.intLocals
|
private Register[] |
GenerationContext.longLocals
|
(package 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 | |
|---|---|
private HashMap<Register,RegisterOperand> |
GenerationContext._ncGuards
|
| Methods in org.jikesrvm.compilers.opt.bc2ir that return Register | |
|---|---|
private Register[] |
GenerationContext.getPool(TypeReference type)
|
Register |
GenerationContext.localReg(int i,
TypeReference type)
Return the Register used to for local i of TypeReference type |
| Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type Register | |
|---|---|
int |
GenerationContext.getLocalNumberFor(Register reg,
TypeReference type)
Get the local number for a given register |
(package private) RegisterOperand |
GenerationContext.makeNullCheckGuard(Register ref)
Make 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 | |
|---|---|
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. |
| Uses of Register in org.jikesrvm.compilers.opt.escape |
|---|
| Fields in org.jikesrvm.compilers.opt.escape declared as Register | |
|---|---|
private Register |
ShortArrayReplacer.reg
the register holding the array reference |
private Register |
ObjectReplacer.reg
the register holding the object reference |
private Register |
UnsyncReplacer.reg
The register to replace |
| Fields in org.jikesrvm.compilers.opt.escape with type parameters of type Register | |
|---|---|
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 | |
|---|---|
private static SimpleEscape.AnalysisResult |
SimpleEscape.checkAllAppearances(Register reg,
IR ir)
Check all appearances of a register, to see if any object pointed to by this register may 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)
Returns true iff ANY object pointed to by symbolic register r
MUST be method local |
(package private) boolean |
FI_EscapeSummary.isThreadLocal(Register r)
Returns true iff ANY object pointed to by symbolic register r
MUST be thread local |
(package private) void |
FI_EscapeSummary.setMethodLocal(Register r,
boolean b)
Record the fact that ALL object pointed to by symbolic register r MUST (or may) escape this method |
(package private) void |
FI_EscapeSummary.setThreadLocal(Register r,
boolean b)
record the fact that ALL object pointed to by symbolic register r MUST (or may) escape this thread |
private static boolean |
EscapeTransformations.synchronizesOn(IR ir,
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 | |
|---|---|
private static boolean |
SimpleEscape.checkEscapesMethod(RegisterOperand use,
IR ir,
Set<Register> visited)
Check 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)
Check 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 | |
|---|---|
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 | |
|---|---|
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 | |
|---|---|
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. |
| Methods in org.jikesrvm.compilers.opt.ir that return Register | |
|---|---|
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()
Return the first symbolic register in this pool. |
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)
|
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 | |
|---|---|
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateAll()
Enumerate all the physical registers in this set. |
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateGPRs()
Enumerate all the GPRs in this set. |
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateNonvolatileFPRs()
Enumerate all the nonvolatile FPRs in this set. |
Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateNonvolatileFPRsBackwards()
Enumerate all the nonvolatile FPRs in this set, backwards. |
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateNonvolatileGPRs()
Enumerate all the nonvolatile GPRs in this set. |
Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateNonvolatileGPRsBackwards()
Enumerate all the nonvolatile GPRs in this set, backwards |
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateVolatileFPRs()
Enumerate all the volatile FPRs in this set. |
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateVolatileGPRs()
Enumerate all the volatile GPRs in this set. |
abstract Enumeration<Register> |
GenericPhysicalRegisterSet.enumerateVolatiles()
Enumerate all the volatile physical registers |
| Methods in org.jikesrvm.compilers.opt.ir with parameters of type Register | |
|---|---|
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)
Does instruction s define register r? |
static RegisterOperand |
IRTools.F(Register reg)
Create a float register operand for a given register. |
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. |
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)
Remove register from register pool. |
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)
Does instruction s use register r? |
| Constructors in org.jikesrvm.compilers.opt.ir with parameters of type Register | |
|---|---|
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 | |
|---|---|
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 | |
|---|---|
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)
Return the (zero-based indexed) nth FPR that may hold a parameter. |
Register |
PhysicalRegisterSet.getGPR(int n)
|
Register |
PhysicalRegisterSet.getGPR(RegisterConstants.GPR n)
|
Register |
PhysicalRegisterSet.getGPRParam(int n)
Return the (zero-based indexed) nth GPR that may hold a parameter. |
Register |
PhysicalRegisterSet.getOF()
|
Register |
PhysicalRegisterSet.getPF()
|
private static Register |
PhysicalDefUse.PDUEnumeration.getReg(int m,
PhysicalRegisterSet phys)
|
Register |
PhysicalRegisterSet.getReturnFPR()
|
Register |
PhysicalRegisterSet.getReturnGPR(int n)
Return the (zero-based indexed) nth GPR that may hold a return value. |
Register |
PhysicalRegisterSet.getSecondReturnGPR()
|
Register |
PhysicalRegisterSet.getSF()
|
Register |
PhysicalRegisterSet.getST0()
|
Register |
PhysicalRegisterSet.getST1()
|
Register |
PhysicalRegisterSet.getTR()
|
Register |
PhysicalRegisterSet.getZF()
|
Register |
PhysicalDefUse.PDUEnumeration.nextElement()
|
Register |
PhysicalRegisterSet.PhysicalRegisterEnumeration.nextElement()
|
Register |
PhysicalRegisterSet.RangeEnumeration.nextElement()
|
| Methods in org.jikesrvm.compilers.opt.ir.ia32 that return types with arguments of type Register | |
|---|---|
Enumeration<Register> |
PhysicalRegisterSet.enumerateAll()
|
Enumeration<Register> |
PhysicalRegisterSet.enumerateFPRs()
Enumerate all the FPRs in this set. |
Enumeration<Register> |
PhysicalRegisterSet.enumerateGPRs()
|
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)
Enumerate the nonvolatile physical registers of a given class, backwards |
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.ia32 with parameters of type Register | |
|---|---|
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)
Is a particular register subject to allocation? |
boolean |
MachineSpecificIRIA.mutateFMOVs(LiveIntervalElement live,
Register register,
int dfnbegin,
int dfnend)
Mutate FMOVs that end live ranges |
| Constructors in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type Register | |
|---|---|
PhysicalRegisterSet.PhysicalRegisterEnumeration(Register[] r)
|
|
| Uses of Register in org.jikesrvm.compilers.opt.ir.operand |
|---|
| Fields in org.jikesrvm.compilers.opt.ir.operand declared as Register | |
|---|---|
Register |
RegisterOperand.register
Register object that this operand uses. |
| Methods in org.jikesrvm.compilers.opt.ir.operand that return Register | |
|---|---|
Register |
RegisterOperand.getRegister()
|
| Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type Register | |
|---|---|
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)
Modify the register |
| Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type Register | |
|---|---|
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.lir2mir.ia32 |
|---|
| Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 that return Register | |
|---|---|
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 | |
|---|---|
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 | |
|---|---|
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 | |
|---|---|
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)
Return the set of registers that are live across a basic block, and who are live before the basic block entry. |
(package private) HashSet<Register> |
LiveAnalysis.getLiveRegistersOnExit(BasicBlock bb)
Return the set of registers that are live across a basic block, and who are live after the basic block exit. |
| Methods in org.jikesrvm.compilers.opt.liveness with parameters of type Register | |
|---|---|
private void |
LiveAnalysis.addToRegisterMap(Register r,
LiveIntervalElement i)
Add the live interval element i to the map for register r. |
boolean |
LiveSet.contains(Register item)
Determines if the item passed is in the current set |
private static 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. |
static 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)
Return an iterator over all the live interval elements for a given register. |
void |
LiveAnalysis.merge(Register r1,
Register r2)
Update the data structures to reflect that all live intervals for r2 are now intervals for r1. |
private void |
LiveAnalysis.removeFromRegisterMap(Register r,
LiveIntervalElement i)
Remove the live interval element i from the map for register r. |
static 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 | |
|---|---|
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 | |
|---|---|
private RegisterConstants.GPR |
AssemblerBase.getGPMachineRegister(Register reg)
Return the machine-level register number corresponding to a given integer Register. |
private RegisterConstants.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 | |
|---|---|
Register |
GenericStackManager.ScratchRegister.currentContents
The current contents of scratch |
(package private) Register |
CoalesceGraph.Node.r
|
private Register |
LinearScan.CompoundInterval.reg
The register this compound interval represents |
private Register |
LiveIntervalElement.register
register that this live interval is for |
Register |
GenericStackManager.ScratchRegister.scratch
The physical register used as scratch. |
(package private) Register |
ScratchMap.Interval.scratch
The physical scratch register or register evicted. |
(package private) Register |
ScratchMap.SymbolicInterval.symbolic
The symbolic register |
| Fields in org.jikesrvm.compilers.opt.regalloc with type parameters of type Register | |
|---|---|
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 | |
|---|---|
Register |
GenericStackManager.allocateNonVolatileRegister(Register symbReg)
Find a nonvolatile register to allocate starting at the reg corresponding to the symbolic register passed TODO: Clean up this interface. |
Register |
GenericStackManager.allocateVolatileRegister(Register symbReg)
Find an volatile register to allocate starting at the reg corresponding to the symbolic register passed |
(package private) Register |
LinearScan.ActiveSet.findAvailableRegister(LinearScan.CompoundInterval ci)
try to find a free physical register to allocate to the compound interval. |
(package private) Register |
LinearScan.ActiveSet.findAvailableRegister(Register symb)
Try to find a free physical register to allocate to a symbolic register. |
(package private) Register |
LinearScan.CompoundInterval.getAssignment()
Get the physical register this interval is assigned to. null if none assigned. |
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)
Return 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) static Register |
RegisterAllocatorState.getMapping(Register r)
|
private Register |
LinearScan.ActiveSet.getPhysicalPreference(LinearScan.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 |
LinearScan.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 |
LinearScan.CompoundInterval.getRegister()
Return the register this interval represents |
(package private) Register |
CoalesceGraph.Node.getRegister()
|
Register |
LiveIntervalElement.getRegister()
|
(package private) Register |
ScratchMap.getScratch(Register r,
int n)
If a symbolic register resides in a scratch register at an instruction numbered n, then return the scratch register. |
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)
Assuming instruction s uses the spill location for a given register, return the symbolic register that embodies that use. |
| Methods in org.jikesrvm.compilers.opt.regalloc that return types with arguments of type Register | |
|---|---|
private ArrayList<Register> |
GenericStackManager.getReservedScratchRegisters(Instruction s)
Return the set of scratch registers which are currently reserved for use in instruction s. |
| Methods in org.jikesrvm.compilers.opt.regalloc with parameters of type Register | |
|---|---|
(package private) void |
GenericRegisterRestrictions.RestrictedRegisterSet.add(Register r)
Add a particular physical register to the set. |
protected void |
GenericRegisterPreferences.addAffinity(int w,
Register r1,
Register r2)
Add a affinity of weight w between two registers. |
(package private) void |
CoalesceGraph.addAffinity(int w,
Register r1,
Register r2)
Add an affinity of weight w between registers r1 and r2 |
protected void |
GenericRegisterRestrictions.addRestriction(Register symb,
Register p)
Record that it is illegal to assign a symbolic register symb to a physical register p |
protected void |
GenericRegisterRestrictions.addRestrictions(Register symb,
BitSet set)
Record that it is illegal to assign a symbolic register symb to any of a set of physical registers |
private boolean |
LinearScan.ActiveSet.allocateNewSymbolicToPhysical(Register symb,
Register p)
Check whether it's ok to allocate symbolic register to a physical register p. |
Register |
GenericStackManager.allocateNonVolatileRegister(Register symbReg)
Find a nonvolatile register to allocate starting at the reg corresponding to the symbolic register passed TODO: Clean up this interface. |
private boolean |
LinearScan.ActiveSet.allocateToPhysical(LinearScan.CompoundInterval i,
Register p)
Check whether it's ok to allocate an interval i to physical register p. |
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)
Does register r appear in instruction s? |
(package private) void |
LinearScan.CompoundInterval.assign(Register r)
Assign this compound interval to a physical register. |
static boolean |
Coalesce.attempt(IR ir,
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) static void |
RegisterAllocatorState.clearOneToOne(Register r)
Clear any 1-to-1 mapping for register R. |
(package private) boolean |
GenericRegisterRestrictions.RestrictedRegisterSet.contains(Register r)
Does this set contain a particular register? |
(package private) LinearScan.CompoundInterval |
LinearScan.CompoundInterval.copy(Register r)
Copy the ranges into a new interval associated with a register r. |
(package private) LinearScan.CompoundInterval |
LinearScan.CompoundInterval.copy(Register r,
LinearScan.BasicInterval stop)
Copy the ranges into a new interval associated with a register r. |
private GenericStackManager.ScratchRegister |
GenericStackManager.createScratchBefore(Instruction s,
Register r,
Register symb)
Make physical register r available to be used as a scratch register before instruction s. |
(package private) boolean |
LinearScan.ActiveSet.currentlyActive(Register r)
Is a particular physical register currently allocated to an interval in the active set? |
private boolean |
GenericStackManager.definesSpillLocation(Register r,
Instruction s)
Does instruction s define the spill location for a given register? |
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 |
LinearScan.ActiveSet.findAvailableRegister(Register symb)
Try to find a free physical register to allocate to a symbolic register. |
(package private) CoalesceGraph.Node |
CoalesceGraph.findNode(Register r)
Find the node corresponding to a regsiter. |
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)
find or create a node in the graph corresponding to a register. |
(package private) void |
GenericRegisterRestrictions.forbidAllVolatiles(Register symb)
Record that it is illegal to assign a symbolic register symb to any volatile physical registers |
(package private) LinearScan.BasicInterval |
LinearScan.ActiveSet.getBasicInterval(Register r,
Instruction s)
Find the basic interval for register r containing instruction s. |
(package private) double |
SpillCostEstimator.getCost(Register r)
Return a number that represents an estimate of the relative cost of spilling register r. |
(package private) LinearScan.CompoundInterval |
LinearScan.ActiveSet.getCurrentInterval(Register r)
Given that a physical register r is currently allocated to an interval in the active set, return the interval. |
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)
Find 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)
Return 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) static LinearScan.CompoundInterval |
LinearScan.getInterval(Register reg)
Returns the interval associated with the passed register. |
(package private) static Register |
RegisterAllocatorState.getMapping(Register r)
|
private Register |
LinearScan.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)
If register r is currently in use as a scratch register, then return that scratch register. |
(package private) GenericRegisterRestrictions.RestrictedRegisterSet |
GenericRegisterRestrictions.getRestrictions(Register symb)
Return the set of restricted physical register for a given symbolic register. |
(package private) Register |
ScratchMap.getScratch(Register r,
int n)
If a symbolic register resides in a scratch register at an instruction numbered n, then return the scratch register. |
private GenericStackManager.ScratchRegister |
GenericStackManager.getScratchRegister(Register symb,
Instruction s,
boolean beCheap)
Get a scratch register to hold symbolic register symb in instruction s. |
private GenericStackManager.ScratchRegister |
GenericStackManager.getScratchRegisterUsingIntervals(Register r,
Instruction s)
Find a register which can serve as a scratch register for symbolic register r in instruction s. |
static 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)
Insert 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)
Is a particular register dead immediately before 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)
Is it legal to assign symbolic register symb to scratch register phys in instruction s? |
private static 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) static void |
RegisterAllocatorState.mapOneToOne(Register A,
Register B)
Record that register A and register B are associated with each other in a bijection. |
void |
ScratchMap.markDirty(Instruction s,
Register symb)
Note that at GC point s, the real value of register symb is cached in a dirty scratch register. |
private GenericStackManager.ScratchRegister |
GenericStackManager.moveToScratchBefore(Instruction s,
Register symb,
boolean beCheap)
Assign symbolic register symb to a physical register, and insert code before instruction s to load the register from the appropriate stack location. |
boolean |
GenericRegisterRestrictions.mustNotSpill(Register r)
Is spilling a register forbidden? |
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)
Record that the register allocator must not spill a symbolic register. |
private void |
GenericStackManager.replaceRegisterWithScratch(Instruction s,
Register r1,
Register r2)
Replace all occurrences of register r1 in an instruction with register r2. |
(package private) static void |
LinearScan.setInterval(Register reg,
LinearScan.CompoundInterval interval)
Associates the passed live interval with the passed register, using the scratchObject field of Register. |
(package private) void |
LinearScan.UpdateOSRMaps.setRealPosition(IR ir,
LocalRegPair tuple,
Register sym_reg)
|
void |
LiveIntervalElement.setRegister(Register r)
|
(package private) static void |
RegisterAllocatorState.setSpill(Register reg,
int spill)
Special use of scratchObject field as "resurrect lists" for real registers TODO: use another field for safety; scratchObject is also used by clan LinearScanLiveAnalysis |
private Register |
GenericStackManager.spillLocationUse(Register r,
Instruction s)
Assuming instruction s uses the spill location for a given register, return the symbolic register that embodies that use. |
private static 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)
Update the cost for a particular register. |
private void |
LinearScan.ActiveSet.updatePhysicalInterval(Register p,
LinearScan.BasicInterval i)
Update the interval representing the allocations of a physical register p to include a new interval i |
private void |
LinearScan.ActiveSet.updatePhysicalInterval(Register p,
LinearScan.CompoundInterval c,
LinearScan.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)
Does instruction s use the spill location for a given register? |
| Method parameters in org.jikesrvm.compilers.opt.regalloc with type arguments of type Register | |
|---|---|
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)
Return 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 | |
|---|---|
CoalesceGraph.Node(Register r)
|
|
GenericStackManager.ScratchRegister(Register scratch,
Register currentContents)
|
|
LinearScan.CompoundInterval(int dfnBegin,
int dfnEnd,
Register register)
Create a new compound interval of a single Basic interval |
|
LinearScan.CompoundInterval(LinearScan.BasicInterval i,
Register register)
Create a new compound interval of a single Basic interval |
|
LinearScan.CompoundInterval(Register r)
Dangerous constructor: use with care. |
|
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 |
|
ScratchMap.Interval(Register scratch)
Initialize scratch register |
|
ScratchMap.PhysicalInterval(Register scratch)
|
|
ScratchMap.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 | |
|---|---|
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)
Can physical register r hold an 8-bit value? |
(package private) void |
RegisterRestrictions.restrictTo8Bits(Register r)
Ensure 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 | |
|---|---|
private static RegisterOperand |
MIRSplitRanges.findOrCreateTemp(RegisterOperand rOp,
HashMap<Register,Register> map,
IR ir)
Find or create a temporary register to cache a symbolic register. |
private static RegisterOperand |
MIRSplitRanges.findOrCreateTemp(RegisterOperand rOp,
HashMap<Register,Register> map,
IR ir)
Find or create 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 | |
|---|---|
private HashSet<Register> |
LeaveSSA.globalRenamePhis
|
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 | |
|---|---|
(package private) static Register |
LoadElimination.findOrCreateRegister(Object heapType,
int valueNumber,
HashMap<LoadElimination.UseRecord,Register> registers,
ArchitectureSpecificOpt.RegisterPool 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,
ArchitectureSpecificOpt.RegisterPool 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)
find step of union/find for guard registers during unSSA |
private Register |
LeaveSSA.guardUnion(Register from,
Register to)
union step of union/find for guard registers during unSSA |
| Methods in org.jikesrvm.compilers.opt.ssa that return types with arguments of type Register | |
|---|---|
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 | |
|---|---|
(package private) static void |
LoadElimination.appendMove(Register r,
Operand src,
Instruction store)
Append an 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)
Find a parameter type. |
private Register |
LeaveSSA.guardFind(Register r)
find step of union/find for guard registers during unSSA |
private Register |
LeaveSSA.guardUnion(Register from,
Register to)
union step of union/find for guard registers during unSSA |
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 | |
|---|---|
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)
Create the block containing explict branches to either the optimized or unoptimized loops |
private boolean |
LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop,
BasicBlock block,
ArrayList<Instruction> checksToEliminate,
BasicBlock unoptimizedLoopEntry,
BasicBlock optimizedLoopEntry,
HashMap<Register,Register> optimalRegMap)
Create the block containing explict branches to either the optimized or unoptimized loops |
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,
ArchitectureSpecificOpt.RegisterPool 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,
ArchitectureSpecificOpt.RegisterPool 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)
Remove loop and replace register definitions in the original loop with phi instructions |
private void |
LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop,
ArrayList<Instruction> phiInstructions,
ArrayList<Instruction> definingInstrInOriginalLoop,
HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Remove loop and replace register definitions in the original loop with phi instructions |
private void |
LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop,
ArrayList<Instruction> phiInstructions,
ArrayList<Instruction> definingInstrInOriginalLoop,
HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Remove loop and replace register definitions in the original loop with phi instructions |
private void |
LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop,
ArrayList<Instruction> phiInstructions,
ArrayList<Instruction> definingInstrInOriginalLoop,
HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Remove loop and replace register definitions in the original loop with phi instructions |
private void |
LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Rename the iterators for optimized loops so we can tell they are still optimized |
private void |
LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Rename the iterators for optimized loops so we can tell they are still optimized |
private void |
LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Rename the iterators for optimized loops so we can tell they are still optimized |
private void |
LoopVersioning.renameOptimizedLoops(HashMap<Register,Register> subOptimalRegMap,
HashMap<Register,Register> optimalRegMap)
Rename the iterators for optimized loops so we can tell they are still optimized |
(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 |
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||