Uses of Class org.jikesrvm.compilers.opt.ir.operand.Operand (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.Operand

Packages that use Operand
org.jikesrvm.adaptive.measurements.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.ir.operand.ia32
org.jikesrvm.compilers.opt.lir2mir
org.jikesrvm.compilers.opt.lir2mir.ia32
org.jikesrvm.compilers.opt.mir2mc.ia32
org.jikesrvm.compilers.opt.ssa
org.jikesrvm.osr

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

Methods in org.jikesrvm.adaptive.measurements.instrumentation with parameters of type Operand
`(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 Operand in org.jikesrvm.compilers.opt

Fields in org.jikesrvm.compilers.opt declared as Operand
`(package private) Operand[]`	`LocalCSE.AvailableExpression.ops` operands

Methods in org.jikesrvm.compilers.opt that return Operand
`(package private) static Operand`	`Simple.equivalentValforPHI(Instruction phi)` Try to find an operand that is equivalent to the result of a given phi instruction.

Methods in org.jikesrvm.compilers.opt with parameters of type Operand
`private boolean`	`NullCheckCombining.canFold(Instruction s, Operand activeGuard, boolean isStore)`
`private static Address`	`ExpressionFolding.getAddressValue(Operand op)`
`private static Address`	`Simplifier.getAddressValue(Operand op)` Turn the given operand encoding an address constant into an Address
`private static double`	`ExpressionFolding.getDoubleValue(Operand op)`
`private static float`	`ExpressionFolding.getFloatValue(Operand op)`
`private static int`	`ExpressionFolding.getIntValue(Operand op)`
`private static long`	`ExpressionFolding.getLongValue(Operand op)`
`private static Simplifier.DefUseEffect`	`Simplifier.multiplyByConstant(AbstractRegisterPool regpool, Instruction s, Operand op1, Operand op2, OptOptions opts)`

Constructors in org.jikesrvm.compilers.opt with parameters of type Operand
`LocalCSE.AvailableExpression(Instruction i, Operator op, Operand[] ops, LocationOperand loc, Register t)`

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

Subclasses of Operand in org.jikesrvm.compilers.opt.bc2ir
`private static class`	`BC2IR.DummyStackSlot` Dummy stack slot
`class`	`ReturnAddressOperand` ReturnAddress operand.

Fields in org.jikesrvm.compilers.opt.bc2ir declared as Operand
`private Operand[]`	`BC2IR._localState` Current state of local variables.
`(package private) Operand[]`	`GenerationContext.arguments` The parameters which BC2IR should use to seed the local state for the entry basic block.
`private Operand`	`BC2IR.currentGuard`
`(package private) Operand[]`	`BasicBlockLE.localState` State of the local variables at the start of this basic block.
`Operand`	`GenerationContext.result` Used to communicate the meet of the return values back to the caller Mainly useful when BC2IR is doing inlining....allows the caller BC2IR object to exploit knowledge the callee BC2IR object had about the result.
`private Operand[]`	`OperandStack.stack`

Methods in org.jikesrvm.compilers.opt.bc2ir that return Operand
`private Operand`	`BC2IR._loadLocalForOSR(Operand op)` make a temporary register, and create a move instruction
`private Operand`	`BC2IR._prepareDoubleConstant(Operand op)` special process for long/double constants
`private Operand`	`BC2IR._prepareLongConstant(Operand op)` special process for long/double constants
`Operand`	`BC2IR.DummyStackSlot.copy()`
`Operand`	`ReturnAddressOperand.copy()`
`(package private) Operand[]`	`BasicBlockLE.copyLocalState()` Return a shallow copy of my local state.
`Operand`	`BC2IR.getConstantOperand(int index)` Fetch the value of the next operand, a constant, from the bytecode stream.
`Operand`	`BC2IR.getCurrentGuard()`
`(package private) Operand`	`OperandStack.getFromTop(int n)`
`static Operand`	`BC2IR.getGuard(Operand op)`
`private Operand`	`BC2IR.getLocal(int i)` Gets the specified local variable.
`private Operand`	`BC2IR.getLocalDual(int i)` Gets the specified local variable (long, double).
`private Operand`	`GenerationContext.getLockObject()` Get the object for locking for synchronized methods.
`(package private) Operand`	`OperandStack.peek(int depth)`
`(package private) Operand`	`OperandStack.peekAt(int pos)`
`(package private) Operand`	`BC2IR.pop()` Pop an operand from the stack.
`(package private) Operand`	`OperandStack.pop()`
`(package private) Operand`	`BC2IR.pop(TypeReference type)` Pop an operand of the given type from the stack.
`Operand`	`BC2IR.popAddress()` Pop a ref operand from the stack.
`(package private) Operand`	`BC2IR.popDouble()` Pop a double operand from the stack.
`(package private) Operand`	`BC2IR.popFloat()` Pop a float operand from the stack.
`Operand`	`BC2IR.popInt()` Pop an int operand from the stack.
`(package private) Operand`	`BC2IR.popLong()` Pop a long operand from the stack.
`Operand`	`BC2IR.popRef()` Pop a ref operand from the stack.
`private Operand`	`BC2IR.popShiftInt(boolean longShift)` Pop an int from the stack to be used in a shift.

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type Operand
`Instruction`	`BC2IR._aloadHelper(Operator operator, Operand ref, Operand index, TypeReference type)`
`private Instruction`	`BC2IR._binaryDualHelper(Operator operator, Operand op1, Operand op2, TypeReference type)`
`private Instruction`	`BC2IR._binaryHelper(Operator operator, Operand op1, Operand op2, TypeReference type)`
`private BasicBlockLE`	`BBSet._createBBLE(int bcIndex, Operand[] simLocals, BasicBlockLE parent, boolean left)` Allocate a new BBLE at the given bcIndex.
`private Instruction`	`BC2IR._guardedBinaryDualHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)`
`private Instruction`	`BC2IR._guardedBinaryHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)`
`private Operand`	`BC2IR._loadLocalForOSR(Operand op)` make a temporary register, and create a move instruction
`private Instruction`	`BC2IR._moveDualHelper(Operator operator, Operand val, TypeReference type)`
`private Instruction`	`BC2IR._moveHelper(Operator operator, Operand val, TypeReference type)`
`private Operand`	`BC2IR._prepareDoubleConstant(Operand op)` special process for long/double constants
`private Operand`	`BC2IR._prepareLongConstant(Operand op)` special process for long/double constants
`private void`	`BC2IR._returnHelper(Operator operator, Operand val)`
`private Instruction`	`BC2IR._unaryDualHelper(Operator operator, Operand val, TypeReference type)`
`private Instruction`	`BC2IR._unaryHelper(Operator operator, Operand val, TypeReference type)`
`void`	`BC2IR.assertIsType(Operand op, TypeReference type)` Assert that the given operand is of the given type, or of a subclass of the given type.
`private static void`	`GenerateMagic.cmpHelper(BC2IR bc2ir, GenerationContext gc, ConditionOperand cond, Operand given_o2)`
`private BasicBlockLE`	`BBSet.condCreateAndInit(BasicBlockLE x, boolean shouldCreate, int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals, boolean left)` Conditionally create a block at the specified target as a child of x.
`(package private) void`	`BasicBlockLE.copyIntoLocalState(Operand[] _localState)` Save a shallow copy of the given local variable state into this.
`boolean`	`BC2IR.do_BoundsCheck(Operand ref, Operand index)` Generate a boundscheck instruction for the given operand and index.
`private boolean`	`BC2IR.do_CheckStore(Operand ref, Operand elem, TypeReference elemType)` Generate a storecheck for the given array and elem
`private boolean`	`BC2IR.do_IntZeroCheck(Operand div)` Generate a check for 0 for the given operand
`private boolean`	`BC2IR.do_LongZeroCheck(Operand div)` Generate a check for 0 for the given operand
`boolean`	`BC2IR.do_NullCheck(Operand ref)` Generate a null-check instruction for the given operand.
`private Instruction`	`BC2IR.do_store(int index, Operand op1)` Simulate a store into a given local variable of an int/long/double/float Returns generated instruction (or null if no instruction generated.)
`TypeReference`	`BC2IR.getArrayTypeOf(Operand op)` Return the data type of the given operand, assuming that the operand is an array reference.
`static Operand`	`BC2IR.getGuard(Operand op)`
`private BasicBlockLE`	`BBSet.getOrCreateBlock(BasicBlockLE x, boolean shouldCreate, int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals)` Get or create a block at the specified target.
`(package private) BasicBlockLE`	`BBSet.getOrCreateBlock(int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals)` Get or create a block at the specified target.
`private BasicBlockLE`	`BC2IR.getOrCreateBlock(int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals)` Get or create a block at the specified target.
`private TypeReference`	`BC2IR.getRefTypeOf(Operand op)` Return the data type of the given operand, assuming that the operand is a reference.
`private void`	`BBSet.initializeExceptionHandlers(BasicBlockLE bble, Operand[] simLocals)` Initialize bble's handlers array based on startPCs/endPCs.
`private void`	`BBSet.injectMove(BasicBlock block, RegisterOperand res, Operand val)`
`boolean`	`GenerationContext.isLocal(Operand op, int i, TypeReference type)` Is the operand a particular bytecode local?
`static boolean`	`BC2IR.isNonNull(Operand op)`
`private static LocationOperand`	`GenerateMagic.mapToMetadata(Operand metadata)`
`private boolean`	`BBSet.matchingJSRcontext(OperandStack simStack, Operand[] simLocals, BasicBlockLE candBBLE)` We specialize basic blocks with respect to the return addresses they have on their expression stack and/or in their local variables on entry to the block.
`void`	`BC2IR.push(Operand r)` Push a single width operand (int, float, ref, ...) on the simulated stack.
`(package private) void`	`OperandStack.push(Operand val)`
`(package private) void`	`BC2IR.push(Operand r, TypeReference type)` Push an operand of the specified type on the simulated stack.
`private Instruction`	`BC2IR.pushCopy(Operand op1)` Push a copy of the given operand onto simulated stack.
`private Instruction`	`BC2IR.pushCopy(Operand op1, int b1)` Push a copy of the given operand onto simulated stack.
`(package private) void`	`BC2IR.pushDual(Operand r)` Push a double width operand (long, double) on the simulated stack.
`(package private) void`	`BBSet.rectifyLocals(Operand[] localState, BasicBlockLE p)` Rectify the given local variable state with the local variable state stored in the given BBLE.
`(package private) void`	`OperandStack.replaceFromTop(int n, Operand op)`
`private void`	`BC2IR.setCurrentGuard(Operand guard)`
`static void`	`BC2IR.setGuard(RegisterOperand rop, Operand guard)`
`private void`	`BC2IR.setLocal(int i, Operand op)` Set the specified local variable
`private void`	`BC2IR.setLocalDual(int i, Operand op)` Set the specified local variable
`boolean`	`BC2IR.DummyStackSlot.similar(Operand op)`
`boolean`	`ReturnAddressOperand.similar(Operand op)`

Constructors in org.jikesrvm.compilers.opt.bc2ir with parameters of type Operand
`BBSet(GenerationContext gc, BytecodeStream bcodes, Operand[] localState)` Initialize the BBSet to handle basic block generation for the argument generation context and bytecode info.

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

Fields in org.jikesrvm.compilers.opt.controlflow declared as Operand
`private Operand`	`AnnotatedLSTNode.carriedLoopIterator` The iterator that is used to loop within the exit block
`Operand`	`AnnotatedLSTNode.initialIteratorValue` The the initial iterator that comes into the phi node in the header
`private Operand`	`AnnotatedLSTNode.phiLoopIterator` The the phi iterator that gets modified by the stride to produce the carried iterator
`Operand`	`AnnotatedLSTNode.strideValue` The stride operand to the iterator instruction
`Operand`	`AnnotatedLSTNode.terminalIteratorValue` The value that ends the loop
`private Operand`	`LoopUnrolling.RealDefs.use`

Methods in org.jikesrvm.compilers.opt.controlflow that return Operand
`private static Operand`	`LoopUnrolling._follow(Operand use)`
`static Operand`	`AnnotatedLSTNode.follow(Operand use)` Follow the operand's definition filtering out moves This code is taken and modified from an old `LoopUnrolling`
`private static Operand`	`LoopUnrolling.follow(Operand use)`
`Operand`	`AnnotatedLSTNode.generateLoopInvariantOperand(BasicBlock block, Operand op)` Loop invariants may not be accessible before a loop, so generate the instructions so they are
`Operand`	`AnnotatedLSTNode.getCarriedLoopIterator()` Get the carried loop iterator
`Operand`	`LoopUnrolling.RealDefs.nextClear()`
`Operand`	`LoopUnrolling.RealDefs.nextElement()`

Methods in org.jikesrvm.compilers.opt.controlflow with parameters of type Operand
`private static Operand`	`LoopUnrolling._follow(Operand use)`
`private static void`	`LoopUnrolling._printDefs(Operand op)`
`private void`	`BranchOptimizations.booleanCompareHelper(Instruction cb, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Generate a boolean operation opcode 1) IF br !
`static Instruction`	`AnnotatedLSTNode.definingInstruction(Operand op)` Find the instruction that defines an operand.
`private static Instruction`	`LoopUnrolling.definingInstruction(Operand op)`
`static Operand`	`AnnotatedLSTNode.follow(Operand use)` Follow the operand's definition filtering out moves This code is taken and modified from an old `LoopUnrolling`
`private static Operand`	`LoopUnrolling.follow(Operand use)`
`Operand`	`AnnotatedLSTNode.generateLoopInvariantOperand(BasicBlock block, Operand op)` Loop invariants may not be accessible before a loop, so generate the instructions so they are
`int`	`AnnotatedLSTNode.getFixedDistanceFromPhiIterator(Operand op)` Get fixed distance from the phi iterator
`private void`	`LoopUnrolling.RealDefs.init(Operand use)`
`boolean`	`AnnotatedLSTNode.isCarriedLoopIterator(Operand op)` Is this operand related to the carried iterator of this loop?
`(package private) static boolean`	`AnnotatedLSTNode.isConstant(Operand op)` Test whether the operand is constant
`(package private) boolean`	`AnnotatedLSTNode.isFixedDistanceFromPhiIterator(Operand op)` Is this operand a fixed distance from the phi iterator?
`boolean`	`AnnotatedLSTNode.isInvariant(Operand op)` Is this value modified by the loop?
`private static boolean`	`AnnotatedLSTNode.isLoopInvariant(Operand op, BitVector loop, BasicBlock header)` Test whether operand value will be invariant in a loop by tracing back earlier definitions.
`boolean`	`AnnotatedLSTNode.isPhiLoopIterator(Operand op)` Is this operand related to the phi iterator of this loop?
`boolean`	`AnnotatedLSTNode.isRelatedToIterator(Operand op)` Is this operand related to the iterator of this loop?
`private static boolean`	`LoopUnrolling.loopInvariant(Operand op, BitVector nloop, int depth)`
`private static boolean`	`LoopUnrolling.printDefs(Operand op, BitVector nloop, int depth)`

