Uses of Class org.jikesrvm.compilers.opt.ir.operand.RegisterOperand (Jikes RVM API)

Overview

Package

Class

Use

Tree

Serialized

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
org.jikesrvm.compilers.opt.ir.operand.RegisterOperand

Packages that use RegisterOperand
org.jikesrvm.adaptive.measurements.instrumentation
org.jikesrvm.adaptive.recompilation.instrumentation
org.jikesrvm.compilers.opt
org.jikesrvm.compilers.opt.bc2ir
org.jikesrvm.compilers.opt.controlflow
org.jikesrvm.compilers.opt.depgraph
org.jikesrvm.compilers.opt.escape
org.jikesrvm.compilers.opt.hir2lir
org.jikesrvm.compilers.opt.ir
org.jikesrvm.compilers.opt.ir.ia32
org.jikesrvm.compilers.opt.ir.operand
org.jikesrvm.compilers.opt.lir2mir
org.jikesrvm.compilers.opt.lir2mir.ia32
org.jikesrvm.compilers.opt.liveness
org.jikesrvm.compilers.opt.regalloc
org.jikesrvm.compilers.opt.regalloc.ia32
org.jikesrvm.compilers.opt.ssa

Uses of RegisterOperand in org.jikesrvm.adaptive.measurements.instrumentation

Methods in org.jikesrvm.adaptive.measurements.instrumentation that return RegisterOperand
`(package private) static RegisterOperand`	`CounterArrayManager.InsertALoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, int offset)` Insert array load off before s in the instruction stream.

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

Fields in org.jikesrvm.adaptive.recompilation.instrumentation declared as RegisterOperand
`private RegisterOperand`	`InstrumentationSamplingFramework.cbsReg` Temporary variables

Methods in org.jikesrvm.adaptive.recompilation.instrumentation that return RegisterOperand
`private static RegisterOperand`	`InstrumentationSamplingFramework.getOrCreateDupReg(RegisterOperand ro, IR ir)` The given register a) does not span multiple basic block, and b) is used in a basic block that is being duplicated.

Methods in org.jikesrvm.adaptive.recompilation.instrumentation with parameters of type RegisterOperand
`private static RegisterOperand`	`InstrumentationSamplingFramework.getOrCreateDupReg(RegisterOperand ro, IR ir)` The given register a) does not span multiple basic block, and b) is used in a basic block that is being duplicated.

Uses of RegisterOperand in org.jikesrvm.compilers.opt

Fields in org.jikesrvm.compilers.opt declared as RegisterOperand
`private RegisterOperand`	`DefUse.RegOpListWalker.current`

Methods in org.jikesrvm.compilers.opt that return RegisterOperand
`private static RegisterOperand`	`ExpressionFolding.getDefFromCandidate(Instruction s, boolean first)` Get the register that's defined by the candidate instruction
`private static RegisterOperand`	`ExpressionFolding.getUseFromCandidate(Instruction s)` Get the register that's used by the candidate instruction
`RegisterOperand`	`DefUse.RegOpListWalker.nextElement()`

Methods in org.jikesrvm.compilers.opt that return types with arguments of type RegisterOperand
`static Enumeration<RegisterOperand>`	`DefUse.defs(Register reg)` Enumerate all operands that def a given register.
`static Enumeration<RegisterOperand>`	`DefUse.uses(Register reg)` Enumerate all operands that use a given register.

Methods in org.jikesrvm.compilers.opt with parameters of type RegisterOperand
`private void`	`LocalCSE.AvExCache.eliminate(RegisterOperand op)` Eliminate all AE tuples that contain a given operand
`private static Operator`	`LocalCSE.getMoveOp(RegisterOperand r)`
`static void`	`DefUse.recordDef(RegisterOperand regOp)` Record a def of a register
`static void`	`DefUse.recordDefUse(RegisterOperand regOp)` Record a def/use of a register TODO: For now we just pretend this is a use!!!!
`static void`	`DefUse.recordUse(RegisterOperand regOp)` Record a use of a register
`static void`	`DefUse.removeDef(RegisterOperand regOp)` Record that a def of a register no longer applies
`static void`	`DefUse.removeUse(RegisterOperand regOp)` Record that a use of a register no longer applies
`static void`	`DefUse.transferUse(RegisterOperand origRegOp, RegisterOperand newRegOp)` This code changes the use in `origRegOp` to use the use in `newRegOp`.

Constructors in org.jikesrvm.compilers.opt with parameters of type RegisterOperand
`DefUse.RegOpListWalker(RegisterOperand start)`

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

Fields in org.jikesrvm.compilers.opt.bc2ir declared as RegisterOperand
`(package private) RegisterOperand`	`HandlerBlockLE.exceptionObject` The RegisterOperand that code should use to access the caught exception object

Fields in org.jikesrvm.compilers.opt.bc2ir with type parameters of type RegisterOperand
`private HashMap<Register,RegisterOperand>`	`GenerationContext._ncGuards`

