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.next()`
`RegisterOperand`	`DefUse.RegOpListWalker.nextElement()`

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`	`BC2IR.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`	`BC2IR.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

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`	`MIR_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`	`TrapIf.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`	`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`	`ZeroCheck.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`	`Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult 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`	`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`	`Binary.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`	`Call.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`	`ALoad.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`	`NewArray.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`	`TypeCheck.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`	`MIR_Lea.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`	`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`	`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`	`Prepare.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`	`New.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`	`MIR_Call.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`	`ResultCarrier.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`	`MIR_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`	`TrapIf.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`	`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`	`ZeroCheck.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`	`Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_LowTableSwitch.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static RegisterOperand`	`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`	`Binary.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`	`Call.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`	`ALoad.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`	`NewArray.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`	`TypeCheck.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`	`MIR_Lea.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`	`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`	`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`	`Prepare.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`	`New.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`	`MIR_Call.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`	`ResultCarrier.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.
`RegisterOperand`	`RegisterOperandEnumeration.next()` Same as nextElement but avoid the need to downcast from Object

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`	`Move.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Move instruction format.
`static Instruction`	`NullCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref)` Create an instruction of the NullCheck instruction format.
`static Instruction`	`Unary.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Unary instruction format.
`static Instruction`	`ZeroCheck.create(Operator o, RegisterOperand GuardResult, Operand Value)` Create an instruction of the ZeroCheck 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`	`Binary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Create an instruction of the Binary instruction format.
`static Instruction`	`GuardedUnary.create(Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Create an instruction of the GuardedUnary 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`	`ALoad.create(Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the ALoad 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`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Prepare 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`	`BoundsCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Create an instruction of the BoundsCheck 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`	`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`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Create an instruction of the InstanceOf 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, 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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`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, 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`	`MIR_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`	`TrapIf.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`	`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`	`ZeroCheck.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`	`Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult 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`	`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`	`Binary.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`	`Call.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`	`ALoad.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`	`NewArray.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`	`TypeCheck.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`	`MIR_Lea.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`	`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`	`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`	`Prepare.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedBinary.`

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

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