Constructors in org.jikesrvm.compilers.opt.controlflow with parameters of type Operand
`LoopUnrolling.RealDefs(Operand use)`
`LoopUnrolling.RealDefs(Operand use, int visit)`

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

Methods in org.jikesrvm.compilers.opt.depgraph with parameters of type Operand
`private void`	`DepGraph.computeBackwardDependencesDef(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode)` Compute backward dependences from a given def to a given node.
`private void`	`DepGraph.computeBackwardDependencesUse(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode)` Compute backward dependences from a given use to a given node.
`private void`	`DepGraph.computeForwardDependencesDef(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode)` Compute forward dependences from a given def to a given node.
`private void`	`DepGraph.computeForwardDependencesUse(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode)` Compute forward dependences from a given use to a given node.
`static DepGraphEdge`	`DepGraphEdge.findInputEdge(DepGraphNode n, Operand op)` Return the input edge for a given node that corresponds to a given operand.

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

Methods in org.jikesrvm.compilers.opt.escape that return types with arguments of type Operand
`private static Iterator<Operand>`	`SimpleEscape.iterateReturnValues(IR ir)` Return an iterator over the operands that serve as return values in an IR TODO: Move this utility elsewhere

Methods in org.jikesrvm.compilers.opt.escape with parameters of type Operand
`private static int`	`SimpleEscape.getParameterIndex(Operand op, Instruction s)` Which parameter to a call instruction corresponds to op?

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