Methods in org.jikesrvm.compilers.opt.bc2ir that return RegisterOperand
`(package private) RegisterOperand`	`GenerationContext.makeLocal(int i, RegisterOperand props)` Make a register operand that refers to the given local variable number, and inherits its properties (type, flags) from props
`RegisterOperand`	`GenerationContext.makeLocal(int i, TypeReference type)` Make a register operand that refers to the given local variable number and has the given type.
`(package private) RegisterOperand`	`GenerationContext.makeNullCheckGuard(Register ref)` Make a register operand to use as a null check guard for the given register.

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type RegisterOperand
`static boolean`	`BC2IR.hasGuard(RegisterOperand rop)`
`static boolean`	`BC2IR.hasLessConservativeGuard(RegisterOperand rop1, RegisterOperand rop2)`
`private void`	`BBSet.injectMove(BasicBlock block, RegisterOperand res, Operand val)`
`(package private) RegisterOperand`	`GenerationContext.makeLocal(int i, RegisterOperand props)` Make a register operand that refers to the given local variable number, and inherits its properties (type, flags) from props
`void`	`BC2IR.markGuardlessNonNull(RegisterOperand rop)`
`static void`	`BC2IR.setGuard(RegisterOperand rop, Operand guard)`

Uses of RegisterOperand in org.jikesrvm.compilers.opt.controlflow

Fields in org.jikesrvm.compilers.opt.controlflow with type parameters of type RegisterOperand
`private Enumeration<RegisterOperand>`	`LoopUnrolling.RealDefs.defs`

Methods in org.jikesrvm.compilers.opt.controlflow with parameters of type RegisterOperand
`private void`	`BranchOptimizations.booleanCompareHelper(Instruction cb, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Generate a boolean operation opcode 1) IF br !
`private static void`	`BranchSimplifier.insertTrueGuard(Instruction inst, RegisterOperand guard)`

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

Fields in org.jikesrvm.compilers.opt.depgraph declared as RegisterOperand
`private RegisterOperand`	`DepGraphEdge._destOperand` The destination operand (of a REG_TRUE dependence)

Methods in org.jikesrvm.compilers.opt.depgraph that return RegisterOperand
`(package private) RegisterOperand`	`DepGraphEdge.destOperand()` Get the destination operand.

Methods in org.jikesrvm.compilers.opt.depgraph with parameters of type RegisterOperand
`void`	`DepGraphNode.insertRegTrueOutEdge(DepGraphNode node, RegisterOperand op)` Add an out edge this node to the given node because of a register true dependence of a given operand.

Constructors in org.jikesrvm.compilers.opt.depgraph with parameters of type RegisterOperand
`DepGraphEdge(RegisterOperand destOp, DepGraphNode sourceNode, DepGraphNode destNode, int depKind)` Constructor for dependence graph edge of a REG_TRUE dependence from sourceNode to destNode due to destOp

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

Methods in org.jikesrvm.compilers.opt.escape with parameters of type RegisterOperand
`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 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`	`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`	`ShortArrayReplacer.scalarReplace(RegisterOperand use, RegisterOperand[] scalars, Set<Register> visited)` Replace a given use of an array with its scalar equivalent.
`private void`	`UnsyncReplacer.transform(RegisterOperand rop)` Perform the transformation for a given register appearance
`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)`

Uses of RegisterOperand in org.jikesrvm.compilers.opt.hir2lir

Methods in org.jikesrvm.compilers.opt.hir2lir that return RegisterOperand
`static RegisterOperand`	`ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field)` Load an instance field.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field, Operand guard)` Load an instance field.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getInstanceMethod(Instruction s, IR ir, Operand tib, RVMMethod method)` Get an instance method from a TIB
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getSpecialMethod(Instruction s, IR ir, int smid)` support for direct call to specialized method.
`static RegisterOperand`	`ConvertToLowLevelIR.getStatic(Instruction s, IR ir, RVMField field)` Load a static field.
`static RegisterOperand`	`ConvertToLowLevelIR.insertBinary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand o2)` Insert a binary instruction before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertGuardedUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand guard)` Insert a guarded unary instruction before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, LocationOperand loc, Operand guard)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, Operand guard)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Operand offset, LocationOperand loc, Operand guard)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Offset offset)` Insert a load off the JTOC before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Operand offset)` Insert a load off the JTOC before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1)` Insert a unary instruction before s in the instruction stream.

Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type RegisterOperand
`private static BasicBlock`	`ConvertToLowLevelIR._lookupswitchHelper(Instruction switchInstr, RegisterOperand reg, BasicBlock defaultBB, IR ir, BasicBlock curBlock, int low, int high, int min, int max)` Helper function to generate the binary search tree for a lookupswitch bytecode
`private static Instruction`	`DynamicTypeCheckExpansion.convertToBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result)` Generate wrapper around branching type check to get a value producing type check.
`private static Instruction`	`DynamicTypeCheckExpansion.generateBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, BasicBlock trueBlock, BasicBlock falseBlock, RegisterOperand oldGuard, BranchProfileOperand falseProb)` Generate a branching dynamic type check.
`private static Instruction`	`DynamicTypeCheckExpansion.generateValueProducingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result)` Generate a value-producing dynamic type check.
`static RegisterOperand`	`ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field)` Load an instance field.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field, Operand guard)` Load an instance field.

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

Fields in org.jikesrvm.compilers.opt.ir declared as RegisterOperand
`RegisterOperand`	`Register.defList` Used to store register lists.
`RegisterOperand`	`Register.useList` Used to store register lists.

Methods in org.jikesrvm.compilers.opt.ir that return RegisterOperand
`protected RegisterOperand`	`GenericPhysicalRegisterTools.A(int regnum)` Create an address register operand for a given physical GPR.
`static RegisterOperand`	`IRTools.A(Register reg)` Create an integer register operand for a given register.
`static RegisterOperand`	`IRTools.CR(Register reg)` Create a condition register operand for a given register.
`(package private) RegisterOperand`	`GenericPhysicalRegisterTools.D(int regnum)` Create a double register operand for a given physical FPR.
`static RegisterOperand`	`IRTools.D(Register reg)` Create a double register operand for a given register.
`(package private) RegisterOperand`	`GenericPhysicalRegisterTools.F(int regnum)` Create a float register operand for a given physical FPR.
`static RegisterOperand`	`IRTools.F(Register reg)` Create a float register operand for a given register.
`static RegisterOperand`	`MIR_RDTSC.getClearDest1(Instruction i)` Get the operand called Dest1 from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_RDTSC.getClearDest2(Instruction i)` Get the operand called Dest2 from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Prologue.getClearFormal(Instruction i, int k)` Get the k'th operand called Formal from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`IfCmp2.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`BoundsCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardResultCarrier.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_TrapIf.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`NullCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`IfCmp.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`StoreCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`TrapIf.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ZeroCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`LowTableSwitch.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_LowTableSwitch.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_LowTableSwitch.getClearMethodStart(Instruction i)` Get the operand called MethodStart from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange.getClearNewValue(Instruction i)` Get the operand called NewValue from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearNewValueHigh(Instruction i)` Get the operand called NewValueHigh from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearNewValueLow(Instruction i)` Get the operand called NewValueLow from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange.getClearOldValue(Instruction i)` Get the operand called OldValue from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearOldValueHigh(Instruction i)` Get the operand called OldValueHigh from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearOldValueLow(Instruction i)` Get the operand called OldValueLow from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`New.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`CondMove.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Call.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardedBinary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`NewArray.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardedUnary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`TypeCheck.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GetField.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Load.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Binary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Multianewarray.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Attempt.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Lea.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Call.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ALoad.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Unary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Nullary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`BooleanCmp.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`InstanceOf.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Move.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GetStatic.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ResultCarrier.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Prepare.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Call.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_DoubleShift.getClearSource(Instruction i)` Get the operand called Source from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_RDTSC.getDest1(Instruction i)` Get the operand called Dest1 from the argument instruction.
`static RegisterOperand`	`MIR_RDTSC.getDest2(Instruction i)` Get the operand called Dest2 from the argument instruction.
`static RegisterOperand`	`Prologue.getFormal(Instruction i, int k)` Get the k'th operand called Formal from the argument instruction.
`static RegisterOperand`	`IfCmp2.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`BoundsCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`GuardResultCarrier.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_TrapIf.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`NullCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`IfCmp.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`StoreCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`TrapIf.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`ZeroCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`LowTableSwitch.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static RegisterOperand`	`MIR_LowTableSwitch.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static RegisterOperand`	`MIR_LowTableSwitch.getMethodStart(Instruction i)` Get the operand called MethodStart from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange.getNewValue(Instruction i)` Get the operand called NewValue from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getNewValueHigh(Instruction i)` Get the operand called NewValueHigh from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getNewValueLow(Instruction i)` Get the operand called NewValueLow from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange.getOldValue(Instruction i)` Get the operand called OldValue from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getOldValueHigh(Instruction i)` Get the operand called OldValueHigh from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getOldValueLow(Instruction i)` Get the operand called OldValueLow from the argument instruction.
`static RegisterOperand`	`New.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`CondMove.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Call.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GuardedBinary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`NewArray.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GuardedUnary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`TypeCheck.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GetField.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Load.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Binary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Multianewarray.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Attempt.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Lea.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Call.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`ALoad.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Unary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Nullary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`BooleanCmp.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`InstanceOf.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Move.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GetStatic.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`ResultCarrier.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Prepare.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Call.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static RegisterOperand`	`MIR_DoubleShift.getSource(Instruction i)` Get the operand called Source from the argument instruction.
`protected RegisterOperand`	`GenericPhysicalRegisterTools.I(int regnum)` Create an integer register operand for a given physical GPR.
`static RegisterOperand`	`IRTools.I(Register reg)` Create an integer register operand for a given register.
`(package private) RegisterOperand`	`GenericPhysicalRegisterTools.L(int regnum)` Create a long register operand for a given GPR number.
`static RegisterOperand`	`IRTools.L(Register reg)` Create a long register operand for a given register.
`RegisterOperand`	`GenericRegisterPool.makeFPOp()` Get a temporary that represents the FP register
`RegisterOperand`	`AbstractRegisterPool.makeTemp(Operand op)` Make a temporary register operand that can hold the values implied by the passed operand.
`RegisterOperand`	`AbstractRegisterPool.makeTemp(RegisterOperand template)` Make a temporary register operand that is similar to the argument.
`RegisterOperand`	`AbstractRegisterPool.makeTemp(TypeReference type)` Make a temporary register operand to hold values of the specified type (a new register is allocated).
`RegisterOperand`	`AbstractRegisterPool.makeTempAddress()` Make a temporary to hold an address (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempBoolean()` Make a temporary to hold a boolean (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempCondition()` Make a temporary to hold a condition code (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempDouble()` Make a temporary to hold a double (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempFloat()` Make a temporary to hold a float (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempInt()` Make a temporary to hold an int (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempLong()` Make a temporary to hold a long (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempOffset()` Make a temporary to hold an address (allocating a new register).
`RegisterOperand`	`AbstractRegisterPool.makeTempValidation()` Make a temporary to hold a guard (validation) (allocating a new register).
`RegisterOperand`	`GenericRegisterPool.makeTROp()` Get a temporary that represents the PR register
`static RegisterOperand`	`IRTools.moveIntoRegister(ArchitectureSpecificOpt.RegisterPool pool, Instruction s, Operand op)` Generates an instruction to move the given operand into a register, and inserts it before the given instruction.
`static RegisterOperand`	`IRTools.moveIntoRegister(TypeReference type, Operator move_op, ArchitectureSpecificOpt.RegisterPool pool, Instruction s, Operand op)` Generates an instruction to move the given operand into a register, and inserts it before the given instruction.

Methods in org.jikesrvm.compilers.opt.ir with parameters of type RegisterOperand
`static Instruction`	`MIR_DoubleShift.create(Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift)` Create an instruction of the MIR_DoubleShift instruction format.
`static Instruction`	`Nullary.create(Operator o, RegisterOperand Result)` Create an instruction of the Nullary instruction format.
`static Instruction`	`LowTableSwitch.create(Operator o, RegisterOperand Index, int numVarOps)` Create an instruction of the LowTableSwitch instruction format.
`static Instruction`	`MIR_Lea.create(Operator o, RegisterOperand Result, MemoryOperand Value)` Create an instruction of the MIR_Lea instruction format.
`static Instruction`	`MIR_CompareExchange.create(Operator o, RegisterOperand OldValue, MemoryOperand MemAddr, RegisterOperand NewValue)` Create an instruction of the MIR_CompareExchange instruction format.
`static Instruction`	`Unary.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Unary instruction format.
`static Instruction`	`NullCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref)` Create an instruction of the NullCheck instruction format.
`static Instruction`	`ZeroCheck.create(Operator o, RegisterOperand GuardResult, Operand Value)` Create an instruction of the ZeroCheck instruction format.
`static Instruction`	`Move.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Move instruction format.
`static Instruction`	`GetStatic.create(Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Create an instruction of the GetStatic instruction format.
`static Instruction`	`Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Create an instruction of the Call instruction format.
`static Instruction`	`Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Create an instruction of the Call instruction format.
`static Instruction`	`GuardedUnary.create(Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Create an instruction of the GuardedUnary instruction format.
`static Instruction`	`Binary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Create an instruction of the Binary instruction format.
`static Instruction`	`IfCmp.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Create an instruction of the IfCmp instruction format.
`static Instruction`	`IfCmp2.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Create an instruction of the IfCmp2 instruction format.
`static Instruction`	`BooleanCmp.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Create an instruction of the BooleanCmp instruction format.
`static Instruction`	`CondMove.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Create an instruction of the CondMove instruction format.
`static Instruction`	`TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Create an instruction of the TrapIf instruction format.
`static Instruction`	`MIR_TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Create an instruction of the MIR_TrapIf instruction format.
`static Instruction`	`Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Load instruction format.
`static Instruction`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Prepare instruction format.
`static Instruction`	`GetField.create(Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the GetField instruction format.
`static Instruction`	`Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Load instruction format.
`static Instruction`	`ALoad.create(Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the ALoad instruction format.
`static Instruction`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Prepare instruction format.
`static Instruction`	`GuardedBinary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Create an instruction of the GuardedBinary instruction format.
`static Instruction`	`BoundsCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Create an instruction of the BoundsCheck instruction format.
`static Instruction`	`StoreCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Create an instruction of the StoreCheck instruction format.
`static Instruction`	`Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Create an instruction of the Attempt instruction format.
`static Instruction`	`Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Create an instruction of the Attempt instruction format.
`static Instruction`	`TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Create an instruction of the TypeCheck instruction format.
`static Instruction`	`TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Create an instruction of the TypeCheck instruction format.
`static Instruction`	`MIR_RDTSC.create(Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Create an instruction of the MIR_RDTSC instruction format.
`static Instruction`	`MIR_LowTableSwitch.create(Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Create an instruction of the MIR_LowTableSwitch instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_CompareExchange8B.create(Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Create an instruction of the MIR_CompareExchange8B instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Trap.create(Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Create an instruction of the MIR_Trap instruction format.
`static Instruction`	`Trap.create(Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Create an instruction of the Trap instruction format.
`static Instruction`	`New.create(Operator o, RegisterOperand Result, TypeOperand Type)` Create an instruction of the New instruction format.
`static Instruction`	`Multianewarray.create(Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Create an instruction of the Multianewarray instruction format.
`static Instruction`	`NewArray.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Create an instruction of the NewArray instruction format.
`static Instruction`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Create an instruction of the InstanceOf instruction format.
`static Instruction`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Create an instruction of the InstanceOf instruction format.
`static Instruction`	`Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Create an instruction of the Call instruction format with 0 variable arguments.
`static Instruction`	`Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Create an instruction of the Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Create an instruction of the Call instruction format with 1 variable arguments.
`static Instruction`	`Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Create an instruction of the Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Create an instruction of the Call instruction format with 2 variable arguments.
`static Instruction`	`Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Create an instruction of the Call instruction format with 2 variable arguments.
`static Instruction`	`Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Create an instruction of the Call instruction format with 3 variable arguments.
`static Instruction`	`Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Create an instruction of the Call instruction format with 3 variable arguments.
`static Instruction`	`Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Create an instruction of the Call instruction format with 4 variable arguments.
`static Instruction`	`Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Create an instruction of the Call instruction format with 4 variable arguments.
`static Instruction`	`Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Create an instruction of the Call instruction format with 5 variable arguments.
`static Instruction`	`Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Create an instruction of the Call instruction format with 5 variable arguments.
`static Instruction`	`Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Create an instruction of the Call instruction format with 6 variable arguments.
`static Instruction`	`Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Create an instruction of the Call instruction format with 6 variable arguments.
`static Instruction`	`Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Create an instruction of the Call instruction format with 7 variable arguments.
`static Instruction`	`Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Create an instruction of the Call instruction format with 7 variable arguments.
`static Instruction`	`Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Create an instruction of the Call instruction format with 8 variable arguments.
`static Instruction`	`Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Create an instruction of the Call instruction format with 8 variable arguments.
`Register`	`AbstractRegisterPool.getReg(RegisterOperand template)` Get a new register of the same type as the argument RegisterOperand
`RegisterOperand`	`AbstractRegisterPool.makeTemp(RegisterOperand template)` Make a temporary register operand that is similar to the argument.
`static Instruction`	`MIR_DoubleShift.mutate(Instruction i, Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift)` Mutate the argument instruction into an instruction of the MIR_DoubleShift instruction format having the specified operator and operands.
`static Instruction`	`Nullary.mutate(Instruction i, Operator o, RegisterOperand Result)` Mutate the argument instruction into an instruction of the Nullary instruction format having the specified operator and operands.
`static Instruction`	`LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, int numVarOps)` Mutate the argument instruction into an instruction of the LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Lea.mutate(Instruction i, Operator o, RegisterOperand Result, MemoryOperand Value)` Mutate the argument instruction into an instruction of the MIR_Lea instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange.mutate(Instruction i, Operator o, RegisterOperand OldValue, MemoryOperand MemAddr, RegisterOperand NewValue)` Mutate the argument instruction into an instruction of the MIR_CompareExchange instruction format having the specified operator and operands.
`static Instruction`	`Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Unary instruction format having the specified operator and operands.
`static Instruction`	`NullCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref)` Mutate the argument instruction into an instruction of the NullCheck instruction format having the specified operator and operands.
`static Instruction`	`ZeroCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Value)` Mutate the argument instruction into an instruction of the ZeroCheck instruction format having the specified operator and operands.
`static Instruction`	`Move.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Move instruction format having the specified operator and operands.
`static Instruction`	`GetStatic.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the GetStatic instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`GuardedUnary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedUnary instruction format having the specified operator and operands.
`static Instruction`	`Binary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the Binary instruction format having the specified operator and operands.
`static Instruction`	`IfCmp.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the IfCmp instruction format having the specified operator and operands.
`static Instruction`	`IfCmp2.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the IfCmp2 instruction format having the specified operator and operands.
`static Instruction`	`BooleanCmp.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the BooleanCmp instruction format having the specified operator and operands.
`static Instruction`	`CondMove.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Mutate the argument instruction into an instruction of the CondMove instruction format having the specified operator and operands.
`static Instruction`	`TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the TrapIf instruction format having the specified operator and operands.
`static Instruction`	`MIR_TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_TrapIf instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`GetField.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the GetField instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`ALoad.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the ALoad instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`GuardedBinary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedBinary instruction format having the specified operator and operands.
`static Instruction`	`BoundsCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Mutate the argument instruction into an instruction of the BoundsCheck instruction format having the specified operator and operands.
`static Instruction`	`StoreCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the StoreCheck instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`MIR_RDTSC.mutate(Instruction i, Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Mutate the argument instruction into an instruction of the MIR_RDTSC instruction format having the specified operator and operands.
`static Instruction`	`MIR_LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange8B.mutate(Instruction i, Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Mutate the argument instruction into an instruction of the MIR_CompareExchange8B instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
`static Instruction`	`Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the Trap instruction format having the specified operator and operands.
`static Instruction`	`New.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type)` Mutate the argument instruction into an instruction of the New instruction format having the specified operator and operands.
`static Instruction`	`Multianewarray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Mutate the argument instruction into an instruction of the Multianewarray instruction format having the specified operator and operands.
`static Instruction`	`NewArray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Mutate the argument instruction into an instruction of the NewArray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`void`	`AbstractRegisterPool.release(RegisterOperand r)` Release a now unused register.
`static void`	`MIR_RDTSC.setDest1(Instruction i, RegisterOperand Dest1)` Set the operand called Dest1 in the argument instruction to the argument operand.
`static void`	`MIR_RDTSC.setDest2(Instruction i, RegisterOperand Dest2)` Set the operand called Dest2 in the argument instruction to the argument operand.
`static void`	`Prologue.setFormal(Instruction i, int k, RegisterOperand o)` Set the k'th operand called Formal in the argument instruction to the argument operand.
`static void`	`IfCmp2.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`GuardResultCarrier.setGuardResult(Instruction i, RegisterOperand op)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`MIR_Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`NullCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`IfCmp.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`StoreCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`TrapIf.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`ZeroCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`LowTableSwitch.setIndex(Instruction i, RegisterOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setIndex(Instruction i, RegisterOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setMethodStart(Instruction i, RegisterOperand MethodStart)` Set the operand called MethodStart in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange.setNewValue(Instruction i, RegisterOperand NewValue)` Set the operand called NewValue in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setNewValueHigh(Instruction i, RegisterOperand NewValueHigh)` Set the operand called NewValueHigh in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setNewValueLow(Instruction i, RegisterOperand NewValueLow)` Set the operand called NewValueLow in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange.setOldValue(Instruction i, RegisterOperand OldValue)` Set the operand called OldValue in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setOldValueHigh(Instruction i, RegisterOperand OldValueHigh)` Set the operand called OldValueHigh in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setOldValueLow(Instruction i, RegisterOperand OldValueLow)` Set the operand called OldValueLow in the argument instruction to the argument operand.
`static void`	`New.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`CondMove.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Call.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`NewArray.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`TypeCheck.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GetField.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Load.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Binary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Multianewarray.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Attempt.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Lea.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Call.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`ALoad.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Unary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Nullary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`InstanceOf.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Move.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GetStatic.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`ResultCarrier.setResult(Instruction i, RegisterOperand op)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Prepare.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Call.setResult2(Instruction i, RegisterOperand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`MIR_DoubleShift.setSource(Instruction i, RegisterOperand Source)` Set the operand called Source in the argument instruction to the argument operand.

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

Methods in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type RegisterOperand
`static Instruction`	`PhysicalRegisterTools.makeMoveInstruction(RegisterOperand lhs, RegisterOperand rhs)` Create an MIR instruction to move rhs into lhs

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

Fields in org.jikesrvm.compilers.opt.ir.operand declared as RegisterOperand
`RegisterOperand`	`MemoryOperand.base` The base register (may be `null`)
`RegisterOperand`	`MemoryOperand.index` The index register (may be `null`)

Methods in org.jikesrvm.compilers.opt.ir.operand that return RegisterOperand
`RegisterOperand`	`Operand.asRegister()` Cast to an `RegisterOperand`.
`RegisterOperand`	`RegisterOperand.copyD2D()` Returns a copy of this def register operand as a def.
`RegisterOperand`	`RegisterOperand.copyD2U()` Returns a copy of this def register operand as a use.
`RegisterOperand`	`RegisterOperand.copyRO()` Returns a copy of this register operand as a register operand.
`RegisterOperand`	`RegisterOperand.copyU2D()` Returns a copy of this use register operand as a def.
`RegisterOperand`	`RegisterOperand.copyU2U()` Returns a copy of this use register operand as another use reg operand.
`RegisterOperand`	`RegisterOperand.getNext()` Returns the scratch object of the register operand

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type RegisterOperand
`void`	`RegisterOperand.append(RegisterOperand next)` Sets scratch object of the register operand to parameter.
`static MemoryOperand`	`MemoryOperand.B(RegisterOperand base, byte size, LocationOperand loc, Operand guard)`
`static MemoryOperand`	`MemoryOperand.BD(RegisterOperand base, Offset disp, byte size, LocationOperand loc, Operand guard)`
`static MemoryOperand`	`MemoryOperand.BI(RegisterOperand base, RegisterOperand index, byte size, LocationOperand loc, Operand guard)`
`static MemoryOperand`	`MemoryOperand.BID(RegisterOperand base, RegisterOperand index, Offset disp, byte size, LocationOperand loc, Operand guard)`
`static MemoryOperand`	`MemoryOperand.BIS(RegisterOperand base, RegisterOperand index, byte scale, byte size, LocationOperand loc, Operand guard)`
`void`	`RegisterOperand.copyType(RegisterOperand rhs)` Copy type information from the given operand into this one including flag information on whether this is a precise type or not
`boolean`	`RegisterOperand.hasLessConservativeFlags(RegisterOperand other)` Return true if we have any bits set (flag true) that other doesn't.
`static MemoryOperand`	`MemoryOperand.I(RegisterOperand base, byte size, LocationOperand loc, Operand guard)`
`void`	`RegisterOperand.meetInheritableFlags(RegisterOperand other)` Currently all flags are "meetable", so mask flags together
`void`	`RegisterOperand.setInheritableFlags(RegisterOperand src)` Currently all flags are inheritable, so copy all flags from src
`void`	`RegisterOperand.setNext(RegisterOperand Next)` Sets scratch object of the register operand to parameter.

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type RegisterOperand
`MemoryOperand(RegisterOperand base, RegisterOperand index, byte scale, Offset disp, byte size, LocationOperand loc, Operand guard)`

Uses of RegisterOperand in org.jikesrvm.compilers.opt.lir2mir

Fields in org.jikesrvm.compilers.opt.lir2mir declared as RegisterOperand
`(package private) RegisterOperand`	`BURS_MemOp_Helpers.AddrStackElement.base`
`(package private) RegisterOperand`	`BURS_MemOp_Helpers.AddrStackElement.index`

Methods in org.jikesrvm.compilers.opt.lir2mir that return RegisterOperand
`protected static RegisterOperand`	`BURS_Common_Helpers.R(Operand op)`

Methods in org.jikesrvm.compilers.opt.lir2mir with parameters of type RegisterOperand
`protected void`	`BURS_MemOp_Helpers.pushAddress(RegisterOperand base, RegisterOperand index, byte scale, Offset disp)`

Constructors in org.jikesrvm.compilers.opt.lir2mir with parameters of type RegisterOperand
`BURS_MemOp_Helpers.AddrStackElement(RegisterOperand b, RegisterOperand i, byte s, Offset d, BURS_MemOp_Helpers.AddrStackElement n)`

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

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 with parameters of type RegisterOperand
`protected void`	`BURS_Helpers.ATTEMPT_LONG(RegisterOperand result, MemoryOperand mo, Operand oldValue, Operand newValue)` This routine expands an ATTEMPT instruction into an atomic compare exchange.
`protected void`	`BURS_Helpers.ATTEMPT(RegisterOperand result, MemoryOperand mo, Operand oldValue, Operand newValue)` This routine expands an ATTEMPT instruction into an atomic compare exchange.
`protected void`	`BURS_Helpers.BOOLEAN_CMP_DOUBLE(Instruction s, RegisterOperand res, ConditionOperand cond, Operand val1, Operand val2)` Expansion of BOOLEAN_CMP_DOUBLE
`protected void`	`BURS_Helpers.BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, ConditionOperand cond)` Expansion of a special case of BOOLEAN_CMP_INT when the condition registers have already been set by the previous ALU op.
`protected void`	`BURS_Helpers.BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Expansion of BOOLEAN_CMP_INT
`protected void`	`BURS_Helpers.BOOLEAN_CMP_LONG(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Expansion of BOOLEAN_CMP_LONG
`protected void`	`BURS_Helpers.CMOV_FMOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate a floating point move portion of a conditional move.
`protected void`	`BURS_Helpers.CMOV_MOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate an integer move portion of a conditional move.
`protected void`	`BURS_Helpers.EMIT_Lea(Instruction s, RegisterOperand result, MemoryOperand mo)` Create the MIR LEA instruction performing a few simplifications if possible
`protected void`	`BURS_Helpers.FPR_2INT(Instruction s, RegisterOperand result, Operand value)` Expansion of FLOAT_2INT and DOUBLE_2INT, using the FIST instruction.
`protected void`	`BURS_Helpers.GET_TIME_BASE(Instruction s, RegisterOperand result)` Expansion of RDTSC (called GET_TIME_BASE for consistency with PPC)
`protected void`	`BURS_Helpers.IFCMP(Instruction s, RegisterOperand guardResult, Operand val1, Operand val2, ConditionOperand cond)` Generate a compare and branch sequence.
`protected void`	`BURS_Helpers.INT_2LONG(Instruction s, RegisterOperand result, Operand value, boolean signExtend)` Expansion of INT_2LONG
`protected void`	`BURS_Helpers.INT_DIVIDES(Instruction s, RegisterOperand result, Operand val1, Operand val2, boolean isDiv)` Expansion of INT_DIV and INT_REM
`protected void`	`BURS_Helpers.LCMP_CMOV(Instruction s, RegisterOperand result, Operand val1, Operand val2, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate a long compare and cmov
`protected void`	`BURS_Helpers.LONG_ADD(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_ADD
`protected void`	`BURS_Helpers.LONG_AND(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_AND
`protected void`	`BURS_Helpers.LONG_CMP(Instruction s, RegisterOperand res, Operand val1, Operand val2)` Expansion of LONG_CMP: compare to values and set result to -1, 0, 1 for <, =, >, respectively
`protected void`	`BURS_Helpers.LONG_MUL(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_MUL
`protected void`	`BURS_Helpers.LONG_NEG(Instruction s, RegisterOperand result, Operand value)` Expansion of LONG_NEG
`protected void`	`BURS_Helpers.LONG_NOT(Instruction s, RegisterOperand result, Operand value)` Expansion of LONG_NOT
`protected void`	`BURS_Helpers.LONG_OR(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_OR
`protected void`	`BURS_Helpers.LONG_XOR(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_XOR
`protected void`	`BURS_Helpers.SSE2_FCMP_FCMOV(Instruction s, RegisterOperand result, Operand lhsCmp, Operand rhsCmp, ConditionOperand cond, Operand trueValue, Operand falseValue)`

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

Fields in org.jikesrvm.compilers.opt.liveness declared as RegisterOperand
`private RegisterOperand`	`LiveSetElement.regOp` The register operand, i.e., the data

Methods in org.jikesrvm.compilers.opt.liveness that return RegisterOperand
`RegisterOperand`	`LiveSetElement.getRegisterOperand()` Returns the register operand associated with this element
`RegisterOperand`	`LiveSetEnumerator.nextElement()` Returns the next element, if one exists, otherwise throws an exception.

Methods in org.jikesrvm.compilers.opt.liveness with parameters of type RegisterOperand
`void`	`LiveSet.add(RegisterOperand item)` create a new object from the passed parameter and add it to the list
`private LiveSetElement`	`LiveSet.createAndAddToCurrentList(RegisterOperand register, LiveSetElement prevElement)` Copy the newElement into a new object and add it to the list after prevElement.
`private boolean`	`LiveAnalysis.isSkippableReg(RegisterOperand regOp, IR ir)` Should this register be included in the liveness solution?
`(package private) void`	`LiveSet.remove(RegisterOperand item)` Removes the passed register from this set.
`void`	`LiveSetElement.setRegisterOperand(RegisterOperand newRegOp)` Change the register operand.

Constructors in org.jikesrvm.compilers.opt.liveness with parameters of type RegisterOperand
`LiveSetElement(RegisterOperand register)` Construct an `LiveSetElement`.

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

Methods in org.jikesrvm.compilers.opt.regalloc with parameters of type RegisterOperand
`abstract void`	`GenericStackManager.replaceOperandWithSpillLocation(Instruction s, RegisterOperand symb)` In instruction s, replace all appearances of a symbolic register operand with uses of the appropriate spill location, as cached by the register allocator.

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

Methods in org.jikesrvm.compilers.opt.regalloc.ia32 that return RegisterOperand
`private static RegisterOperand`	`MIRSplitRanges.findOrCreateTemp(RegisterOperand rOp, HashMap<Register,Register> map, IR ir)` Find or create a temporary register to cache a symbolic register.

Methods in org.jikesrvm.compilers.opt.regalloc.ia32 with parameters of type RegisterOperand
`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.insertMoveAfter(RegisterOperand r2, RegisterOperand r1, Instruction s)` Insert an instruction to move r1 into r2 after instruction s
`private static void`	`MIRSplitRanges.insertMoveBefore(RegisterOperand r2, RegisterOperand r1, Instruction s)` Insert an instruction to move r1 into r2 before instruction s
`void`	`StackManager.replaceOperandWithSpillLocation(Instruction s, RegisterOperand symb)`

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

Fields in org.jikesrvm.compilers.opt.ssa declared as RegisterOperand
`(package private) RegisterOperand`	`LeaveSSA.Copy.destination` The left-hand side of the copy instruction

Methods in org.jikesrvm.compilers.opt.ssa that return RegisterOperand
`private RegisterOperand`	`GlobalCSE.getResult(Instruction inst)` Get the result operand of the instruction
`private RegisterOperand`	`LoopVersioning.nullCheckPerformedInLoopPredecessors(BasicBlock header, Instruction instr)` Can we eliminate a null check as it has lready been performed?

Overview

Package

Class

Use

Tree

Serialized

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Classorg.jikesrvm.compilers.opt.ir.operand.RegisterOperand

Uses of Class
org.jikesrvm.compilers.opt.ir.operand.RegisterOperand