Methods in org.jikesrvm.compilers.opt.hir2lir that return Operand
`(package private) static Operand`	`ConvertToLowLevelIR.getTIB(Instruction s, IR ir, Operand obj, Operand guard)` get the tib from the object pointer to by obj
`(package private) static Operand`	`ConvertToLowLevelIR.getTIB(Instruction s, IR ir, RVMType type)` get the class tib for type
`(package private) static Operand`	`ConvertToLowLevelIR.getTIB(Instruction s, IR ir, TypeOperand type)` get the class tib for type

Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type Operand
`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.
`(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 Operand`	`ConvertToLowLevelIR.getTIB(Instruction s, IR ir, Operand obj, Operand guard)` get the tib from the object pointer to by obj
`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, 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.

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

Fields in org.jikesrvm.compilers.opt.ir declared as Operand
`private Operand`	`Instruction.OE.deferredMOReg`
`protected Operand`	`Instruction.BASE_OE.nextElem`
`private Operand[]`	`Instruction.ops` The operands of this instruction.

Fields in org.jikesrvm.compilers.opt.ir with type parameters of type Operand
`private Enumeration<Operand>`	`IREnumeration.AllDefsEnum.instructionOperands` Enumeration of non-heap operands defined by the instruction
`private Enumeration<Operand>`	`IREnumeration.AllUsesEnum.instructionOperands` Enumeration of non-heap operands defined by the instruction

Methods in org.jikesrvm.compilers.opt.ir that return Operand
`static Operand`	`Call.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Load.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`MIR_CacheOp.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Attempt.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Store.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Prepare.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`ALoad.getArray(Instruction i)` Get the operand called Array from the argument instruction.
`static Operand`	`AStore.getArray(Instruction i)` Get the operand called Array from the argument instruction.
`static Operand`	`MIR_DoubleShift.getBitsToShift(Instruction i)` Get the operand called BitsToShift from the argument instruction.
`static Operand`	`Call.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Load.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CacheOp.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Prepare.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`ALoad.getClearArray(Instruction i)` Get the operand called Array from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearArray(Instruction i)` Get the operand called Array from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_DoubleShift.getClearBitsToShift(Instruction i)` Get the operand called BitsToShift from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_FSave.getClearDestination(Instruction i)` Get the operand called Destination from the argument instruction clearing its instruction pointer.
`static Operand`	`Multianewarray.getClearDimension(Instruction i, int k)` Get the k'th operand called Dimension from the argument instruction clearing its instruction pointer.
`static Operand`	`OsrPoint.getClearElement(Instruction i, int k)` Get the k'th operand called Element from the argument instruction clearing its instruction pointer.
`static Operand`	`OsrBarrier.getClearElement(Instruction i, int k)` Get the k'th operand called Element from the argument instruction clearing its instruction pointer.
`static Operand`	`CondMove.getClearFalseValue(Instruction i)` Get the operand called FalseValue from the argument instruction clearing its instruction pointer.
`static Operand`	`InlineGuard.getClearGoal(Instruction i)` Get the operand called Goal from the argument instruction clearing its instruction pointer.
`static Operand`	`Call.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedBinary.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`MonitorOp.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedUnary.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`BoundsCheck.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`TypeCheck.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GetField.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Load.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardCarrier.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedSet.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`ALoad.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`StoreCheck.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`InstanceOf.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`InlineGuard.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Prepare.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`InstrumentedCounter.getClearIncrement(Instruction i)` Get the operand called Increment from the argument instruction clearing its instruction pointer.
`static Operand`	`BoundsCheck.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static Operand`	`ALoad.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearNewValue(Instruction i)` Get the operand called NewValue from the argument instruction clearing its instruction pointer.
`static Operand`	`GetField.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Load.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`GetStatic.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`PutStatic.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Prepare.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearOldValue(Instruction i)` Get the operand called OldValue from the argument instruction clearing its instruction pointer.
`Operand`	`Instruction.getClearOperand(int i)` NOTE: It is incorrect to use getClearOperand with a constant argument outside of the automatically generated code in Operators.
`static Operand`	`Call.getClearParam(Instruction i, int k)` Get the k'th operand called Param from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Call.getClearParam(Instruction i, int k)` Get the k'th operand called Param from the argument instruction clearing its instruction pointer.
`static Operand`	`MonitorOp.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`BoundsCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`TypeCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`GetField.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedSet.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`CacheOp.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`NullCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`StoreCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`InstanceOf.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Set.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_UnaryAcc.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Move.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CondMove.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_BinaryAcc.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_DoubleShift.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Unary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`Phi.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Nullary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_ConvertDW2QW.getClearResult1(Instruction i)` Get the operand called Result1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearResult1(Instruction i)` Get the operand called Result1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Multiply.getClearResult1(Instruction i)` Get the operand called Result1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_ConvertDW2QW.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Multiply.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static Operand`	`NewArray.getClearSize(Instruction i)` Get the operand called Size from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CaseLabel.getClearTarget(Instruction i)` Get the operand called Target from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Call.getClearTarget(Instruction i)` Get the operand called Target from the argument instruction clearing its instruction pointer.
`static Operand`	`CondMove.getClearTrueValue(Instruction i)` Get the operand called TrueValue from the argument instruction clearing its instruction pointer.
`static Operand`	`TableSwitch.getClearUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction clearing its instruction pointer.
`static Operand`	`LookupSwitch.getClearUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction clearing its instruction pointer.
`static Operand`	`TableSwitch.getClearUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction clearing its instruction pointer.
`static Operand`	`LookupSwitch.getClearUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedUnary.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_UnaryNoRes.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Return.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedSet.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`Unary.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`StoreCheck.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`Return.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`Move.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Unary.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`CondMove.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp2.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedBinary.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`Binary.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_TrapIf.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_XChng.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`BooleanCmp.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`TrapIf.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Compare.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Test.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`CondMove.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp2.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedBinary.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Return.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`Binary.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_TrapIf.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_XChng.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`BooleanCmp.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`TrapIf.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Compare.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Test.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`TableSwitch.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Move.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CondMove.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_BinaryAcc.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Multiply.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`LookupSwitch.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`Athrow.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`InlineGuard.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`ZeroCheck.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`PutStatic.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`Phi.getClearValue(Instruction i, int k)` Get the k'th operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`IRTools.getDefaultOperand(TypeReference type)` Returns a constant operand with a default value for a given type
`static Operand`	`MIR_FSave.getDestination(Instruction i)` Get the operand called Destination from the argument instruction.
`static Operand`	`Multianewarray.getDimension(Instruction i, int k)` Get the k'th operand called Dimension from the argument instruction.
`static Operand`	`OsrPoint.getElement(Instruction i, int k)` Get the k'th operand called Element from the argument instruction.
`static Operand`	`OsrBarrier.getElement(Instruction i, int k)` Get the k'th operand called Element from the argument instruction.
`static Operand`	`CondMove.getFalseValue(Instruction i)` Get the operand called FalseValue from the argument instruction.
`static Operand`	`InlineGuard.getGoal(Instruction i)` Get the operand called Goal from the argument instruction.
`static Operand`	`Call.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardedBinary.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`MonitorOp.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardedUnary.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`BoundsCheck.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`TypeCheck.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GetField.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Load.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardCarrier.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardedSet.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`PutField.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Attempt.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`MIR_Divide.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`ALoad.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`StoreCheck.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`InstanceOf.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`InlineGuard.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Store.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`AStore.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Prepare.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`InstrumentedCounter.getIncrement(Instruction i)` Get the operand called Increment from the argument instruction.
`static Operand`	`BoundsCheck.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static Operand`	`ALoad.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static Operand`	`AStore.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static Operand`	`Attempt.getNewValue(Instruction i)` Get the operand called NewValue from the argument instruction.
`static Operand`	`GetField.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Load.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`PutField.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Attempt.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Store.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`GetStatic.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`PutStatic.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Prepare.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Attempt.getOldValue(Instruction i)` Get the operand called OldValue from the argument instruction.
`Operand`	`Instruction.getOperand(int i)` NOTE: It is incorrect to use getOperand with a constant argument outside of the automatically generated code in Operators.
`static Operand`	`Call.getParam(Instruction i, int k)` Get the k'th operand called Param from the argument instruction.
`static Operand`	`MIR_Call.getParam(Instruction i, int k)` Get the k'th operand called Param from the argument instruction.
`static Operand`	`MonitorOp.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`BoundsCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`TypeCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`GetField.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`GuardedSet.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`PutField.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`CacheOp.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`NullCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`StoreCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`InstanceOf.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`MIR_Set.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_UnaryAcc.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Move.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_CondMove.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_BinaryAcc.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_DoubleShift.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Unary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`Phi.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Nullary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_ConvertDW2QW.getResult1(Instruction i)` Get the operand called Result1 from the argument instruction.
`static Operand`	`MIR_Divide.getResult1(Instruction i)` Get the operand called Result1 from the argument instruction.
`static Operand`	`MIR_Multiply.getResult1(Instruction i)` Get the operand called Result1 from the argument instruction.
`static Operand`	`MIR_ConvertDW2QW.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`MIR_Divide.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`MIR_Multiply.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`NewArray.getSize(Instruction i)` Get the operand called Size from the argument instruction.
`static Operand`	`MIR_CaseLabel.getTarget(Instruction i)` Get the operand called Target from the argument instruction.
`static Operand`	`MIR_Call.getTarget(Instruction i)` Get the operand called Target from the argument instruction.
`static Operand`	`CondMove.getTrueValue(Instruction i)` Get the operand called TrueValue from the argument instruction.
`static Operand`	`TableSwitch.getUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction.
`static Operand`	`LookupSwitch.getUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction.
`static Operand`	`TableSwitch.getUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction.
`static Operand`	`LookupSwitch.getUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction.
`static Operand`	`GuardedUnary.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`MIR_UnaryNoRes.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`MIR_Return.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`GuardedSet.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`Unary.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`StoreCheck.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`Return.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`Move.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`MIR_Unary.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`CondMove.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`IfCmp2.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`GuardedBinary.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`Binary.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_TrapIf.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_XChng.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`BooleanCmp.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`IfCmp.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`TrapIf.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_Compare.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_Test.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`CondMove.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`IfCmp2.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`GuardedBinary.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_Return.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`Binary.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_TrapIf.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_XChng.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`BooleanCmp.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`IfCmp.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`TrapIf.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_Compare.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_Test.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`TableSwitch.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_Move.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`PutField.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_Divide.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_CondMove.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_BinaryAcc.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_Multiply.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`LookupSwitch.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`Athrow.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`InlineGuard.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`Store.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`ZeroCheck.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`AStore.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`PutStatic.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`Phi.getValue(Instruction i, int k)` Get the k'th operand called Value from the argument instruction.
`Operand`	`IREnumeration.AllDefsEnum.nextElement()`
`Operand`	`IREnumeration.AllUsesEnum.nextElement()`
`Operand`	`Instruction.BASE_OE.nextElement()`
`private Operand`	`Instruction.outOfLineCopy(Operand op)`

Methods in org.jikesrvm.compilers.opt.ir that return types with arguments of type Operand
`Enumeration<Operand>`	`Instruction.getDefs()` Enumerate all defs (both pure defs and def/uses) of an instruction.
`Enumeration<Operand>`	`Instruction.getDefUses()` Enumerate all the def/uses of an instruction.
`Enumeration<Operand>`	`Instruction.getMemoryOperands()` Enumerate all memory operands of an instruction
`Enumeration<Operand>`	`Instruction.getOperands()` Enumerate all "leaf" operands of an instruction.
`Enumeration<Operand>`	`IR.getParameters()` Return an enumeration of the parameters to the IR Warning: Only valid before register allocation (see CallingConvention)
`Enumeration<Operand>`	`Instruction.getPureDefs()` Enumerate all the pure defs (ie not including def/uses) of an instruction.
`Enumeration<Operand>`	`Instruction.getPureUses()` Enumerate all the pure uses (ie not including def/uses) of an instruction.
`Enumeration<Operand>`	`Instruction.getRootOperands()` Enumerate all the root operands of an instruction (DOES NOT ENUMERATE CONTAINED OPERANDS OF MEMORY OPERANDS).
`Enumeration<Operand>`	`Instruction.getRootUses()` Enumerate all root uses of an instruction.
`Enumeration<Operand>`	`Instruction.getUses()` Enumerate all uses of an instruction (includes def/use).

Methods in org.jikesrvm.compilers.opt.ir with parameters of type Operand
`static Instruction`	`InstrumentedCounter.create(Operator o, IntConstantOperand Data, IntConstantOperand Index, Operand Increment)` Create an instruction of the InstrumentedCounter instruction format.
`static Instruction`	`MIR_CaseLabel.create(Operator o, IntConstantOperand Index, Operand Target)` Create an instruction of the MIR_CaseLabel instruction format.
`static Instruction`	`MIR_Return.create(Operator o, IntConstantOperand PopBytes, Operand Val, Operand Val2)` Create an instruction of the MIR_Return instruction format.
`static Instruction`	`MIR_UnaryAcc.create(Operator o, Operand Result)` Create an instruction of the MIR_UnaryAcc instruction format.
`static Instruction`	`MIR_UnaryNoRes.create(Operator o, Operand Val)` Create an instruction of the MIR_UnaryNoRes instruction format.
`static Instruction`	`CacheOp.create(Operator o, Operand Ref)` Create an instruction of the CacheOp instruction format.
`static Instruction`	`MIR_CacheOp.create(Operator o, Operand Address)` Create an instruction of the MIR_CacheOp instruction format.
`static Instruction`	`Athrow.create(Operator o, Operand Value)` Create an instruction of the Athrow instruction format.
`static Instruction`	`Return.create(Operator o, Operand Val)` Create an instruction of the Return instruction format.
`static Instruction`	`MIR_Nullary.create(Operator o, Operand Result)` Create an instruction of the MIR_Nullary instruction format.
`static Instruction`	`MIR_FSave.create(Operator o, Operand Destination)` Create an instruction of the MIR_FSave instruction format.
`static Instruction`	`MIR_Set.create(Operator o, Operand Result, IA32ConditionOperand Cond)` Create an instruction of the MIR_Set instruction format.
`static Instruction`	`Phi.create(Operator o, Operand Result, int numVarOps)` Create an instruction of the Phi instruction format.
`static Instruction`	`MIR_ConvertDW2QW.create(Operator o, Operand Result1, Operand Result2)` Create an instruction of the MIR_ConvertDW2QW instruction format.
`static Instruction`	`MonitorOp.create(Operator o, Operand Ref, Operand Guard)` Create an instruction of the MonitorOp instruction format.
`static Instruction`	`MIR_Move.create(Operator o, Operand Result, Operand Value)` Create an instruction of the MIR_Move instruction format.
`static Instruction`	`MIR_XChng.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_XChng instruction format.
`static Instruction`	`MIR_BinaryAcc.create(Operator o, Operand Result, Operand Value)` Create an instruction of the MIR_BinaryAcc instruction format.
`static Instruction`	`MIR_Compare.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_Compare instruction format.
`static Instruction`	`MIR_Test.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_Test instruction format.
`static Instruction`	`MIR_Unary.create(Operator o, Operand Result, Operand Val)` Create an instruction of the MIR_Unary instruction format.
`static Instruction`	`MIR_CondMove.create(Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond)` Create an instruction of the MIR_CondMove instruction format.
`static Instruction`	`PutStatic.create(Operator o, Operand Value, Operand Offset, LocationOperand Location)` Create an instruction of the PutStatic instruction format.
`static Instruction`	`GuardedSet.create(Operator o, Operand Ref, Operand Val, Operand Guard)` Create an instruction of the GuardedSet instruction format.
`static Instruction`	`MIR_Multiply.create(Operator o, Operand Result1, Operand Result2, Operand Value)` Create an instruction of the MIR_Multiply instruction format.
`static Instruction`	`InlineGuard.create(Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile)` Create an instruction of the InlineGuard instruction format.
`static Instruction`	`LookupSwitch.create(Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Create an instruction of the LookupSwitch instruction format.
`static Instruction`	`TableSwitch.create(Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Create an instruction of the TableSwitch instruction format.
`static Instruction`	`Store.create(Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Store instruction format.
`static Instruction`	`PutField.create(Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the PutField instruction format.
`static Instruction`	`Store.create(Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Store instruction format.
`static Instruction`	`AStore.create(Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the AStore instruction format.
`static Instruction`	`MIR_Divide.create(Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard)` Create an instruction of the MIR_Divide instruction format.
`static Instruction`	`MIR_DoubleShift.create(Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift)` Create an instruction of the MIR_DoubleShift 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_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`	`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, 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.
`static boolean`	`IRTools.defDoublesAsUse(Operand d, Instruction s)` Is the operand d, which is a def in instruction s, also a def in instruction s?
`int`	`MachineSpecificIR.getBURSManagedFPRValue(Operand operand)`
`private Object`	`IR.getVariableDef(String where, Operand operand)` Get the variable defined by this operand
`private Object`	`IR.getVariableUse(String where, Operand operand)` Get the variable used by this operand
`boolean`	`MachineSpecificIR.isBURSManagedFPROperand(Operand operand)`
`abstract boolean`	`MachineSpecificIR.isConditionOperand(Operand operand)`
`boolean`	`IR.isParameter(Operand op)` Is the operand a parameter of the IR?
`boolean`	`MachineSpecificIR.isPowerPCTrapOperand(Operand operand)`
`RegisterOperand`	`AbstractRegisterPool.makeTemp(Operand op)` Make a temporary register operand that can hold the values implied by the passed operand.
`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.
`static Instruction`	`InstrumentedCounter.mutate(Instruction i, Operator o, IntConstantOperand Data, IntConstantOperand Index, Operand Increment)` Mutate the argument instruction into an instruction of the InstrumentedCounter instruction format having the specified operator and operands.
`static Instruction`	`MIR_CaseLabel.mutate(Instruction i, Operator o, IntConstantOperand Index, Operand Target)` Mutate the argument instruction into an instruction of the MIR_CaseLabel instruction format having the specified operator and operands.
`static Instruction`	`MIR_Return.mutate(Instruction i, Operator o, IntConstantOperand PopBytes, Operand Val, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Return instruction format having the specified operator and operands.
`static Instruction`	`MIR_UnaryAcc.mutate(Instruction i, Operator o, Operand Result)` Mutate the argument instruction into an instruction of the MIR_UnaryAcc instruction format having the specified operator and operands.
`static Instruction`	`MIR_UnaryNoRes.mutate(Instruction i, Operator o, Operand Val)` Mutate the argument instruction into an instruction of the MIR_UnaryNoRes instruction format having the specified operator and operands.
`static Instruction`	`CacheOp.mutate(Instruction i, Operator o, Operand Ref)` Mutate the argument instruction into an instruction of the CacheOp instruction format having the specified operator and operands.
`static Instruction`	`MIR_CacheOp.mutate(Instruction i, Operator o, Operand Address)` Mutate the argument instruction into an instruction of the MIR_CacheOp instruction format having the specified operator and operands.
`static Instruction`	`Athrow.mutate(Instruction i, Operator o, Operand Value)` Mutate the argument instruction into an instruction of the Athrow instruction format having the specified operator and operands.
`static Instruction`	`Return.mutate(Instruction i, Operator o, Operand Val)` Mutate the argument instruction into an instruction of the Return instruction format having the specified operator and operands.
`static Instruction`	`MIR_Nullary.mutate(Instruction i, Operator o, Operand Result)` Mutate the argument instruction into an instruction of the MIR_Nullary instruction format having the specified operator and operands.
`static Instruction`	`MIR_FSave.mutate(Instruction i, Operator o, Operand Destination)` Mutate the argument instruction into an instruction of the MIR_FSave instruction format having the specified operator and operands.
`static Instruction`	`MIR_Set.mutate(Instruction i, Operator o, Operand Result, IA32ConditionOperand Cond)` Mutate the argument instruction into an instruction of the MIR_Set instruction format having the specified operator and operands.
`static Instruction`	`Phi.mutate(Instruction i, Operator o, Operand Result, int numVarOps)` Mutate the argument instruction into an instruction of the Phi instruction format having the specified operator and operands.
`static Instruction`	`MIR_ConvertDW2QW.mutate(Instruction i, Operator o, Operand Result1, Operand Result2)` Mutate the argument instruction into an instruction of the MIR_ConvertDW2QW instruction format having the specified operator and operands.
`static Instruction`	`MonitorOp.mutate(Instruction i, Operator o, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the MonitorOp instruction format having the specified operator and operands.
`static Instruction`	`MIR_Move.mutate(Instruction i, Operator o, Operand Result, Operand Value)` Mutate the argument instruction into an instruction of the MIR_Move instruction format having the specified operator and operands.
`static Instruction`	`MIR_XChng.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_XChng instruction format having the specified operator and operands.
`static Instruction`	`MIR_BinaryAcc.mutate(Instruction i, Operator o, Operand Result, Operand Value)` Mutate the argument instruction into an instruction of the MIR_BinaryAcc instruction format having the specified operator and operands.
`static Instruction`	`MIR_Compare.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Compare instruction format having the specified operator and operands.
`static Instruction`	`MIR_Test.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Test instruction format having the specified operator and operands.
`static Instruction`	`MIR_Unary.mutate(Instruction i, Operator o, Operand Result, Operand Val)` Mutate the argument instruction into an instruction of the MIR_Unary instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondMove.mutate(Instruction i, Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond)` Mutate the argument instruction into an instruction of the MIR_CondMove instruction format having the specified operator and operands.
`static Instruction`	`PutStatic.mutate(Instruction i, Operator o, Operand Value, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the PutStatic instruction format having the specified operator and operands.
`static Instruction`	`GuardedSet.mutate(Instruction i, Operator o, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedSet instruction format having the specified operator and operands.
`static Instruction`	`MIR_Multiply.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value)` Mutate the argument instruction into an instruction of the MIR_Multiply instruction format having the specified operator and operands.
`static Instruction`	`InlineGuard.mutate(Instruction i, Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the InlineGuard instruction format having the specified operator and operands.
`static Instruction`	`LookupSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Mutate the argument instruction into an instruction of the LookupSwitch instruction format having the specified operator and operands.
`static Instruction`	`TableSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Mutate the argument instruction into an instruction of the TableSwitch instruction format having the specified operator and operands.
`static Instruction`	`Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
`static Instruction`	`PutField.mutate(Instruction i, Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the PutField instruction format having the specified operator and operands.
`static Instruction`	`Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
`static Instruction`	`AStore.mutate(Instruction i, Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the AStore instruction format having the specified operator and operands.
`static Instruction`	`MIR_Divide.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard)` Mutate the argument instruction into an instruction of the MIR_Divide instruction format having the specified operator and operands.
`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`	`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_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`	`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, 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.
`private Operand`	`Instruction.outOfLineCopy(Operand op)`
`void`	`Instruction.putOperand(int i, Operand op)` NOTE: It is incorrect to use putOperand with a constant argument outside of the automatically generated code in Operators.
`void`	`Instruction.replaceOperand(Operand oldOp, Operand newOp)` Replace all occurances of the first operand with the second.
`void`	`Instruction.replaceSimilarOperands(Operand oldOp, Operand newOp)` Replace any operands that are similar to the first operand with a copy of the second operand.
`static void`	`Call.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Load.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`MIR_CacheOp.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Attempt.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Store.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Prepare.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`ALoad.setArray(Instruction i, Operand Array)` Set the operand called Array in the argument instruction to the argument operand.
`static void`	`AStore.setArray(Instruction i, Operand Array)` Set the operand called Array in the argument instruction to the argument operand.
`static void`	`MIR_DoubleShift.setBitsToShift(Instruction i, Operand BitsToShift)` Set the operand called BitsToShift in the argument instruction to the argument operand.
`static void`	`MIR_FSave.setDestination(Instruction i, Operand Destination)` Set the operand called Destination in the argument instruction to the argument operand.
`static void`	`Multianewarray.setDimension(Instruction i, int k, Operand o)` Set the k'th operand called Dimension in the argument instruction to the argument operand.
`static void`	`OsrPoint.setElement(Instruction i, int k, Operand o)` Set the k'th operand called Element in the argument instruction to the argument operand.
`static void`	`OsrBarrier.setElement(Instruction i, int k, Operand o)` Set the k'th operand called Element in the argument instruction to the argument operand.
`static void`	`CondMove.setFalseValue(Instruction i, Operand FalseValue)` Set the operand called FalseValue in the argument instruction to the argument operand.
`static void`	`InlineGuard.setGoal(Instruction i, Operand Goal)` Set the operand called Goal in the argument instruction to the argument operand.
`static void`	`Call.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`MonitorOp.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`TypeCheck.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GetField.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Load.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardCarrier.setGuard(Instruction i, Operand op)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardedSet.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`PutField.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Attempt.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`ALoad.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`StoreCheck.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`InstanceOf.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`InlineGuard.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Store.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`AStore.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Prepare.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`InstrumentedCounter.setIncrement(Instruction i, Operand Increment)` Set the operand called Increment in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`ALoad.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`AStore.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`Attempt.setNewValue(Instruction i, Operand NewValue)` Set the operand called NewValue in the argument instruction to the argument operand.
`static void`	`GetField.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Load.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`PutField.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Attempt.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Store.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`GetStatic.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`PutStatic.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Prepare.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Attempt.setOldValue(Instruction i, Operand OldValue)` Set the operand called OldValue in the argument instruction to the argument operand.
`static void`	`Call.setParam(Instruction i, int k, Operand o)` Set the k'th operand called Param in the argument instruction to the argument operand.
`static void`	`MIR_Call.setParam(Instruction i, int k, Operand o)` Set the k'th operand called Param in the argument instruction to the argument operand.
`static void`	`MonitorOp.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`TypeCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`GetField.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`GuardedSet.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`PutField.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`CacheOp.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`NullCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`StoreCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`InstanceOf.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`MIR_Set.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_UnaryAcc.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Move.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_CondMove.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_BinaryAcc.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_DoubleShift.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Unary.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Phi.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Nullary.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_ConvertDW2QW.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 in the argument instruction to the argument operand.
`static void`	`MIR_ConvertDW2QW.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`NewArray.setSize(Instruction i, Operand Size)` Set the operand called Size in the argument instruction to the argument operand.
`static void`	`MIR_CaseLabel.setTarget(Instruction i, Operand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`MIR_Call.setTarget(Instruction i, Operand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`CondMove.setTrueValue(Instruction i, Operand TrueValue)` Set the operand called TrueValue in the argument instruction to the argument operand.
`static void`	`TableSwitch.setUnknown1(Instruction i, Operand Unknown1)` Set the operand called Unknown1 in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setUnknown1(Instruction i, Operand Unknown1)` Set the operand called Unknown1 in the argument instruction to the argument operand.
`static void`	`TableSwitch.setUnknown2(Instruction i, Operand Unknown2)` Set the operand called Unknown2 in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setUnknown2(Instruction i, Operand Unknown2)` Set the operand called Unknown2 in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`MIR_UnaryNoRes.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`MIR_Return.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`GuardedSet.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`Unary.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`StoreCheck.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`Return.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`Move.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`MIR_Unary.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`CondMove.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`Binary.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_XChng.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`IfCmp.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`TrapIf.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_Compare.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_Test.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`CondMove.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_Return.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`Binary.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_XChng.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`IfCmp.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`TrapIf.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_Compare.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_Test.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`Phi.setValue(Instruction i, int k, Operand o)` Set the k'th operand called Value in the argument instruction to the argument operand.
`static void`	`TableSwitch.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Move.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`PutField.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_CondMove.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_BinaryAcc.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`Athrow.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`InlineGuard.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`Store.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`ZeroCheck.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`AStore.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`PutStatic.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static boolean`	`IRTools.useDoublesAsDef(Operand u, Instruction s)` Is the operand u, which is a use in instruction s, also a def in instruction s?

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

Methods in org.jikesrvm.compilers.opt.ir.ia32 that return Operand
`Operand`	`RegisterPool.makeJTOCOp(IR ir, Instruction s)` Return a constant operand that is the base address of the JTOC.

Methods in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type Operand
`int`	`MachineSpecificIRIA.getBURSManagedFPRValue(Operand operand)`
`boolean`	`MachineSpecificIRIA.isBURSManagedFPROperand(Operand operand)`
`boolean`	`MachineSpecificIRIA.isConditionOperand(Operand operand)`

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

Subclasses of Operand in org.jikesrvm.compilers.opt.ir.operand
`class`	`AddressConstantOperand` Represents an address constant operand.
`class`	`BasicBlockOperand` Represents a basic block (used in LABEL and BBEND instructions)
`class`	`BranchOperand` Represents a branch target.
`class`	`BranchProfileOperand`
`class`	`ClassConstantOperand` Represents a constant class operand.
`class`	`CodeConstantOperand` Represents a constant code operand, found for example, from an TIBConstantOperand.
`class`	`ConditionOperand` Encodes the condition codes for branches.
`class`	`ConstantOperand` Common superclass for all constant operands
`class`	`DoubleConstantOperand` Represents a constant double operand.
`class`	`FloatConstantOperand` Represents a constant float operand.
`class`	`HeapOperand<T>` Represents a heap variable for instructions in Heap Array SSA form.
`class`	`InlinedOsrTypeInfoOperand` An InlinedOsrTypeInfoOperand object keeps necessary information to recover non-inlined status for an inlined method.
`class`	`IntConstantOperand` Represents a constant int operand.
`class`	`LocationOperand` Represents a location in memory.
`class`	`LongConstantOperand` Represents a constant long operand.
`class`	`MemoryOperand` A memory operand.
`class`	`MethodOperand` Refers to a method.
`class`	`NullConstantOperand` This operand represents the `null` constant.
`class`	`ObjectConstantOperand` Represents a constant object operand (for example, from an initialized static final).
`class`	`OsrTypeInfoOperand` An OsrTypeInfoOperand object keeps type information of locals and stacks at a byte code index.
`class`	`RegisterOperand` A symbolic or physical register.
`class`	`StackLocationOperand` Represents a symbolic name for a stack location.
`class`	`StringConstantOperand` Represents a constant string operand.
`class`	`TIBConstantOperand` Represents a constant TIB operand, found for example, from an ObjectConstantOperand.
`class`	`TrapCodeOperand` Encode the semantic reason for a trap instruction.
`class`	`TrueGuardOperand` This operand represents a "true" guard, e.g. non-nullness of the result of an allocation or boundcheck eliminated via analysis of the loop induction variables.
`class`	`TypeOperand` A TypeOperand represents a type.
`class`	`UnreachableOperand` This operand represents, in a phi function, a control-flow path that is actually unreachable.

Fields in org.jikesrvm.compilers.opt.ir.operand declared as Operand
`Operand`	`MemoryOperand.guard` The guard operand that validates this memory access

Methods in org.jikesrvm.compilers.opt.ir.operand that return Operand
`Operand`	`OsrTypeInfoOperand.copy()`
`Operand`	`BranchOperand.copy()` Returns a copy of this branch operand.
`Operand`	`ConditionOperand.copy()`
`Operand`	`ObjectConstantOperand.copy()`
`Operand`	`TypeOperand.copy()`
`Operand`	`BasicBlockOperand.copy()`
`Operand`	`LocationOperand.copy()`
`Operand`	`MemoryOperand.copy()`
`Operand`	`ClassConstantOperand.copy()`
`Operand`	`UnreachableOperand.copy()`
`Operand`	`MethodOperand.copy()`
`Operand`	`NullConstantOperand.copy()`
`Operand`	`TrapCodeOperand.copy()`
`Operand`	`InlinedOsrTypeInfoOperand.copy()`
`Operand`	`CodeConstantOperand.copy()`
`Operand`	`AddressConstantOperand.copy()`
`Operand`	`StringConstantOperand.copy()`
`Operand`	`TIBConstantOperand.copy()`
`Operand`	`BranchProfileOperand.copy()` Returns a copy of this branch operand.
`abstract Operand`	`Operand.copy()` Return a new operand that is semantically equivalent to `this`.
`Operand`	`LongConstantOperand.copy()`
`Operand`	`DoubleConstantOperand.copy()`
`Operand`	`IntConstantOperand.copy()`
`Operand`	`StackLocationOperand.copy()`
`Operand`	`RegisterOperand.copy()` Returns a copy of this register operand as an operand
`Operand`	`TrueGuardOperand.copy()`
`Operand`	`FloatConstantOperand.copy()`
`static Operand`	`Operand.meet(Operand op1, Operand op2, Register reg)` Meet two operands based on their positions in the operand lattice.

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type Operand
`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)`
`static boolean`	`Operand.conservativelyApproximates(Operand op1, Operand op2)` Compare two operands based on their positions in the operand lattice.
`static MemoryOperand`	`MemoryOperand.D(Address disp, byte size, LocationOperand loc, Operand guard)`
`int`	`ConditionOperand.evaluate(Operand v1, Operand v2)` Given two operands, evaluate the condition on them.
`static MemoryOperand`	`MemoryOperand.I(RegisterOperand base, byte size, LocationOperand loc, Operand guard)`
`static Operand`	`Operand.meet(Operand op1, Operand op2, Register reg)` Meet two operands based on their positions in the operand lattice.
`boolean`	`OsrTypeInfoOperand.similar(Operand op)`
`boolean`	`BranchOperand.similar(Operand op)`
`boolean`	`ConditionOperand.similar(Operand op)`
`boolean`	`ObjectConstantOperand.similar(Operand op)`
`boolean`	`TypeOperand.similar(Operand op)`
`boolean`	`BasicBlockOperand.similar(Operand op)`
`boolean`	`LocationOperand.similar(Operand op)`
`boolean`	`MemoryOperand.similar(Operand op)`
`boolean`	`UnreachableOperand.similar(Operand op)`
`boolean`	`MethodOperand.similar(Operand op)`
`boolean`	`NullConstantOperand.similar(Operand op)`
`boolean`	`TrapCodeOperand.similar(Operand op)`
`boolean`	`InlinedOsrTypeInfoOperand.similar(Operand op)`
`boolean`	`CodeConstantOperand.similar(Operand op)`
`boolean`	`AddressConstantOperand.similar(Operand op)`
`boolean`	`TIBConstantOperand.similar(Operand op)`
`boolean`	`BranchProfileOperand.similar(Operand op)`
`abstract boolean`	`Operand.similar(Operand op)` Are two operands semantically equivalent?
`boolean`	`LongConstantOperand.similar(Operand op)`
`boolean`	`HeapOperand.similar(Operand op)` Does this operand correspond to the same heap variable as another heap operand?
`boolean`	`DoubleConstantOperand.similar(Operand op)`
`boolean`	`IntConstantOperand.similar(Operand op)`
`boolean`	`StackLocationOperand.similar(Operand op)`
`boolean`	`RegisterOperand.similar(Operand op)` Returns whether the given operand is a register operand and has the same register object.
`boolean`	`TrueGuardOperand.similar(Operand op)`
`boolean`	`FloatConstantOperand.similar(Operand op)`

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

Uses of Operand in org.jikesrvm.compilers.opt.ir.operand.ia32

Subclasses of Operand in org.jikesrvm.compilers.opt.ir.operand.ia32
`class`	`BURSManagedFPROperand` An FPR register that BURS is managing.
`class`	`IA32ConditionOperand` An IA32 condition operand

Methods in org.jikesrvm.compilers.opt.ir.operand.ia32 that return Operand
`Operand`	`BURSManagedFPROperand.copy()`
`Operand`	`IA32ConditionOperand.copy()`

Methods in org.jikesrvm.compilers.opt.ir.operand.ia32 with parameters of type Operand
`boolean`	`BURSManagedFPROperand.similar(Operand op)`
`boolean`	`IA32ConditionOperand.similar(Operand op)`

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

Methods in org.jikesrvm.compilers.opt.lir2mir with parameters of type Operand
`protected static AddressConstantOperand`	`BURS_Common_Helpers.AC(Operand op)`
`protected void`	`BURS_MemOp_Helpers.augmentAddress(Operand op)`
`protected static Address`	`BURS_Common_Helpers.AV(Operand op)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.consumeAddress(byte size, LocationOperand loc, Operand guard)`
`protected static int`	`BURS_Common_Helpers.FITS(Operand op, int numBits, int trueCost)`
`protected static int`	`BURS_Common_Helpers.FITS(Operand op, int numBits, int trueCost, int falseCost)`
`protected static IntConstantOperand`	`BURS_Common_Helpers.IC(Operand op)`
`protected static int`	`BURS_Common_Helpers.IV(Operand op)`
`protected static LongConstantOperand`	`BURS_Common_Helpers.LC(Operand op)`
`protected static boolean`	`BURS_Common_Helpers.MINUSONE(Operand a)`
`private MemoryOperand`	`BURS_MemOp_Helpers.MO_ARRAY(Operand base, Operand index, byte scale, byte size, Offset disp, LocationOperand loc, Operand guard)` Construct memory operand for an array access
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_B(Operand base, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_BD(Operand base, Offset disp, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_BI(Operand base, Operand index, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_BID(Operand base, Operand index, Offset disp, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_BIS(Operand base, Operand index, byte scale, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_D(Offset disp, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO(Operand base, Operand offset, byte size, LocationOperand loc, Operand guard)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO(Operand base, Operand offset, byte size, LocationOperand loc, Operand guard, int disp)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO(Operand base, Operand offset, byte size, Offset disp, LocationOperand loc, Operand guard)`
`protected static boolean`	`BURS_Common_Helpers.ONE(Operand a)`
`protected static RegisterOperand`	`BURS_Common_Helpers.R(Operand op)`
`protected static boolean`	`BURS_Common_Helpers.ZERO(Operand a)`

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

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 that return Operand
`(package private) static Operand`	`NormalizeConstants.asImmediateOrReg(Operand addr, Instruction s, IR ir)` IA32 supports 32 bit int immediates, so nothing to do.
`private Operand`	`BURS_Helpers.asReg(Instruction s, Operator movop, Operand op)` Move op into a register operand if it isn't one already.
`protected static Operand`	`BURS_Helpers.follow(Operand use)` Follow a chain of Move operations filtering back to a def
`protected Operand`	`BURS_Helpers.MO_CONV(byte size)` Create a slot on the stack in memory for a conversion
`protected Operand`	`BURS_Helpers.myFP0()`
`protected Operand`	`BURS_Helpers.myFP1()`

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 with parameters of type Operand
`(package private) static Operand`	`NormalizeConstants.asImmediateOrReg(Operand addr, Instruction s, IR ir)` IA32 supports 32 bit int immediates, so nothing to do.
`private Operand`	`BURS_Helpers.asReg(Instruction s, Operator movop, Operand op)` Move op into a register operand if it isn't one already.
`protected void`	`BURS_Helpers.ATTEMPT_IFCMP(MemoryOperand mo, Operand oldValue, Operand newValue, ConditionOperand cond, BranchOperand target, BranchProfileOperand bp)` This routine expands the compound pattern IFCMP(ATTEMPT, ZERO) into an atomic compare/exchange followed by a branch on success/failure of the attempted atomic compare/exchange.
`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.
`private static void`	`ComplexLIR2MIRExpansion.basic_long_ifcmp(Instruction s, IR ir, ConditionOperand cond, Register xh, Register xl, Operand yh, Operand yl)`
`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, 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.CALL(Instruction s, Operand address)` Expansion of CALL.
`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_Commutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` Create the MIR instruction given by operator from the Binary LIR operands
`protected void`	`BURS_Helpers.EMIT_NonCommutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` Create the MIR instruction given by operator from the Binary LIR operands
`protected void`	`BURS_Helpers.EMIT_Unary(Operator operator, Instruction s, Operand result, Operand value)` Create the MIR instruction given by operator from the Binary LIR operands
`protected static Operand`	`BURS_Helpers.follow(Operand use)` Follow a chain of Move operations filtering back to a def
`protected void`	`BURS_Helpers.FP_MOV_OP_MOV(Instruction s, Operator op, Operand result, Operand val1, Operand val2)` Expansion of FP_ADD_ACC, FP_MUL_ACC, FP_SUB_ACC, and FP_DIV_ACC.
`protected void`	`BURS_Helpers.FP_REM(Instruction s, Operand val1, Operand val2)` Expansion of FP_REM
`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.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 byte`	`BURS_Helpers.LEA_SHIFT(Operand op)`
`protected int`	`BURS_Helpers.LEA_SHIFT(Operand op, int trueCost)` Can an IV be the scale in a LEA instruction?
`protected int`	`BURS_Helpers.LEA_SHIFT(Operand op, int trueCost, int falseCost)` Can an IV be the scale in a LEA instruction?
`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_SHL(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_SHL
`protected void`	`BURS_Helpers.LONG_SHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_SHR
`protected void`	`BURS_Helpers.LONG_SUB(Instruction s, Operand result, Operand val1, Operand val2)` Expansion of LONG_SUB
`protected void`	`BURS_Helpers.LONG_USHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_USHR
`protected void`	`BURS_Helpers.LONG_XOR(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_XOR
`protected boolean`	`BURS_Helpers.SIMILAR_REGISTERS(Operand... ops)`
`protected void`	`BURS_Helpers.SSE2_ABS(boolean single, Instruction s, Operand result, Operand value)`
`protected void`	`BURS_Helpers.SSE2_CONV(Operator op, Instruction s, Operand result, Operand value)` Expansion of SSE2 conversions double <-> float
`protected void`	`BURS_Helpers.SSE2_COP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` BURS expansion of a commutative SSE2 operation.
`protected void`	`BURS_Helpers.SSE2_FCMP_FCMOV(Instruction s, RegisterOperand result, Operand lhsCmp, Operand rhsCmp, ConditionOperand cond, Operand trueValue, Operand falseValue)`
`protected void`	`BURS_Helpers.SSE2_IFCMP(Operator op, Instruction s, Operand val1, Operand val2)` Expansion of SSE2 comparison operations
`protected Operator`	`BURS_Helpers.SSE2_MOVE(Operand o)` Returns the appropriate move operator based on the type of operand.
`protected void`	`BURS_Helpers.SSE2_NCOP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` BURS expansion of a non commutative SSE2 operation.
`protected void`	`BURS_Helpers.SSE2_NEG(boolean single, Instruction s, Operand result, Operand value)` Expansion of SSE2 negation ops
`protected byte`	`BURS_Helpers.SSE2_SIZE(Operand o)` Returns the size based on the type of operand.
`protected void`	`BURS_Helpers.STORE_LONG_FOR_CONV(Operand op)` Create a 64bit slot on the stack in memory for a conversion and store the given long
`protected void`	`BURS_Helpers.SYSCALL(Instruction s, Operand address)` Expansion of SYSCALL.

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

Methods in org.jikesrvm.compilers.opt.mir2mc.ia32 with parameters of type Operand
`(package private) RegisterConstants.GPR`	`AssemblerBase.getBase(Operand op)` Given a memory operand, return the 3 bit IA32 ISA encoding of its base regsiter.
`(package private) byte`	`AssemblerBase.getCond(Operand op)` Return the condition bits of a given optimizing compiler condition operand.
`(package private) Offset`	`AssemblerBase.getDisp(Operand op)` Given a memory operand, return the 2 bit IA32 ISA encoding of its scale, suitable for passing to the Assembler to mask into a SIB byte.
`(package private) RegisterConstants.FPR`	`AssemblerBase.getFPR_Reg(Operand op)`
`(package private) RegisterConstants.GPR`	`AssemblerBase.getGPR_Reg(Operand op)`
`(package private) int`	`AssemblerBase.getImm(Operand op)` Return the IA32 ISA encoding of the immediate value represented by the the given operand.
`(package private) RegisterConstants.GPR`	`AssemblerBase.getIndex(Operand op)` Given a memory operand, return the 3 bit IA32 ISA encoding of its index register.
`(package private) int`	`AssemblerBase.getLabel(Operand op)` Return the label representing the target of the given branch operand.
`(package private) RegisterConstants.MM`	`AssemblerBase.getMM_Reg(Operand op)`
`(package private) RegisterConstants.MachineRegister`	`AssemblerBase.getReg(Operand op)` Given a register operand, return the 3 bit IA32 ISA encoding of that register.
`(package private) short`	`AssemblerBase.getScale(Operand op)` Given a memory operand, return the 2 bit IA32 ISA encoding of its scale, suitable for passing to the Assembler to mask into a SIB byte.
`(package private) RegisterConstants.XMM`	`AssemblerBase.getXMM_Reg(Operand op)`
`(package private) boolean`	`AssemblerBase.isAbs(Operand op)` Determine if a given operand is a memory operand representing absolute mode addressing.
`(package private) boolean`	`AssemblerBase.isCond(Operand op)` Is the given operand an IA32 condition operand?
`(package private) boolean`	`AssemblerBase.isFPR_Reg(Operand op)`
`(package private) boolean`	`AssemblerBase.isGPR_Reg(Operand op)`
`(package private) boolean`	`AssemblerBase.isImm(Operand op)` Is the given operand an immediate?
`(package private) boolean`	`AssemblerBase.isImmOrLabel(Operand op)` Is the given operand a branch target?
`(package private) boolean`	`AssemblerBase.isLabel(Operand op)` Is the given operand a branch target that requires a label?
`(package private) boolean`	`AssemblerBase.isMM_Reg(Operand op)`
`(package private) boolean`	`AssemblerBase.isReg(Operand op)` Is the given operand a register operand?
`(package private) boolean`	`AssemblerBase.isRegDisp(Operand op)` Determine if a given operand is a memory operand representing register-displacement mode addressing.
`(package private) boolean`	`AssemblerBase.isRegIdx(Operand op)` Determine if a given operand is a memory operand representing the full glory of scaled-index-base addressing.
`(package private) boolean`	`AssemblerBase.isRegInd(Operand op)` Determine if a given operand is a memory operand representing register-indirect mode addressing.
`(package private) boolean`	`AssemblerBase.isRegOff(Operand op)` Determine if a given operand is a memory operand representing register-offset mode addressing.
`(package private) boolean`	`AssemblerBase.isXMM_Reg(Operand op)`
`private int`	`AssemblerBase.operandCost(Operand op, boolean shortFormImmediate)`

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

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

Methods in org.jikesrvm.compilers.opt.ssa that return Operand
`private Operand`	`ValueGraph.bypassMoves(Operand op)` Bypass MOVE instructions that def an operand: return the first def in the chain that is not the result of a MOVE instruction.
`private Operand`	`LoopVersioning.getConstantAdjustedArrayLengthRef(Operand op)` Get the array length reference ignoring instructions that adjust its result by a fixed amount
`(package private) Operand`	`LICM.getResult(Instruction inst)` Get the result operand of the instruction
`(package private) Operand`	`LeaveSSA.VariableStacks.peek(Register s)` Get the name at the top of the stack for a particular register
`(package private) Operand`	`LeaveSSA.VariableStacks.pop(Register s)` Pop the name at the top of the stack for a particular register

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type Operand
`(package private) static void`	`LoadElimination.appendMove(Register r, Operand src, Instruction store)` Append an instruction after a store instruction that caches value in register r.
`private Operand`	`ValueGraph.bypassMoves(Operand op)` Bypass MOVE instructions that def an operand: return the first def in the chain that is not the result of a MOVE instruction.
`(package private) Instruction`	`LICM.definingInstruction(Operand op)` Return the instruction that defines the operand.
`private BasicBlock`	`LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry)` Generate bound check branch blocks
`private int`	`LoopVersioning.getConstantAdjustedArrayLengthDistance(Operand op)` Get the distance from an array length by addding up instructions that adjust the array length result by a constant amount
`private Operand`	`LoopVersioning.getConstantAdjustedArrayLengthRef(Operand op)` Get the array length reference ignoring instructions that adjust its result by a fixed amount
`(package private) void`	`LeaveSSA.VariableStacks.push(Register s, Operand name)` Push a name at the top of the stack for a particular register
`(package private) BasicBlock`	`LICM.useBlock(Instruction use, Operand op)`
`private boolean`	`LICM.useDominates(Operand op, BasicBlock block)`

Method parameters in org.jikesrvm.compilers.opt.ssa with type arguments of type Operand
`private Instruction`	`LICM.scheduleScalarDefsEarly(Enumeration<Operand> e, Instruction earlyPos, Instruction inst)` Schedule me as early as possible, but behind the definitions in e and behind earlyPos

Uses of Operand in org.jikesrvm.osr

Fields in org.jikesrvm.osr declared as Operand
`Operand`	`LocalRegPair.operand` What's the register operand, from which we can get the symbolic register.

Constructors in org.jikesrvm.osr with parameters of type Operand
`LocalRegPair(boolean kind, int num, byte type, Operand op)`

Overview

Package

Class

Use

Tree

Serialized

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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

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