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

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

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

Methods in org.jikesrvm.adaptive.measurements.instrumentation that return Instruction
`Instruction`	`ManagedCounterData.createEventCounterInstruction(int counterNumber)` Create a place holder instruction to represent an increment of a particular counted event.
`(package private) Instruction`	`ManagedCounterData.createEventCounterInstruction(int counterNumber, double incrementValue)` Create a place holder instruction to represent the counted event.
`Instruction`	`CounterArrayManager.createEventCounterInstruction(int handle, int index, double incrementValue)` Create a place holder instruction to represent the counted event.
`Instruction`	`StringEventCounterData.getCounterInstructionForEvent(String event)` Given a string, find or create the counter associated and return and instruction to increment that counter.
`Instruction`	`StringEventCounterData.getCounterInstructionForEvent(String event, double incrementValue)` Given a string, find or create the counter associated and return and instruction to increment that counter.

Methods in org.jikesrvm.adaptive.measurements.instrumentation with parameters of type Instruction
`(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.
`void`	`CounterArrayManager.mutateOptEventCounterInstruction(Instruction counterInst, IR ir)` Take an event counter instruction and mutate it into IR instructions that will do the actual counting.

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

Methods in org.jikesrvm.adaptive.recompilation.instrumentation that return Instruction
`private static Instruction`	`InstrumentationSamplingFramework.getFirstInstWithOperator(Operator operator, BasicBlock bb)` Go through all instructions and find the first with the given operator.
`static Instruction`	`InstrumentationSamplingFramework.getFirstInstWithYieldPoint(BasicBlock bb)` Go through all instructions and find one that is a yield point

Methods in org.jikesrvm.adaptive.recompilation.instrumentation with parameters of type Instruction
`private void`	`InstrumentationSamplingFramework.conditionalizeInstrumentationOperation(IR ir, Instruction i, BasicBlock bb)` Take an instrumentation operation (an instruction) and guard it with a counter-based check. 1) split the basic block before and after the i to get A -> B -> C 2) Add check to A, making it go to B if it succeeds, otherwise C
`private static boolean`	`InstrumentationSamplingFramework.isInstrumentationInstruction(Instruction i)` How to determine whether a given instruction is an "instrumentation instruction".
`static boolean`	`InstrumentationSamplingFramework.isYieldpoint(Instruction i)` Is the given instruction a yieldpoint?

Uses of Instruction in org.jikesrvm.compilers.opt

Fields in org.jikesrvm.compilers.opt declared as Instruction
`(package private) Instruction`	`LocalCSE.AvailableExpression.inst` the instruction which makes this expression available

Methods in org.jikesrvm.compilers.opt that return Instruction
`abstract Instruction`	`InstrumentedEventCounterManager.createEventCounterInstruction(int handle, int location, double incrementValue)` Create a place holder instruction to represent the counted event.
`private static Instruction`	`ExpressionFolding.transform(Instruction s, Instruction def)` Perform the transformation on the instruction

Methods in org.jikesrvm.compilers.opt with parameters of type Instruction
`private static Simplifier.DefUseEffect`	`Simplifier.addr2Int(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.addr2Long(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.arrayLength(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.booleanCmpAddr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.booleanCmpInt(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.booleanNot(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.boundsCheck(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.call(boolean HIR, AbstractRegisterPool regpool, Instruction s, OptOptions opts)`
`private boolean`	`NullCheckCombining.canFold(Instruction s, Operand activeGuard, boolean isStore)`
`private static void`	`Simplifier.canonicalizeCommutativeOperator(Instruction instr)` To reduce the number of conditions to consider, we transform all commutative operators to a canoncial form.
`private static Simplifier.DefUseEffect`	`Simplifier.checkcast(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.checkcastNotNull(Instruction s, OptOptions opts)`
`private void`	`LocalCSE.checkHelper(IR ir, LocalCSE.AvExCache cache, Instruction inst)` Process a check instruction
`private static Simplifier.DefUseEffect`	`Simplifier.double2Float(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.double2Int(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.double2Long(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleAdd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleAsLongBits(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleCmpg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleCmpl(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleCondMove(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleDiv(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleMul(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleNeg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleRem(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleSqrt(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.doubleSub(Instruction s, OptOptions opts)`
`void`	`LocalCSE.AvExCache.eliminate(Instruction s)` Eliminate all AE tuples that are killed by a given instruction
`(package private) static Operand`	`Simple.equivalentValforPHI(Instruction phi)` Try to find an operand that is equivalent to the result of a given phi instruction.
`private void`	`LocalCSE.expressionHelper(IR ir, LocalCSE.AvExCache cache, Instruction inst)` Process a unary or binary expression.
`LocalCSE.AvailableExpression`	`LocalCSE.AvExCache.find(Instruction inst)` Find and return a matching available expression.
`private static Simplifier.DefUseEffect`	`Simplifier.float2Double(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.float2Int(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.float2Long(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatAdd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatAsIntBits(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatCmpg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatCmpl(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatCondMove(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatDiv(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatMul(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatNeg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatRem(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatSqrt(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.floatSub(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.getArrayElementTibFromTib(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.getClassTib(Instruction s, OptOptions opts)`
`private static RegisterOperand`	`ExpressionFolding.getDefFromCandidate(Instruction s, boolean first)` Get the register that's defined by the candidate instruction
`private static Simplifier.DefUseEffect`	`Simplifier.getDoesImplementFromTib(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.getField(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.getObjTib(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.getSuperclassIdsFromTib(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.getTypeFromTib(Instruction s, OptOptions opts)`
`private static RegisterOperand`	`ExpressionFolding.getUseFromCandidate(Instruction s)` Get the register that's used by the candidate instruction
`private static Simplifier.DefUseEffect`	`Simplifier.guardCombine(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.guardCondMove(Instruction s, OptOptions opts)`
`void`	`LocalCSE.AvExCache.insert(Instruction inst)` Insert a new available expression in the cache
`private static Simplifier.DefUseEffect`	`Simplifier.instanceOf(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.instanceOfNotNull(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2AddrSigExt(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2AddrZerExt(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2Byte(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2Double(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2Float(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2Long(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2Short(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.int2UShort(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intAdd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intAnd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intBitsAsFloat(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intCondMove(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intDiv(AbstractRegisterPool regpool, Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intMul(AbstractRegisterPool regpool, Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intNeg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intNot(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intOr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intRem(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intShl(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intShr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intSub(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intUshr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intXor(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.intZeroCheck(Instruction s, OptOptions opts)`
`private boolean`	`LocalCastOptimization.invertNullAndTypeChecks(Instruction s)` If there's a checkcast followed by a null check, move the checkcast after the null check, since the null pointer exception must be thrown anyway.
`private static Register`	`ExpressionFolding.isCandidateExpression(Instruction s, boolean ssa)` Does instruction s compute a register r = candidate expression?
`private boolean`	`LocalCSE.isCheck(Instruction inst)` Is the given instruction a check instruction?
`private boolean`	`NullCheckCombining.isExplicitLoad(Instruction s, Operator op)`
`private boolean`	`NullCheckCombining.isExplicitStore(Instruction s, Operator op)`
`private boolean`	`LocalCSE.isExpression(Instruction inst)` Does the instruction compute some expression?
`static boolean`	`LocalCSE.isLoadInstruction(Instruction s)` Is a given instruction a CSE-able load?
`static boolean`	`LocalCSE.isStoreInstruction(Instruction s)` Is a given instruction a CSE-able store?
`private static boolean`	`LocalCSE.isSynchronizing(Instruction inst)` Is this a synchronizing instruction?
`private boolean`	`LocalCSE.isTypeCheck(Instruction inst)`
`private void`	`LocalCSE.loadHelper(IR ir, LocalCSE.AvExCache cache, Instruction inst)` Process a load instruction
`private static Simplifier.DefUseEffect`	`Simplifier.long2Addr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.long2Double(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.long2Float(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.long2Int(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longAdd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longAnd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longBitsAsDouble(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longCmp(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longCondMove(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longDiv(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longMul(AbstractRegisterPool regpool, Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longNeg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longNot(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longOr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longRem(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longShl(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longShr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longSub(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longUshr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longXor(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.longZeroCheck(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.multiplyByConstant(AbstractRegisterPool regpool, Instruction s, Operand op1, Operand op2, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.mustImplementInterface(Instruction s, OptOptions opts)`
`abstract void`	`InstrumentedEventCounterManager.mutateOptEventCounterInstruction(Instruction i, IR ir)` Take an event counter instruction and mutate it into IR instructions that will do the actual counting.
`private static Simplifier.DefUseEffect`	`Simplifier.nullCheck(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.objarrayStoreCheck(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.objarrayStoreCheckNotNull(Instruction s, OptOptions opts)`
`private boolean`	`LocalCastOptimization.pushTypeCheckBelowIf(Instruction s, IR ir)` Where legal, move a type check below an if instruction.
`private static Simplifier.DefUseEffect`	`Simplifier.refAdd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refAnd(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refCondMove(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refLoad(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refNeg(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refNot(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refOr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refShl(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refShr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refSub(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refUshr(Instruction s, OptOptions opts)`
`private static Simplifier.DefUseEffect`	`Simplifier.refXor(Instruction s, OptOptions opts)`
`static void`	`DefUse.removeInstructionAndUpdateDU(Instruction s)` Remove an instruction and update register lists.
`static void`	`DefUse.replaceInstructionAndUpdateDU(Instruction oldI, Instruction newI)` Replace an instruction and update register lists.
`static Simplifier.DefUseEffect`	`Simplifier.simplify(boolean hir, AbstractRegisterPool regpool, OptOptions opts, Instruction s)` Given an instruction, attempt to simplify it.
`private void`	`LocalCSE.storeHelper(LocalCSE.AvExCache cache, Instruction inst)` Process a store instruction
`private static Instruction`	`ExpressionFolding.transform(Instruction s, Instruction def)` Perform the transformation on the instruction
`private static Simplifier.DefUseEffect`	`Simplifier.trapIf(Instruction s, OptOptions opts)`
`private static void`	`LocalCSE.typeCheckHelper(IR ir, LocalCSE.AvExCache cache, Instruction inst)` Process a type check instruction
`static void`	`DefUse.updateDUForNewInstruction(Instruction s)` Update register lists to account for the effect of a new instruction s

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

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

Fields in org.jikesrvm.compilers.opt.bc2ir declared as Instruction
`private Instruction`	`BC2IR.lastInstr` Last instruction generated (for ELIM_COPY_LOCALS)
`private Instruction`	`BC2IR.lastOsrBarrier` osr barrier needs type information of locals and stacks, it has to be created before a _callHelper.

Methods in org.jikesrvm.compilers.opt.bc2ir that return Instruction
`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 Instruction`	`BC2IR._callHelper(MethodReference meth, MethodOperand methOp)` Pop method parameters off the expression stack.
`private Instruction`	`BC2IR._createOsrBarrier()`
`private Instruction`	`BC2IR._gotoHelper(int offset)`
`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 Instruction`	`BC2IR._intIfCmpHelper(ConditionOperand cond)`
`private Instruction`	`BC2IR._intIfHelper(ConditionOperand cond)`
`private Instruction`	`BC2IR._jsrHelper(int offset)`
`private Instruction`	`BC2IR._moveDualHelper(Operator operator, Operand val, TypeReference type)`
`private Instruction`	`BC2IR._moveHelper(Operator operator, Operand val, TypeReference type)`
`static Instruction`	`BC2IR._osrHelper(Instruction barrier)` Creates an OSR point instruction with its dependent OsrBarrier which provides type and variable information.
`private Instruction`	`BC2IR._refIfCmpHelper(ConditionOperand cond)`
`private Instruction`	`BC2IR._refIfNullHelper(ConditionOperand cond)`
`private Instruction`	`BC2IR._retHelper(int var)`
`private Instruction`	`BC2IR._unaryDualHelper(Operator operator, Operand val, TypeReference type)`
`private Instruction`	`BC2IR._unaryHelper(Operator operator, Operand val, TypeReference type)`
`private Instruction`	`BC2IR.do_aload(int index)` Simulate a load from a given local variable of a reference.
`private Instruction`	`BC2IR.do_astore(int index)` Simulate a store into a given local variable of an object ref.
`private Instruction`	`BC2IR.do_dload(int index)` Simulate a load from a given local variable of a double.
`private Instruction`	`BC2IR.do_fload(int index)` Simulate a load from a given local variable of a float.
`private Instruction`	`BC2IR.do_iinc(int index, int amount)` Simulate the incrementing of a given int local variable.
`private Instruction`	`BC2IR.do_iload(int index)` Simulate a load from a given local variable of an int.
`private Instruction`	`BC2IR.do_lload(int index)` Simulate a load from a given local variable of a long.
`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.)
`Instruction`	`BC2IR.generateAnewarray(TypeReference arrayTypeRef, TypeReference elementTypeRef)`
`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.

Methods in org.jikesrvm.compilers.opt.bc2ir that return types with arguments of type Instruction
`private LinkedList<Instruction>`	`OsrPointConstructor.collectOsrPoints(IR ir)` Iterates instructions, build a list of OsrPoint instructions.

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type Instruction
`static Instruction`	`BC2IR._osrHelper(Instruction barrier)` Creates an OSR point instruction with its dependent OsrBarrier which provides type and variable information.
`private void`	`OsrPointConstructor.adjustBCIndex(Instruction barrier)` The OsrBarrier instruction is not in IR, so the bc index was not adjusted in OSR_AdjustBCIndex
`private void`	`GenerationContext.appendInstruction(BasicBlock b, Instruction s, int bcIndex)`
`void`	`BC2IR.appendInstruction(Instruction s)` Append an instruction to the current basic block.
`static GenerationContext`	`GenerationContext.createChildContext(GenerationContext parent, ExceptionHandlerBasicBlockBag ebag, NormalMethod callee, Instruction callSite)` Create a child generation context from parent & callerBB to generate IR for callsite.
`private boolean`	`OsrPointConstructor.isBarrierClean(Instruction barrier)` verify barrier is clean by checking the number of valid operands
`private boolean`	`BC2IR.maybeInlineMethod(InlineDecision inlDec, Instruction callSite)` Attempt to inline a method.
`private InlineDecision`	`BC2IR.shouldInline(Instruction call, boolean isExtant, int realBCI)` Should we inline a call site?

Method parameters in org.jikesrvm.compilers.opt.bc2ir with type arguments of type Instruction
`private void`	`OsrPointConstructor.fixupCFGForOsr(LinkedList<Instruction> osrs, IR ir)` Split each OsrPoint, and connect it to the exit point.
`private void`	`OsrPointConstructor.renovateOsrPoints(LinkedList<Instruction> osrs, IR ir)` For each OsrPoint instruction, traces its OsrBarriers created by inlining. rebuild OsrPoint instruction to hold all necessary information to recover from inlined activation.

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

Fields in org.jikesrvm.compilers.opt.controlflow declared as Instruction
`private Instruction`	`AnnotatedLSTNode.ifCmpInstr` The if instruction within the exit block
`private Instruction`	`AnnotatedLSTNode.iteratorInstr` The instruction that modifies the iterator
`(package private) Instruction`	`StaticSplitting.CandInfo.test`

Methods in org.jikesrvm.compilers.opt.controlflow that return Instruction
`private Instruction[]`	`BranchOptimizations.copyAndMapInstructions(BasicBlock bb, HashMap<Instruction,Instruction> map)` For each real non-branch instruction s in bb, Copy s to s', and store s' in the returned array Insert the function s->s' in the map
`static Instruction`	`AnnotatedLSTNode.definingInstruction(Operand op)` Find the instruction that defines an operand.
`private static Instruction`	`LoopUnrolling.definingInstruction(Operand op)`
`protected Instruction`	`BranchOptimizationDriver.firstLabelFollowing(Instruction s)` Given an instruction s, return the first LABEL instruction following s.
`protected Instruction`	`BranchOptimizationDriver.firstRealInstructionFollowing(Instruction s)` Given an instruction s, return the first real (non-label) instruction following s
`private Instruction`	`StaticSplitting.getCandidateTest(BasicBlock bb)` Return the candidate test in b, or `null` if b does not have one.
`(package private) Instruction`	`TailRecursionElimination.transform(Instruction call, Instruction prologue, BasicBlock target, IR ir)` Transform the tail recursive call into a loop.

Methods in org.jikesrvm.compilers.opt.controlflow with parameters of type Instruction
`private void`	`BranchOptimizations.booleanCompareHelper(Instruction cb, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Generate a boolean operation opcode 1) IF br !
`private void`	`BranchOptimizations.doCondMove(IR ir, Diamond diamond, Instruction cb)` Perform the transformation to replace conditional branch with a sequence using conditional moves.
`(package private) static void`	`AnnotatedLSTNode.dumpInstruction(IR ir, Instruction instr)` Dump a human readable description of an instruction within a basic block within the loop
`private BasicBlock`	`StaticSplitting.findColdSucc(BasicBlock bb, Instruction test)` Return the off-trace successor of b (on and off relative to the argument test)
`protected Instruction`	`BranchOptimizationDriver.firstLabelFollowing(Instruction s)` Given an instruction s, return the first LABEL instruction following s.
`protected Instruction`	`BranchOptimizationDriver.firstRealInstructionFollowing(Instruction s)` Given an instruction s, return the first real (non-label) instruction following s
`private void`	`BranchOptimizations.flipConditionalBranch(Instruction cb)` Flip a conditional branch and remove the trailing goto.
`private void`	`MIRBranchOptimizations.flipConditionalBranch(Instruction cb)` Flip a conditional branch and remove the trailing goto.
`private boolean`	`BranchOptimizations.generateBooleanCompare(IR ir, BasicBlock bb, Instruction cb, BasicBlock tb)` Attempt to generate a boolean compare opcode from a conditional branch.
`private boolean`	`BranchOptimizations.generateCondMove(IR ir, BasicBlock bb, Instruction cb)` Attempt to generate a straight-line sequence using conditional move instructions, to replace a diamond control flow structure.
`private void`	`BranchOptimizations.insertBefore(Instruction[] list, Instruction s)` Insert each instruction in a list before instruction s
`private void`	`BranchOptimizations.insertBefore(Instruction[] list, Instruction s)` Insert each instruction in a list before instruction s
`private static void`	`BranchSimplifier.insertTrueGuard(Instruction inst, RegisterOperand guard)`
`(package private) static String`	`AnnotatedLSTNode.instructionToString(IR ir, Instruction instr)` Convert instruction to String in of AnnotatedLSTNode format
`private boolean`	`BranchOptimizations.isFlipCandidate(Instruction cb, Instruction target)` Is a conditional branch a candidate to be flipped?
`private boolean`	`MIRBranchOptimizations.isFlipCandidate(Instruction cb, Instruction target)` Is a conditional branch a candidate to be flipped?
`(package private) boolean`	`TailRecursionElimination.isTailRecursion(Instruction call, IR ir)` Is the argument call instruction a tail recursive call?
`protected abstract boolean`	`BranchOptimizationDriver.optimizeBranchInstruction(IR ir, Instruction s, BasicBlock bb)` This method actually does the work of attempting to peephole optimize a branch instruction.
`protected boolean`	`BranchOptimizations.optimizeBranchInstruction(IR ir, Instruction s, BasicBlock bb)` This method actually does the work of attempting to peephole optimize a branch instruction.
`protected boolean`	`MIRBranchOptimizations.optimizeBranchInstruction(IR ir, Instruction s, BasicBlock bb)` This method actually does the work of attempting to peephole optimize a branch instruction.
`private boolean`	`MIRBranchOptimizations.processCondBranch(IR ir, Instruction cb, BasicBlock bb)` Perform optimizations for a conditional branch.
`private boolean`	`BranchOptimizations.processConditionalBranch(IR ir, Instruction cb, BasicBlock bb)` Perform optimizations for a conditional branch.
`private boolean`	`BranchOptimizations.processGoto(IR ir, Instruction g, BasicBlock bb)` Perform optimizations for a Goto.
`private boolean`	`MIRBranchOptimizations.processGoto(IR ir, Instruction g, BasicBlock bb)` Perform optimizations for an unconditonal branch.
`(package private) static boolean`	`BranchSimplifier.processIfCmp(IR ir, BasicBlock bb, Instruction s)` Process IfCmp branch instruction
`(package private) static boolean`	`BranchSimplifier.processIfCmp2(IR ir, BasicBlock bb, Instruction s)` Process IfCmp2 branch instruction
`(package private) static boolean`	`BranchSimplifier.processInlineGuard(IR ir, BasicBlock bb, Instruction s)` Process InlineGuard branch instruction
`private boolean`	`BranchOptimizations.processInlineGuard(IR ir, Instruction cb, BasicBlock bb)` Perform optimizations for an inline guard.
`(package private) static boolean`	`BranchSimplifier.processLookupSwitch(IR ir, BasicBlock bb, Instruction s)` Process LookupSwitch branch instruction
`(package private) static boolean`	`BranchSimplifier.processTableSwitch(IR ir, BasicBlock bb, Instruction s)` Process TableSwitch branch instruction
`private boolean`	`BranchOptimizations.processTwoTargetConditionalBranch(IR ir, Instruction cb, BasicBlock bb)` Perform optimizations for a two way conditional branch.
`private boolean`	`MIRBranchOptimizations.processTwoTargetConditionalBranch(IR ir, Instruction cb, BasicBlock bb)` Perform optimizations for a two way conditional branch.
`private void`	`StaticSplitting.pushCandidate(BasicBlock cand, BasicBlock prev, BasicBlock succ, Instruction test)`
`private void`	`BranchOptimizations.rewriteWithTemporaries(Instruction[] set, IR ir)` For each in a set of instructions, rewrite every def to use a new temporary register.
`(package private) Instruction`	`TailRecursionElimination.transform(Instruction call, Instruction prologue, BasicBlock target, IR ir)` Transform the tail recursive call into a loop.

Method parameters in org.jikesrvm.compilers.opt.controlflow with type arguments of type Instruction
`private Instruction[]`	`BranchOptimizations.copyAndMapInstructions(BasicBlock bb, HashMap<Instruction,Instruction> map)` For each real non-branch instruction s in bb, Copy s to s', and store s' in the returned array Insert the function s->s' in the map
`private Instruction[]`	`BranchOptimizations.copyAndMapInstructions(BasicBlock bb, HashMap<Instruction,Instruction> map)` For each real non-branch instruction s in bb, Copy s to s', and store s' in the returned array Insert the function s->s' in the map

Constructors in org.jikesrvm.compilers.opt.controlflow with parameters of type Instruction
`StaticSplitting.CandInfo(BasicBlock c, BasicBlock p, BasicBlock s, Instruction t, StaticSplitting.CandInfo n)`

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

Fields in org.jikesrvm.compilers.opt.depgraph declared as Instruction
`Instruction`	`DepGraphNode._instr` Instruction that this node represents.

Methods in org.jikesrvm.compilers.opt.depgraph that return Instruction
`Instruction`	`DepGraphNode.instruction()` Get the instruction this node represents.

Methods in org.jikesrvm.compilers.opt.depgraph with parameters of type Instruction
`private void`	`DepGraph.clearRegisters(Instruction start, Instruction end)` Initialize (clear) the dNode field in Register for all registers in this basic block by setting them to null.
`private void`	`DepGraph.computeBackwardDependences(Instruction start, Instruction end)` Compute anti dependences by doing a backwards traversal of the instructions from start to end.
`private void`	`DepGraph.computeControlAndBarrierDependences(Instruction start, Instruction end)` Compute control and barrier (acquire/release) dependences in two passes (one forward, one reverse over the instructions from start to end.
`private void`	`DepGraph.computeForwardDependences(Instruction start, Instruction end)` Compute flow and output dependences by doing a forward traversal of the instructions from start to end.
`private void`	`DepGraph.createNodes(Instruction start, Instruction end)` Create the dependency graph nodes for instructions start to end
`(package private) int`	`DepGraphStats.estimateExecutionTime(Instruction instr)` Return an estimate of the number of cycles for a given instruction.
`private LocationOperand`	`DepGraph.getLocation(Instruction s)` Get the location of a given load or store instruction.

Constructors in org.jikesrvm.compilers.opt.depgraph with parameters of type Instruction
`DepGraph(IR ir, Instruction start, Instruction end, BasicBlock currentBlock)` Constructor (computes the dependence graph!).
`DepGraphNode(Instruction instr)` Constructor.

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

Methods in org.jikesrvm.compilers.opt.escape with parameters of type Instruction
`private AggregateReplacer`	`EscapeTransformations.getAggregateReplacer(Instruction inst, IR ir)` Generate an object which will perform scalar replacement of an aggregate allocated by a given instruction PRECONDITION: objects returned by this allocation site do NOT escape the current method
`private static int`	`SimpleEscape.getParameterIndex(Operand op, Instruction s)` Which parameter to a call instruction corresponds to op?
`static ShortArrayReplacer`	`ShortArrayReplacer.getReplacer(Instruction inst, IR ir)` Return an object representing this transformation for a given allocation site
`static ObjectReplacer`	`ObjectReplacer.getReplacer(Instruction inst, IR ir)` Return an object representing this transformation for a given allocation site
`static UnsyncReplacer`	`UnsyncReplacer.getReplacer(Instruction inst, IR ir)` Generate an instance of this class for a particular instantiation site.
`private UnsyncReplacer`	`EscapeTransformations.getUnsyncReplacer(Register reg, Instruction inst, IR ir)` Generate an object which transforms defs & uses of "synchronized" objects to defs & uses of "unsynchronized" objects PRECONDITION: objects pointed to by reg do NOT escape
`private void`	`ShortArrayReplacer.transform2(Register reg, Instruction defI, RegisterOperand[] scalars)`
`private void`	`ObjectReplacer.transform2(Register reg, Instruction defI, RegisterOperand[] scalars, ArrayList<RVMField> fields, Set<Register> visited)`

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

Methods in org.jikesrvm.compilers.opt.hir2lir that return Instruction
`(package private) static Instruction`	`DynamicTypeCheckExpansion.arrayStoreCheck(Instruction s, IR ir, boolean couldBeNull)` Expand an object array store check into the LIR sequence that implements it.
`(package private) static Instruction`	`ConvertToLowLevelIR.callHelper(Instruction v, IR ir)` Helper method for call expansion.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.checkcast(Instruction s, IR ir)` Expand a checkcast instruction into the LIR sequence that implements the dynamic type check, raising a ClassCastException when the type check fails.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.checkcastNotNull(Instruction s, IR ir)` Expand a checkcast instruction into the LIR sequence that implements the dynamic type check, raising a ClassCastException when the type check fails.
`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 Instruction`	`DynamicTypeCheckExpansion.instanceOf(Instruction s, IR ir)` Expand an instanceof instruction into the LIR sequence that implements the dynamic type check.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.instanceOfNotNull(Instruction s, IR ir)` Expand an instanceof instruction into the LIR sequence that implements the dynamic type check.
`(package private) static Instruction`	`ConvertToLowLevelIR.lookup(Instruction switchInstr, IR ir)` Expand a lookupswitch.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.mustImplementInterface(Instruction s, IR ir)` Expand a checkcastInterface instruction into the LIR sequence that implements the dynamic type check, raising an IncompataibleClassChangeError if the type check fails.
`private static Instruction`	`ConvertToLowLevelIR.resolveMember(Instruction s, IR ir)` Generate the code to resolve a member (field/method) reference.
`(package private) static Instruction`	`ConvertToLowLevelIR.tableswitch(Instruction s, IR ir)` Expand a tableswitch.

Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type Instruction
`private static BasicBlock`	`ConvertToLowLevelIR._lookupswitchHelper(Instruction switchInstr, RegisterOperand reg, BasicBlock defaultBB, IR ir, BasicBlock curBlock, int low, int high, int min, int max)` Helper function to generate the binary search tree for a lookupswitch bytecode
`(package private) static Instruction`	`DynamicTypeCheckExpansion.arrayStoreCheck(Instruction s, IR ir, boolean couldBeNull)` Expand an object array store check into the LIR sequence that implements it.
`(package private) static Instruction`	`ConvertToLowLevelIR.callHelper(Instruction v, IR ir)` Helper method for call expansion.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.checkcast(Instruction s, IR ir)` Expand a checkcast instruction into the LIR sequence that implements the dynamic type check, raising a ClassCastException when the type check fails.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.checkcastNotNull(Instruction s, IR ir)` Expand a checkcast instruction into the LIR sequence that implements the dynamic type check, raising a ClassCastException when the type check fails.
`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.
`static void`	`ConvertToLowLevelIR.doArrayLoad(Instruction s, IR ir, Operator op, int logwidth)` Expand an array load.
`static void`	`ConvertToLowLevelIR.doArrayStore(Instruction s, IR ir, Operator op, int logwidth)` Expand an array store.
`static void`	`ConvertToLowLevelIR.expandSysCallTarget(Instruction s, IR ir)` Expand symbolic SysCall target into a chain of loads from the bootrecord to the desired target address.
`private static BasicBlock`	`DynamicTypeCheckExpansion.fallThroughBB(Instruction s, IR ir)`
`private static Instruction`	`DynamicTypeCheckExpansion.generateBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, BasicBlock trueBlock, BasicBlock falseBlock, RegisterOperand oldGuard, BranchProfileOperand falseProb)` Generate a branching dynamic type check.
`private static Instruction`	`DynamicTypeCheckExpansion.generateValueProducingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result)` Generate a value-producing dynamic type check.
`static RegisterOperand`	`ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field)` Load an instance field.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field, Operand guard)` Load an instance field.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getInstanceMethod(Instruction s, IR ir, Operand tib, RVMMethod method)` Get an instance method from a TIB
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.getSpecialMethod(Instruction s, IR ir, int smid)` support for direct call to specialized method.
`static RegisterOperand`	`ConvertToLowLevelIR.getStatic(Instruction s, IR ir, RVMField field)` Load a static field.
`(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
`private void`	`ExpandRuntimeServices.inline(Instruction inst, IR ir)` Inline a call instruction
`private void`	`ExpandRuntimeServices.inline(Instruction inst, IR ir, boolean noCalleeExceptions)` Inline a call instruction
`static RegisterOperand`	`ConvertToLowLevelIR.insertBinary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand o2)` Insert a binary instruction before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertGuardedUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand guard)` Insert a guarded unary instruction before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, LocationOperand loc, Operand guard)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, Operand guard)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Operand offset, LocationOperand loc, Operand guard)` Insert a load off before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Offset offset)` Insert a load off the JTOC before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Operand offset)` Insert a load off the JTOC before s in the instruction stream.
`(package private) static RegisterOperand`	`ConvertToLowLevelIR.InsertUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1)` Insert a unary instruction before s in the instruction stream.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.instanceOf(Instruction s, IR ir)` Expand an instanceof instruction into the LIR sequence that implements the dynamic type check.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.instanceOfNotNull(Instruction s, IR ir)` Expand an instanceof instruction into the LIR sequence that implements the dynamic type check.
`(package private) static Instruction`	`ConvertToLowLevelIR.lookup(Instruction switchInstr, IR ir)` Expand a lookupswitch.
`(package private) static Instruction`	`DynamicTypeCheckExpansion.mustImplementInterface(Instruction s, IR ir)` Expand a checkcastInterface instruction into the LIR sequence that implements the dynamic type check, raising an IncompataibleClassChangeError if the type check fails.
`private void`	`ExpandRuntimeServices.primitiveArrayStoreHelper(RVMMethod target, Instruction inst, Instruction next, IR ir)` Helper method to generate call to primitive arrayStore write barrier
`private void`	`ExpandRuntimeServices.primitiveObjectFieldStoreHelper(RVMMethod target, Instruction inst, Instruction next, IR ir, FieldReference fieldRef)` Helper method to generate call to primitive putfield write barrier
`private static Instruction`	`ConvertToLowLevelIR.resolveMember(Instruction s, IR ir)` Generate the code to resolve a member (field/method) reference.
`(package private) static Instruction`	`ConvertToLowLevelIR.tableswitch(Instruction s, IR ir)` Expand a tableswitch.

Uses of Instruction in org.jikesrvm.compilers.opt.inlining

Fields in org.jikesrvm.compilers.opt.inlining declared as Instruction
`private Instruction`	`CompilationState.call`
`(package private) Instruction`	`InlineSequence.callSite` We need more detailed information of call site than bcIndex.

Methods in org.jikesrvm.compilers.opt.inlining that return Instruction
`Instruction`	`CompilationState.getCallInstruction()` Return the call instruction being considered for inlining
`Instruction`	`InlineSequence.getCallSite()`

Methods in org.jikesrvm.compilers.opt.inlining with parameters of type Instruction
`static GenerationContext`	`Inliner.execute(InlineDecision inlDec, GenerationContext parent, ExceptionHandlerBasicBlockBag ebag, Instruction callSite)` Return a generation context that represents the execution of inlDec in the context for the call instruction callSite.
`static void`	`Inliner.execute(InlineDecision inlDec, IR ir, Instruction callSite)` Execute an inlining decision inlDec for the CALL instruction callSite that is contained in ir.

Constructors in org.jikesrvm.compilers.opt.inlining with parameters of type Instruction
`CompilationState(Instruction call, boolean isExtant, OptOptions options, CompiledMethod cm, int realBCI)`
`InlineSequence(NormalMethod method, InlineSequence caller, Instruction callsite)` Constructs a new inline sequence operand.

Uses of Instruction in org.jikesrvm.compilers.opt.instrsched

Fields in org.jikesrvm.compilers.opt.instrsched declared as Instruction
`private Instruction`	`DefaultPriority.i`
`Instruction`	`Scheduler.InstructionBucket.instruction` The instruction in the current slot.

Methods in org.jikesrvm.compilers.opt.instrsched that return Instruction
`Instruction`	`DefaultPriority.next()` Returns the next instruction in sequence
`abstract Instruction`	`Priority.next()` Returns the next instruction in sequence
`Instruction`	`Priority.nextElement()` Returns the next instruction in sequence

Methods in org.jikesrvm.compilers.opt.instrsched with parameters of type Instruction
`private int`	`Scheduler.computeEarliestTime(Instruction i)` Compute earliest scheduling time for an instruction.
`static void`	`SchedulingInfo.createInfo(Instruction i)` Initializes scheduling information for instruction.
`static int`	`SchedulingInfo.getAlt(Instruction i)` Returns scheduling alternative for instruction.
`static int`	`SchedulingInfo.getCriticalPath(Instruction i)` Returns critical path length for instruction.
`static int`	`SchedulingInfo.getEarliestTime(Instruction i)` Returns earliest scheduling time for instruction.
`private DepGraphNode`	`Scheduler.getGraphNode(Instruction i)` Return corresponding graph node for instruction.
`static SchedulingInfo`	`SchedulingInfo.getInfo(Instruction i)` Returns scheduling information for instruction.
`static int`	`SchedulingInfo.getTime(Instruction i)` Returns scheduling time for instruction.
`static void`	`Scheduler.InstructionBucket.insert(Scheduler.InstructionBucket[] pool, Instruction i)` Insert the instruction into a given slot (based on its scheduling time).
`static boolean`	`SchedulingInfo.isScheduled(Instruction i)` Checks whether instruction is scheduled.
`static void`	`SchedulingInfo.removeInfo(Instruction i)` Removes scheduling information from instruction.
`static void`	`SchedulingInfo.resetInfo(Instruction i)` Clears scheduling information of instruction.
`boolean`	`ResourceMap.schedule(Instruction i, int time)` Reserves resources for given instruction at given time.
`static void`	`SchedulingInfo.setCriticalPath(Instruction i, int cp)` Sets critical path length for instruction.
`static void`	`SchedulingInfo.setEarliestTime(Instruction i, int etime)` Sets earliest scheduling time for instruction.
`private void`	`Scheduler.setGraphNode(Instruction i, DepGraphNode n)` Set corresponding graph node for instruction.
`static void`	`SchedulingInfo.setInfo(Instruction i, int alt, int time)` Adds scheduling information to instruction.
`void`	`ResourceMap.unschedule(Instruction i)` Frees resources for given instruction.

Constructors in org.jikesrvm.compilers.opt.instrsched with parameters of type Instruction
`Scheduler.InstructionBucket(Instruction i)` Create a list element containing the instruction.

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

Fields in org.jikesrvm.compilers.opt.ir declared as Instruction
`(package private) Instruction`	`BasicBlock.end` Last instruction of the basic block (BBEND).
`private Instruction`	`GCIRMapElement.inst` The instruction, i.e., GC point
`private Instruction`	`IREnumeration.AllDefsEnum.instr` Defining instruction
`private Instruction`	`IREnumeration.AllUsesEnum.instr` Defining instruction
`protected Instruction`	`Instruction.BASE_OE.instr`
`private Instruction`	`IREnumeration.AllInstructionsEnum.labelInstruction` The label instruction for the basic block - the label is special as we want it to appear in the enumeration before the implicit SSA instructions
`private Instruction`	`Instruction.next` The next instruction in the intra-basic-block list of instructions, will be null if no such instruction exists.
`private Instruction`	`Instruction.prev` The previous instruction in the intra-basic-block list of instructions, will be null if no such instruction exists.
`(package private) Instruction`	`BasicBlock.start` First instruction of the basic block (LABEL).

Fields in org.jikesrvm.compilers.opt.ir with type parameters of type Instruction
`private Iterator<Instruction>`	`IREnumeration.AllInstructionsEnum.implicitInstructions` An enumeration of the implicit instructions in the IR for a basic block.

Methods in org.jikesrvm.compilers.opt.ir that return Instruction
`Instruction`	`Instruction.copyWithoutLinks()` Create a copy of this instruction.
`static Instruction`	`IRTools.CPOS(Instruction src, Instruction dst)` Copy the position information from the source instruction to the destination instruction, returning the source instruction.
`static Instruction`	`Empty.create(Operator o)` Create an instruction of the Empty instruction format.
`static Instruction`	`MIR_Empty.create(Operator o)` Create an instruction of the MIR_Empty instruction format.
`static Instruction`	`Return.create(Operator o)` Create an instruction of the Return instruction format.
`static Instruction`	`Label.create(Operator o, BasicBlockOperand Block)` Create an instruction of the Label instruction format.
`static Instruction`	`BBend.create(Operator o, BasicBlockOperand Block)` Create an instruction of the BBend instruction format.
`static Instruction`	`Goto.create(Operator o, BranchOperand Target)` Create an instruction of the Goto instruction format.
`static Instruction`	`MIR_Branch.create(Operator o, BranchOperand Target)` Create an instruction of the MIR_Branch instruction format.
`static Instruction`	`MIR_CondBranch.create(Operator o, IA32ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Create an instruction of the MIR_CondBranch instruction format.
`static Instruction`	`MIR_CondBranch2.create(Operator o, IA32ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Create an instruction of the MIR_CondBranch2 instruction format.
`static Instruction`	`MIR_CondBranch2.create(Operator o, IA32ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchProfileOperand BranchProfile2)` Create an instruction of the MIR_CondBranch2 instruction format.
`static Instruction`	`MIR_CondBranch.create(Operator o, IA32ConditionOperand Cond, BranchProfileOperand BranchProfile)` Create an instruction of the MIR_CondBranch instruction format.
`static Instruction`	`MIR_CondBranch2.create(Operator o, IA32ConditionOperand Cond1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Create an instruction of the MIR_CondBranch2 instruction format.
`static Instruction`	`MIR_CondBranch2.create(Operator o, IA32ConditionOperand Cond1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchProfileOperand BranchProfile2)` Create an instruction of the MIR_CondBranch2 instruction format.
`static Instruction`	`OsrPoint.create(Operator o, InlinedOsrTypeInfoOperand InlinedTypeInfo, int numVarOps)` Create an instruction of the OsrPoint instruction format.
`static Instruction`	`Prologue.create(Operator o, int numVarOps)` Create an instruction of the Prologue instruction format.
`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_Nullary.create(Operator o, Operand Result)` Create an instruction of the MIR_Nullary instruction format.
`static Instruction`	`Return.create(Operator o, Operand Val)` Create an instruction of the Return instruction format.
`static Instruction`	`MIR_UnaryAcc.create(Operator o, Operand Result)` Create an instruction of the MIR_UnaryAcc instruction format.
`static Instruction`	`MIR_FSave.create(Operator o, Operand Destination)` Create an instruction of the MIR_FSave instruction format.
`static Instruction`	`CacheOp.create(Operator o, Operand Ref)` Create an instruction of the CacheOp instruction format.
`static Instruction`	`MIR_UnaryNoRes.create(Operator o, Operand Val)` Create an instruction of the MIR_UnaryNoRes instruction format.
`static Instruction`	`Athrow.create(Operator o, Operand Value)` Create an instruction of the Athrow instruction format.
`static Instruction`	`MIR_CacheOp.create(Operator o, Operand Address)` Create an instruction of the MIR_CacheOp 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_Unary.create(Operator o, Operand Result, Operand Val)` Create an instruction of the MIR_Unary 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_XChng.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_XChng instruction format.
`static Instruction`	`MIR_ConvertDW2QW.create(Operator o, Operand Result1, Operand Result2)` Create an instruction of the MIR_ConvertDW2QW 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_Test.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_Test instruction format.
`static Instruction`	`MonitorOp.create(Operator o, Operand Ref, Operand Guard)` Create an instruction of the MonitorOp 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_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`	`MIR_Multiply.create(Operator o, Operand Result1, Operand Result2, Operand Value)` Create an instruction of the MIR_Multiply instruction format.
`static Instruction`	`GuardedSet.create(Operator o, Operand Ref, Operand Val, Operand Guard)` Create an instruction of the GuardedSet 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`	`AStore.create(Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the AStore 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`	`PutField.create(Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the PutField 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`	`OsrBarrier.create(Operator o, OsrTypeInfoOperand TypeInfo, int numVarOps)` Create an instruction of the OsrBarrier instruction format.
`static Instruction`	`Nullary.create(Operator o, RegisterOperand Result)` Create an instruction of the Nullary instruction format.
`static Instruction`	`LowTableSwitch.create(Operator o, RegisterOperand Index, int numVarOps)` Create an instruction of the LowTableSwitch instruction format.
`static Instruction`	`MIR_Lea.create(Operator o, RegisterOperand Result, MemoryOperand Value)` Create an instruction of the MIR_Lea instruction format.
`static Instruction`	`MIR_CompareExchange.create(Operator o, RegisterOperand OldValue, MemoryOperand MemAddr, RegisterOperand NewValue)` Create an instruction of the MIR_CompareExchange instruction format.
`static Instruction`	`Move.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Move instruction format.
`static Instruction`	`NullCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref)` Create an instruction of the NullCheck instruction format.
`static Instruction`	`Unary.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Unary instruction format.
`static Instruction`	`ZeroCheck.create(Operator o, RegisterOperand GuardResult, Operand Value)` Create an instruction of the ZeroCheck instruction format.
`static Instruction`	`GetStatic.create(Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Create an instruction of the GetStatic instruction format.
`static Instruction`	`Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Create an instruction of the Call instruction format.
`static Instruction`	`Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Create an instruction of the Call instruction format.
`static Instruction`	`Binary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Create an instruction of the Binary instruction format.
`static Instruction`	`GuardedUnary.create(Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Create an instruction of the GuardedUnary instruction format.
`static Instruction`	`IfCmp.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Create an instruction of the IfCmp instruction format.
`static Instruction`	`IfCmp2.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Create an instruction of the IfCmp2 instruction format.
`static Instruction`	`BooleanCmp.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Create an instruction of the BooleanCmp instruction format.
`static Instruction`	`CondMove.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Create an instruction of the CondMove instruction format.
`static Instruction`	`TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Create an instruction of the TrapIf instruction format.
`static Instruction`	`MIR_TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Create an instruction of the MIR_TrapIf instruction format.
`static Instruction`	`Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Load instruction format.
`static Instruction`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Prepare instruction format.
`static Instruction`	`ALoad.create(Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the ALoad instruction format.
`static Instruction`	`GetField.create(Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the GetField instruction format.
`static Instruction`	`Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Load instruction format.
`static Instruction`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Prepare instruction format.
`static Instruction`	`StoreCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Create an instruction of the StoreCheck instruction format.
`static Instruction`	`BoundsCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Create an instruction of the BoundsCheck instruction format.
`static Instruction`	`GuardedBinary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Create an instruction of the GuardedBinary instruction format.
`static Instruction`	`Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Create an instruction of the Attempt instruction format.
`static Instruction`	`Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Create an instruction of the Attempt instruction format.
`static Instruction`	`TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Create an instruction of the TypeCheck instruction format.
`static Instruction`	`TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Create an instruction of the TypeCheck instruction format.
`static Instruction`	`MIR_RDTSC.create(Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Create an instruction of the MIR_RDTSC instruction format.
`static Instruction`	`MIR_LowTableSwitch.create(Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Create an instruction of the MIR_LowTableSwitch instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_CompareExchange8B.create(Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Create an instruction of the MIR_CompareExchange8B instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Trap.create(Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Create an instruction of the MIR_Trap instruction format.
`static Instruction`	`Trap.create(Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Create an instruction of the Trap instruction format.
`static Instruction`	`New.create(Operator o, RegisterOperand Result, TypeOperand Type)` Create an instruction of the New instruction format.
`static Instruction`	`Multianewarray.create(Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Create an instruction of the Multianewarray instruction format.
`static Instruction`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Create an instruction of the InstanceOf instruction format.
`static Instruction`	`NewArray.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Create an instruction of the NewArray instruction format.
`static Instruction`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Create an instruction of the InstanceOf instruction format.
`static Instruction`	`Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Create an instruction of the Call instruction format with 0 variable arguments.
`static Instruction`	`Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Create an instruction of the Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Create an instruction of the Call instruction format with 1 variable arguments.
`static Instruction`	`Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Create an instruction of the Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Create an instruction of the Call instruction format with 2 variable arguments.
`static Instruction`	`Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Create an instruction of the Call instruction format with 2 variable arguments.
`static Instruction`	`Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Create an instruction of the Call instruction format with 3 variable arguments.
`static Instruction`	`Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Create an instruction of the Call instruction format with 3 variable arguments.
`static Instruction`	`Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Create an instruction of the Call instruction format with 4 variable arguments.
`static Instruction`	`Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Create an instruction of the Call instruction format with 4 variable arguments.
`static Instruction`	`Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Create an instruction of the Call instruction format with 5 variable arguments.
`static Instruction`	`Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Create an instruction of the Call instruction format with 5 variable arguments.
`static Instruction`	`Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Create an instruction of the Call instruction format with 6 variable arguments.
`static Instruction`	`Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Create an instruction of the Call instruction format with 6 variable arguments.
`static Instruction`	`Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Create an instruction of the Call instruction format with 7 variable arguments.
`static Instruction`	`Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Create an instruction of the Call instruction format with 7 variable arguments.
`static Instruction`	`Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Create an instruction of the Call instruction format with 8 variable arguments.
`static Instruction`	`Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Create an instruction of the Call instruction format with 8 variable arguments.
`Instruction`	`BasicBlock.firstBranchInstruction()` Return the first branch instruction in the block.
`Instruction`	`BasicBlock.firstInstruction()`
`Instruction`	`IR.firstInstructionInCodeOrder()` Return the first instruction with respect to the current code linearization order.
`Instruction`	`BasicBlock.firstRealInstruction()`
`Instruction`	`Register.getFirstDef()` This accessor is only valid when register lists are valid
`Instruction`	`GCIRMapElement.getInstruction()` return the instruction with this entry
`(package private) Instruction`	`Instruction.getNext()` For IR internal use only; general clients should use `nextInstructionInCodeOrder()`.
`(package private) Instruction`	`Instruction.getPrev()` For IR internal use only; General clients should use `prevInstructionInCodeOrder()`.
`Instruction`	`BasicBlock.lastInstruction()`
`Instruction`	`IR.lastInstructionInCodeOrder()` Return the last instruction with respect to the current code linearization order.
`Instruction`	`BasicBlock.lastRealInstruction()`
`Instruction`	`BasicBlock.makeGOTO()` Make a GOTO instruction, branching to the first instruction of this basic block.
`static Instruction`	`Empty.mutate(Instruction i, Operator o)` Mutate the argument instruction into an instruction of the Empty instruction format having the specified operator and operands.
`static Instruction`	`MIR_Empty.mutate(Instruction i, Operator o)` Mutate the argument instruction into an instruction of the MIR_Empty instruction format having the specified operator and operands.
`static Instruction`	`Return.mutate(Instruction i, Operator o)` Mutate the argument instruction into an instruction of the Return instruction format having the specified operator and operands.
`static Instruction`	`Label.mutate(Instruction i, Operator o, BasicBlockOperand Block)` Mutate the argument instruction into an instruction of the Label instruction format having the specified operator and operands.
`static Instruction`	`BBend.mutate(Instruction i, Operator o, BasicBlockOperand Block)` Mutate the argument instruction into an instruction of the BBend instruction format having the specified operator and operands.
`static Instruction`	`Goto.mutate(Instruction i, Operator o, BranchOperand Target)` Mutate the argument instruction into an instruction of the Goto instruction format having the specified operator and operands.
`static Instruction`	`MIR_Branch.mutate(Instruction i, Operator o, BranchOperand Target)` Mutate the argument instruction into an instruction of the MIR_Branch instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch.mutate(Instruction i, Operator o, IA32ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the MIR_CondBranch instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch.mutate(Instruction i, Operator o, IA32ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the MIR_CondBranch instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`OsrPoint.mutate(Instruction i, Operator o, InlinedOsrTypeInfoOperand InlinedTypeInfo, int numVarOps)` Mutate the argument instruction into an instruction of the OsrPoint instruction format having the specified operator and operands.
`static Instruction`	`Prologue.mutate(Instruction i, Operator o, int numVarOps)` Mutate the argument instruction into an instruction of the Prologue instruction format having the specified operator and operands.
`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_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`	`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_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_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`	`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_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`	`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`	`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`	`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_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_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_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_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`	`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_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`	`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_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_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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`OsrBarrier.mutate(Instruction i, Operator o, OsrTypeInfoOperand TypeInfo, int numVarOps)` Mutate the argument instruction into an instruction of the OsrBarrier instruction format having the specified operator and operands.
`static Instruction`	`Nullary.mutate(Instruction i, Operator o, RegisterOperand Result)` Mutate the argument instruction into an instruction of the Nullary instruction format having the specified operator and operands.
`static Instruction`	`LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, int numVarOps)` Mutate the argument instruction into an instruction of the LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Lea.mutate(Instruction i, Operator o, RegisterOperand Result, MemoryOperand Value)` Mutate the argument instruction into an instruction of the MIR_Lea instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange.mutate(Instruction i, Operator o, RegisterOperand OldValue, MemoryOperand MemAddr, RegisterOperand NewValue)` Mutate the argument instruction into an instruction of the MIR_CompareExchange instruction format having the specified operator and operands.
`static Instruction`	`Move.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Move instruction format having the specified operator and operands.
`static Instruction`	`NullCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref)` Mutate the argument instruction into an instruction of the NullCheck instruction format having the specified operator and operands.
`static Instruction`	`Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Unary instruction format having the specified operator and operands.
`static Instruction`	`ZeroCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Value)` Mutate the argument instruction into an instruction of the ZeroCheck instruction format having the specified operator and operands.
`static Instruction`	`GetStatic.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the GetStatic instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Binary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the Binary instruction format having the specified operator and operands.
`static Instruction`	`GuardedUnary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedUnary instruction format having the specified operator and operands.
`static Instruction`	`IfCmp.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the IfCmp instruction format having the specified operator and operands.
`static Instruction`	`IfCmp2.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the IfCmp2 instruction format having the specified operator and operands.
`static Instruction`	`BooleanCmp.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the BooleanCmp instruction format having the specified operator and operands.
`static Instruction`	`CondMove.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Mutate the argument instruction into an instruction of the CondMove instruction format having the specified operator and operands.
`static Instruction`	`TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the TrapIf instruction format having the specified operator and operands.
`static Instruction`	`MIR_TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_TrapIf instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`ALoad.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the ALoad instruction format having the specified operator and operands.
`static Instruction`	`GetField.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the GetField instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`StoreCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the StoreCheck instruction format having the specified operator and operands.
`static Instruction`	`BoundsCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Mutate the argument instruction into an instruction of the BoundsCheck instruction format having the specified operator and operands.
`static Instruction`	`GuardedBinary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedBinary instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`MIR_RDTSC.mutate(Instruction i, Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Mutate the argument instruction into an instruction of the MIR_RDTSC instruction format having the specified operator and operands.
`static Instruction`	`MIR_LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange8B.mutate(Instruction i, Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Mutate the argument instruction into an instruction of the MIR_CompareExchange8B instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
`static Instruction`	`Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the Trap instruction format having the specified operator and operands.
`static Instruction`	`New.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type)` Mutate the argument instruction into an instruction of the New instruction format having the specified operator and operands.
`static Instruction`	`Multianewarray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Mutate the argument instruction into an instruction of the Multianewarray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`NewArray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Mutate the argument instruction into an instruction of the NewArray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`Instruction`	`InstructionEnumeration.next()` Same as nextElement but avoid the need to downcast from Object
`Instruction`	`IREnumeration.AllInstructionsEnum.next()` Get the next instruction in the enumeration
`Instruction`	`IREnumeration.AllInstructionsEnum.nextElement()` Get the next instruction in the enumeration
`Instruction`	`Instruction.nextInstructionInCodeOrder()` Return the next instruction with respect to the current code linearization order.
`static Instruction`	`IRTools.nonPEIGC(Instruction instr)` Mark the parameter as nonGC and nonPEI and return it.
`Instruction`	`Instruction.prevInstructionInCodeOrder()` Return the previous instruction with respect to the current code linearization order.
`Instruction`	`Instruction.remove()` Removal: Remove this from the instruction stream.

Methods in org.jikesrvm.compilers.opt.ir with parameters of type Instruction
`void`	`BasicBlock.appendInstruction(Instruction i)` Append instruction to this basic block by inserting it right before the BBEND instruction in the instruction list.
`void`	`BasicBlock.appendInstructionRespectingTerminalBranch(Instruction i)` Append instruction to this basic block by inserting it right before the BBEND instruction in the instruction list.
`void`	`BasicBlock.appendInstructionRespectingTerminalBranchOrPEI(Instruction i)` Append instruction to this basic block by inserting it right before the BBEND instruction in the instruction list.
`void`	`Instruction.BURS_backdoor_linkWithNext(Instruction other)` Allow BURS a back door into linkWithNext.
`boolean`	`MachineSpecificIR.canFoldNullCheckAndLoad(Instruction s)`
`static boolean`	`MIR_RDTSC.conforms(Instruction i)` InstructionFormat identification method for MIR_RDTSC.
`static boolean`	`IfCmp2.conforms(Instruction i)` InstructionFormat identification method for IfCmp2.
`static boolean`	`Empty.conforms(Instruction i)` InstructionFormat identification method for Empty.
`static boolean`	`Binary.conforms(Instruction i)` InstructionFormat identification method for Binary.
`static boolean`	`MIR_Unary.conforms(Instruction i)` InstructionFormat identification method for MIR_Unary.
`static boolean`	`MIR_Trap.conforms(Instruction i)` InstructionFormat identification method for MIR_Trap.
`static boolean`	`InstanceOf.conforms(Instruction i)` InstructionFormat identification method for InstanceOf.
`static boolean`	`Goto.conforms(Instruction i)` InstructionFormat identification method for Goto.
`static boolean`	`Call.conforms(Instruction i)` InstructionFormat identification method for Call.
`static boolean`	`Multianewarray.conforms(Instruction i)` InstructionFormat identification method for Multianewarray.
`static boolean`	`BranchProfileCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called BranchProfile?
`static boolean`	`ALoad.conforms(Instruction i)` InstructionFormat identification method for ALoad.
`static boolean`	`Move.conforms(Instruction i)` InstructionFormat identification method for Move.
`static boolean`	`MIR_Return.conforms(Instruction i)` InstructionFormat identification method for MIR_Return.
`static boolean`	`MIR_Nullary.conforms(Instruction i)` InstructionFormat identification method for MIR_Nullary.
`static boolean`	`MIR_Empty.conforms(Instruction i)` InstructionFormat identification method for MIR_Empty.
`static boolean`	`Return.conforms(Instruction i)` InstructionFormat identification method for Return.
`static boolean`	`NewArray.conforms(Instruction i)` InstructionFormat identification method for NewArray.
`static boolean`	`MIR_Multiply.conforms(Instruction i)` InstructionFormat identification method for MIR_Multiply.
`static boolean`	`MIR_BinaryAcc.conforms(Instruction i)` InstructionFormat identification method for MIR_BinaryAcc.
`static boolean`	`AStore.conforms(Instruction i)` InstructionFormat identification method for AStore.
`static boolean`	`LocationCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called Location?
`static boolean`	`MIR_DoubleShift.conforms(Instruction i)` InstructionFormat identification method for MIR_DoubleShift.
`static boolean`	`MIR_UnaryAcc.conforms(Instruction i)` InstructionFormat identification method for MIR_UnaryAcc.
`static boolean`	`NullCheck.conforms(Instruction i)` InstructionFormat identification method for NullCheck.
`static boolean`	`MIR_CondBranch.conforms(Instruction i)` InstructionFormat identification method for MIR_CondBranch.
`static boolean`	`GetStatic.conforms(Instruction i)` InstructionFormat identification method for GetStatic.
`static boolean`	`OsrPoint.conforms(Instruction i)` InstructionFormat identification method for OsrPoint.
`static boolean`	`MIR_XChng.conforms(Instruction i)` InstructionFormat identification method for MIR_XChng.
`static boolean`	`TrapIf.conforms(Instruction i)` InstructionFormat identification method for TrapIf.
`static boolean`	`MIR_ConvertDW2QW.conforms(Instruction i)` InstructionFormat identification method for MIR_ConvertDW2QW.
`static boolean`	`InlineGuard.conforms(Instruction i)` InstructionFormat identification method for InlineGuard.
`static boolean`	`StoreCheck.conforms(Instruction i)` InstructionFormat identification method for StoreCheck.
`static boolean`	`GuardedSet.conforms(Instruction i)` InstructionFormat identification method for GuardedSet.
`static boolean`	`BoundsCheck.conforms(Instruction i)` InstructionFormat identification method for BoundsCheck.
`static boolean`	`MIR_CaseLabel.conforms(Instruction i)` InstructionFormat identification method for MIR_CaseLabel.
`static boolean`	`MIR_CompareExchange.conforms(Instruction i)` InstructionFormat identification method for MIR_CompareExchange.
`static boolean`	`TypeCheck.conforms(Instruction i)` InstructionFormat identification method for TypeCheck.
`static boolean`	`MIR_Move.conforms(Instruction i)` InstructionFormat identification method for MIR_Move.
`static boolean`	`OsrBarrier.conforms(Instruction i)` InstructionFormat identification method for OsrBarrier.
`static boolean`	`GuardCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called Guard?
`static boolean`	`BooleanCmp.conforms(Instruction i)` InstructionFormat identification method for BooleanCmp.
`static boolean`	`MIR_Lea.conforms(Instruction i)` InstructionFormat identification method for MIR_Lea.
`static boolean`	`CondMove.conforms(Instruction i)` InstructionFormat identification method for CondMove.
`static boolean`	`Unary.conforms(Instruction i)` InstructionFormat identification method for Unary.
`static boolean`	`MIR_Test.conforms(Instruction i)` InstructionFormat identification method for MIR_Test.
`static boolean`	`Nullary.conforms(Instruction i)` InstructionFormat identification method for Nullary.
`static boolean`	`Store.conforms(Instruction i)` InstructionFormat identification method for Store.
`static boolean`	`GetField.conforms(Instruction i)` InstructionFormat identification method for GetField.
`static boolean`	`InstrumentedCounter.conforms(Instruction i)` InstructionFormat identification method for InstrumentedCounter.
`static boolean`	`MIR_LowTableSwitch.conforms(Instruction i)` InstructionFormat identification method for MIR_LowTableSwitch.
`static boolean`	`MIR_FSave.conforms(Instruction i)` InstructionFormat identification method for MIR_FSave.
`static boolean`	`Label.conforms(Instruction i)` InstructionFormat identification method for Label.
`static boolean`	`LookupSwitch.conforms(Instruction i)` InstructionFormat identification method for LookupSwitch.
`static boolean`	`MIR_CondBranch2.conforms(Instruction i)` InstructionFormat identification method for MIR_CondBranch2.
`static boolean`	`TableSwitch.conforms(Instruction i)` InstructionFormat identification method for TableSwitch.
`static boolean`	`GuardResultCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called GuardResult?
`static boolean`	`Load.conforms(Instruction i)` InstructionFormat identification method for Load.
`static boolean`	`Prepare.conforms(Instruction i)` InstructionFormat identification method for Prepare.
`static boolean`	`CacheOp.conforms(Instruction i)` InstructionFormat identification method for CacheOp.
`static boolean`	`GuardedBinary.conforms(Instruction i)` InstructionFormat identification method for GuardedBinary.
`static boolean`	`MIR_TrapIf.conforms(Instruction i)` InstructionFormat identification method for MIR_TrapIf.
`static boolean`	`MonitorOp.conforms(Instruction i)` InstructionFormat identification method for MonitorOp.
`static boolean`	`MIR_CompareExchange8B.conforms(Instruction i)` InstructionFormat identification method for MIR_CompareExchange8B.
`static boolean`	`PutField.conforms(Instruction i)` InstructionFormat identification method for PutField.
`static boolean`	`BBend.conforms(Instruction i)` InstructionFormat identification method for BBend.
`static boolean`	`New.conforms(Instruction i)` InstructionFormat identification method for New.
`static boolean`	`GuardedUnary.conforms(Instruction i)` InstructionFormat identification method for GuardedUnary.
`static boolean`	`MIR_Call.conforms(Instruction i)` InstructionFormat identification method for MIR_Call.
`static boolean`	`MIR_UnaryNoRes.conforms(Instruction i)` InstructionFormat identification method for MIR_UnaryNoRes.
`static boolean`	`ZeroCheck.conforms(Instruction i)` InstructionFormat identification method for ZeroCheck.
`static boolean`	`IfCmp.conforms(Instruction i)` InstructionFormat identification method for IfCmp.
`static boolean`	`Athrow.conforms(Instruction i)` InstructionFormat identification method for Athrow.
`static boolean`	`Attempt.conforms(Instruction i)` InstructionFormat identification method for Attempt.
`static boolean`	`Prologue.conforms(Instruction i)` InstructionFormat identification method for Prologue.
`static boolean`	`MIR_Divide.conforms(Instruction i)` InstructionFormat identification method for MIR_Divide.
`static boolean`	`PutStatic.conforms(Instruction i)` InstructionFormat identification method for PutStatic.
`static boolean`	`ResultCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called Result?
`static boolean`	`MIR_CondMove.conforms(Instruction i)` InstructionFormat identification method for MIR_CondMove.
`static boolean`	`LowTableSwitch.conforms(Instruction i)` InstructionFormat identification method for LowTableSwitch.
`static boolean`	`Phi.conforms(Instruction i)` InstructionFormat identification method for Phi.
`static boolean`	`MIR_Compare.conforms(Instruction i)` InstructionFormat identification method for MIR_Compare.
`static boolean`	`Trap.conforms(Instruction i)` InstructionFormat identification method for Trap.
`static boolean`	`MIR_CacheOp.conforms(Instruction i)` InstructionFormat identification method for MIR_CacheOp.
`static boolean`	`MIR_Branch.conforms(Instruction i)` InstructionFormat identification method for MIR_Branch.
`static boolean`	`MIR_Set.conforms(Instruction i)` InstructionFormat identification method for MIR_Set.
`void`	`Instruction.copyPosition(Instruction source)` Set the source position description (`bcIndex`, `position`) for this instruction to be the same as the source instruction's source position description.
`static Instruction`	`IRTools.CPOS(Instruction src, Instruction dst)` Copy the position information from the source instruction to the destination instruction, returning the source instruction.
`GCIRMapElement`	`GCIRMapElement.createTwin(Instruction inst)` Create a twin entry: required when the same MIR GC point is split into two instructions, both of which are PEIs after register allocation/GCIRMap creation.
`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?
`static boolean`	`IRTools.definedIn(Register r, Instruction s)` Does instruction s define register r?
`void`	`GCIRMap.delete(Instruction inst)` This method removes an entry in the GCIRMap that is specified by inst.
`protected static void`	`InstructionFormat.fail(Instruction i, String name)` Called to generate a (possibly fatal) error message when it is detected that an InstructionFormat method was invoked on an instruction/operator that does not conform to that format.
`static InstructionEnumeration`	`IREnumeration.forwardIntraBlockIE(Instruction start, Instruction end)` Forward intra basic block instruction enumerations from from start...last inclusive.
`static Operand`	`Call.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`	`Load.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`	`Attempt.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.
`BasicBlockEnumeration`	`BasicBlock.getApplicableExceptionalOut(Instruction instr)` An enumeration of the subset of exceptional out edges that are applicable to the given instruction (assumed to be in instruction in 'this')
`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 BasicBlockOperand`	`Label.getBlock(Instruction i)` Get the operand called Block from the argument instruction.
`static BasicBlockOperand`	`BBend.getBlock(Instruction i)` Get the operand called Block from the argument instruction.
`static BranchProfileOperand`	`BranchProfileCarrier.getBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`MIR_CondBranch.getBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`InlineGuard.getBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`BooleanCmp.getBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`IfCmp.getBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`MIR_LowTableSwitch.getBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`LookupSwitch.getBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`TableSwitch.getBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`LowTableSwitch.getBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`IfCmp2.getBranchProfile1(Instruction i)` Get the operand called BranchProfile1 from the argument instruction.
`static BranchProfileOperand`	`MIR_CondBranch2.getBranchProfile1(Instruction i)` Get the operand called BranchProfile1 from the argument instruction.
`static BranchProfileOperand`	`IfCmp2.getBranchProfile2(Instruction i)` Get the operand called BranchProfile2 from the argument instruction.
`static BranchProfileOperand`	`MIR_CondBranch2.getBranchProfile2(Instruction i)` Get the operand called BranchProfile2 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`	`Store.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`	`Prepare.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`	`MIR_CacheOp.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 BasicBlockOperand`	`Label.getClearBlock(Instruction i)` Get the operand called Block from the argument instruction clearing its instruction pointer.
`static BasicBlockOperand`	`BBend.getClearBlock(Instruction i)` Get the operand called Block from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`BranchProfileCarrier.getClearBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`MIR_CondBranch.getClearBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`InlineGuard.getClearBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`BooleanCmp.getClearBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`IfCmp.getClearBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`MIR_LowTableSwitch.getClearBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`LookupSwitch.getClearBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`TableSwitch.getClearBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`LowTableSwitch.getClearBranchProfile(Instruction i, int k)` Get the k'th operand called BranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`IfCmp2.getClearBranchProfile1(Instruction i)` Get the operand called BranchProfile1 from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`MIR_CondBranch2.getClearBranchProfile1(Instruction i)` Get the operand called BranchProfile1 from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`IfCmp2.getClearBranchProfile2(Instruction i)` Get the operand called BranchProfile2 from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`MIR_CondBranch2.getClearBranchProfile2(Instruction i)` Get the operand called BranchProfile2 from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_CondBranch.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static ConditionOperand`	`TrapIf.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static ConditionOperand`	`BooleanCmp.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static ConditionOperand`	`CondMove.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_TrapIf.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static ConditionOperand`	`IfCmp.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_CondMove.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_Set.getClearCond(Instruction i)` Get the operand called Cond from the argument instruction clearing its instruction pointer.
`static ConditionOperand`	`IfCmp2.getClearCond1(Instruction i)` Get the operand called Cond1 from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_CondBranch2.getClearCond1(Instruction i)` Get the operand called Cond1 from the argument instruction clearing its instruction pointer.
`static ConditionOperand`	`IfCmp2.getClearCond2(Instruction i)` Get the operand called Cond2 from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_CondBranch2.getClearCond2(Instruction i)` Get the operand called Cond2 from the argument instruction clearing its instruction pointer.
`static IntConstantOperand`	`InstrumentedCounter.getClearData(Instruction i)` Get the operand called Data from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`LookupSwitch.getClearDefault(Instruction i)` Get the operand called Default from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`TableSwitch.getClearDefault(Instruction i)` Get the operand called Default from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`LookupSwitch.getClearDefaultBranchProfile(Instruction i)` Get the operand called DefaultBranchProfile from the argument instruction clearing its instruction pointer.
`static BranchProfileOperand`	`TableSwitch.getClearDefaultBranchProfile(Instruction i)` Get the operand called DefaultBranchProfile from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_RDTSC.getClearDest1(Instruction i)` Get the operand called Dest1 from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_RDTSC.getClearDest2(Instruction i)` Get the operand called Dest2 from the argument instruction clearing its instruction pointer.
`static 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 RegisterOperand`	`Prologue.getClearFormal(Instruction i, int k)` Get the k'th operand called Formal 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`	`InstanceOf.getClearGuard(Instruction i)` Get the operand called Guard 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`	`ALoad.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`	`InlineGuard.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`	`GuardedSet.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`	`GuardCarrier.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`	`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`	`Prepare.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`	`PutField.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`	`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 RegisterOperand`	`IfCmp2.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`NullCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`TrapIf.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`StoreCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`BoundsCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardResultCarrier.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_TrapIf.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ZeroCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`IfCmp.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static IntConstantOperand`	`TableSwitch.getClearHigh(Instruction i)` Get the operand called High 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`	`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`	`BoundsCheck.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static IntConstantOperand`	`MIR_CaseLabel.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static IntConstantOperand`	`InstrumentedCounter.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_LowTableSwitch.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`LowTableSwitch.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static InlinedOsrTypeInfoOperand`	`OsrPoint.getClearInlinedTypeInfo(Instruction i)` Get the operand called InlinedTypeInfo from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`ALoad.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`AStore.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`LocationCarrier.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`GetStatic.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`Store.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`GetField.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`Load.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`Prepare.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`PutField.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`Attempt.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static LocationOperand`	`PutStatic.getClearLocation(Instruction i)` Get the operand called Location from the argument instruction clearing its instruction pointer.
`static IntConstantOperand`	`TableSwitch.getClearLow(Instruction i)` Get the operand called Low from the argument instruction clearing its instruction pointer.
`static IntConstantOperand`	`LookupSwitch.getClearMatch(Instruction i, int k)` Get the k'th operand called Match from the argument instruction clearing its instruction pointer.
`static MemoryOperand`	`MIR_CompareExchange.getClearMemAddr(Instruction i)` Get the operand called MemAddr from the argument instruction clearing its instruction pointer.
`static MemoryOperand`	`MIR_CompareExchange8B.getClearMemAddr(Instruction i)` Get the operand called MemAddr from the argument instruction clearing its instruction pointer.
`static MethodOperand`	`Call.getClearMethod(Instruction i)` Get the operand called Method from the argument instruction clearing its instruction pointer.
`static MethodOperand`	`MIR_Call.getClearMethod(Instruction i)` Get the operand called Method from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_LowTableSwitch.getClearMethodStart(Instruction i)` Get the operand called MethodStart from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange.getClearNewValue(Instruction i)` Get the operand called NewValue from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearNewValue(Instruction i)` Get the operand called NewValue from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearNewValueHigh(Instruction i)` Get the operand called NewValueHigh from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearNewValueLow(Instruction i)` Get the operand called NewValueLow from the argument instruction clearing its instruction pointer.
`static Operand`	`GetStatic.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`	`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`	`Prepare.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`	`PutStatic.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange.getClearOldValue(Instruction i)` Get the operand called OldValue from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearOldValue(Instruction i)` Get the operand called OldValue from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearOldValueHigh(Instruction i)` Get the operand called OldValueHigh from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_CompareExchange8B.getClearOldValueLow(Instruction i)` Get the operand called OldValueLow from the argument instruction clearing its instruction pointer.
`static 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 IntConstantOperand`	`MIR_Return.getClearPopBytes(Instruction i)` Get the operand called PopBytes from the argument instruction clearing its instruction pointer.
`static BasicBlockOperand`	`Phi.getClearPred(Instruction i, int k)` Get the k'th operand called Pred 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`	`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`	`GuardedSet.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`	`CacheOp.getClearRef(Instruction i)` Get the operand called Ref 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`	`PutField.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Binary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Unary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`InstanceOf.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Call.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Multianewarray.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ALoad.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Move.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Nullary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`NewArray.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static 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_UnaryAcc.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GetStatic.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`TypeCheck.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Move.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`BooleanCmp.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Lea.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`CondMove.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Unary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Nullary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GetField.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Load.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Prepare.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardedBinary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`New.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardedUnary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Call.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Attempt.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ResultCarrier.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CondMove.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_Set.getClearResult(Instruction i)` Get the operand called Result 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.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.getClearResult2(Instruction i)` Get the operand called Result2 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 RegisterOperand`	`MIR_Call.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`	`NewArray.getClearSize(Instruction i)` Get the operand called Size from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_DoubleShift.getClearSource(Instruction i)` Get the operand called Source from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`Goto.getClearTarget(Instruction i)` Get the operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`MIR_CondBranch.getClearTarget(Instruction i)` Get the operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`InlineGuard.getClearTarget(Instruction i)` Get the operand called Target 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 BranchOperand`	`IfCmp.getClearTarget(Instruction i)` Get the operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`MIR_Branch.getClearTarget(Instruction i)` Get the operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`MIR_LowTableSwitch.getClearTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`LookupSwitch.getClearTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`TableSwitch.getClearTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`LowTableSwitch.getClearTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`IfCmp2.getClearTarget1(Instruction i)` Get the operand called Target1 from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`MIR_CondBranch2.getClearTarget1(Instruction i)` Get the operand called Target1 from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`IfCmp2.getClearTarget2(Instruction i)` Get the operand called Target2 from the argument instruction clearing its instruction pointer.
`static BranchOperand`	`MIR_CondBranch2.getClearTarget2(Instruction i)` Get the operand called Target2 from the argument instruction clearing its instruction pointer.
`static TrapCodeOperand`	`TrapIf.getClearTCode(Instruction i)` Get the operand called TCode from the argument instruction clearing its instruction pointer.
`static TrapCodeOperand`	`Trap.getClearTCode(Instruction i)` Get the operand called TCode from the argument instruction clearing its instruction pointer.
`static TrapCodeOperand`	`MIR_Trap.getClearTrapCode(Instruction i)` Get the operand called TrapCode from the argument instruction clearing its instruction pointer.
`static TrapCodeOperand`	`MIR_TrapIf.getClearTrapCode(Instruction i)` Get the operand called TrapCode 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 TypeOperand`	`InstanceOf.getClearType(Instruction i)` Get the operand called Type from the argument instruction clearing its instruction pointer.
`static TypeOperand`	`Multianewarray.getClearType(Instruction i)` Get the operand called Type from the argument instruction clearing its instruction pointer.
`static TypeOperand`	`NewArray.getClearType(Instruction i)` Get the operand called Type from the argument instruction clearing its instruction pointer.
`static TypeOperand`	`TypeCheck.getClearType(Instruction i)` Get the operand called Type from the argument instruction clearing its instruction pointer.
`static TypeOperand`	`New.getClearType(Instruction i)` Get the operand called Type from the argument instruction clearing its instruction pointer.
`static OsrTypeInfoOperand`	`OsrBarrier.getClearTypeInfo(Instruction i)` Get the operand called TypeInfo 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.getClearUnknown1(Instruction i)` Get the operand called Unknown1 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`	`TableSwitch.getClearUnknown2(Instruction i)` Get the operand called Unknown2 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`	`Move.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`	`Return.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`	`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`	`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`	`IfCmp2.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_XChng.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`	`BooleanCmp.getClearVal1(Instruction i)` Get the operand called Val1 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`	`MIR_Test.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`	`MIR_TrapIf.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`	`MIR_Compare.getClearVal1(Instruction i)` Get the operand called Val1 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`	`Binary.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`	`MIR_XChng.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`	`BooleanCmp.getClearVal2(Instruction i)` Get the operand called Val2 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`	`MIR_Test.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_TrapIf.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`	`MIR_Compare.getClearVal2(Instruction i)` Get the operand called Val2 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`	`MIR_BinaryAcc.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`	`InlineGuard.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 MemoryOperand`	`MIR_Lea.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`	`LookupSwitch.getClearValue(Instruction i)` Get the operand called Value 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`	`PutField.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`	`Athrow.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`	`PutStatic.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`	`Phi.getClearValue(Instruction i, int k)` Get the k'th operand called Value from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_CondBranch.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static ConditionOperand`	`TrapIf.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static ConditionOperand`	`BooleanCmp.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static ConditionOperand`	`CondMove.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static IA32ConditionOperand`	`MIR_TrapIf.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static ConditionOperand`	`IfCmp.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static IA32ConditionOperand`	`MIR_CondMove.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static IA32ConditionOperand`	`MIR_Set.getCond(Instruction i)` Get the operand called Cond from the argument instruction.
`static ConditionOperand`	`IfCmp2.getCond1(Instruction i)` Get the operand called Cond1 from the argument instruction.
`static IA32ConditionOperand`	`MIR_CondBranch2.getCond1(Instruction i)` Get the operand called Cond1 from the argument instruction.
`static ConditionOperand`	`IfCmp2.getCond2(Instruction i)` Get the operand called Cond2 from the argument instruction.
`static IA32ConditionOperand`	`MIR_CondBranch2.getCond2(Instruction i)` Get the operand called Cond2 from the argument instruction.
`static IntConstantOperand`	`InstrumentedCounter.getData(Instruction i)` Get the operand called Data from the argument instruction.
`static BranchOperand`	`LookupSwitch.getDefault(Instruction i)` Get the operand called Default from the argument instruction.
`static BranchOperand`	`TableSwitch.getDefault(Instruction i)` Get the operand called Default from the argument instruction.
`static BranchProfileOperand`	`LookupSwitch.getDefaultBranchProfile(Instruction i)` Get the operand called DefaultBranchProfile from the argument instruction.
`static BranchProfileOperand`	`TableSwitch.getDefaultBranchProfile(Instruction i)` Get the operand called DefaultBranchProfile from the argument instruction.
`static RegisterOperand`	`MIR_RDTSC.getDest1(Instruction i)` Get the operand called Dest1 from the argument instruction.
`static RegisterOperand`	`MIR_RDTSC.getDest2(Instruction i)` Get the operand called Dest2 from the argument instruction.
`static 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 RegisterOperand`	`Prologue.getFormal(Instruction i, int k)` Get the k'th operand called Formal from the argument instruction.
`static Operand`	`InlineGuard.getGoal(Instruction i)` Get the operand called Goal from the argument instruction.
`static Operand`	`InstanceOf.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Call.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`	`AStore.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`	`StoreCheck.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`	`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`	`GuardCarrier.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`	`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`	`Prepare.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`	`PutField.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`	`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 RegisterOperand`	`IfCmp2.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`NullCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`TrapIf.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`StoreCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`BoundsCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`GuardResultCarrier.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_TrapIf.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`ZeroCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`IfCmp.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static IntConstantOperand`	`TableSwitch.getHigh(Instruction i)` Get the operand called High from the argument instruction.
`static Operand`	`InstrumentedCounter.getIncrement(Instruction i)` Get the operand called Increment 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`	`BoundsCheck.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static IntConstantOperand`	`MIR_CaseLabel.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static IntConstantOperand`	`InstrumentedCounter.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static RegisterOperand`	`MIR_LowTableSwitch.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static RegisterOperand`	`LowTableSwitch.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static InlinedOsrTypeInfoOperand`	`OsrPoint.getInlinedTypeInfo(Instruction i)` Get the operand called InlinedTypeInfo from the argument instruction.
`static LocationOperand`	`ALoad.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`AStore.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`LocationCarrier.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`GetStatic.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`Store.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`GetField.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`Load.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`Prepare.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`PutField.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`Attempt.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`PutStatic.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static IntConstantOperand`	`TableSwitch.getLow(Instruction i)` Get the operand called Low from the argument instruction.
`static IntConstantOperand`	`LookupSwitch.getMatch(Instruction i, int k)` Get the k'th operand called Match from the argument instruction.
`static MemoryOperand`	`MIR_CompareExchange.getMemAddr(Instruction i)` Get the operand called MemAddr from the argument instruction.
`static MemoryOperand`	`MIR_CompareExchange8B.getMemAddr(Instruction i)` Get the operand called MemAddr from the argument instruction.
`static MethodOperand`	`Call.getMethod(Instruction i)` Get the operand called Method from the argument instruction.
`static MethodOperand`	`MIR_Call.getMethod(Instruction i)` Get the operand called Method from the argument instruction.
`static RegisterOperand`	`MIR_LowTableSwitch.getMethodStart(Instruction i)` Get the operand called MethodStart from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange.getNewValue(Instruction i)` Get the operand called NewValue from the argument instruction.
`static Operand`	`Attempt.getNewValue(Instruction i)` Get the operand called NewValue from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getNewValueHigh(Instruction i)` Get the operand called NewValueHigh from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getNewValueLow(Instruction i)` Get the operand called NewValueLow from the argument instruction.
`static int`	`MIR_LowTableSwitch.getNumberOfBranchProfiles(Instruction i)` How many variable-length operands called BranchProfiles does the argument instruction have?
`static int`	`LookupSwitch.getNumberOfBranchProfiles(Instruction i)` How many variable-length operands called BranchProfiles does the argument instruction have?
`static int`	`TableSwitch.getNumberOfBranchProfiles(Instruction i)` How many variable-length operands called BranchProfiles does the argument instruction have?
`static int`	`LowTableSwitch.getNumberOfBranchProfiles(Instruction i)` How many variable-length operands called BranchProfiles does the argument instruction have?
`static int`	`Multianewarray.getNumberOfDimensions(Instruction i)` How many variable-length operands called Dimensions does the argument instruction have?
`static int`	`OsrPoint.getNumberOfElements(Instruction i)` How many variable-length operands called Elements does the argument instruction have?
`static int`	`OsrBarrier.getNumberOfElements(Instruction i)` How many variable-length operands called Elements does the argument instruction have?
`static int`	`Prologue.getNumberOfFormals(Instruction i)` How many variable-length operands called Formals does the argument instruction have?
`static int`	`LookupSwitch.getNumberOfMatches(Instruction i)` How many variable-length operands called Matches does the argument instruction have?
`static int`	`Call.getNumberOfParams(Instruction i)` How many variable-length operands called Params does the argument instruction have?
`static int`	`MIR_Call.getNumberOfParams(Instruction i)` How many variable-length operands called Params does the argument instruction have?
`static int`	`Phi.getNumberOfPreds(Instruction i)` How many variable-length operands called Preds does the argument instruction have?
`static int`	`MIR_LowTableSwitch.getNumberOfTargets(Instruction i)` How many variable-length operands called Targets does the argument instruction have?
`static int`	`LookupSwitch.getNumberOfTargets(Instruction i)` How many variable-length operands called Targets does the argument instruction have?
`static int`	`TableSwitch.getNumberOfTargets(Instruction i)` How many variable-length operands called Targets does the argument instruction have?
`static int`	`LowTableSwitch.getNumberOfTargets(Instruction i)` How many variable-length operands called Targets does the argument instruction have?
`static int`	`Phi.getNumberOfValues(Instruction i)` How many variable-length operands called Values does the argument instruction have?
`static Operand`	`GetStatic.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`	`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`	`Prepare.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`	`PutStatic.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange.getOldValue(Instruction i)` Get the operand called OldValue from the argument instruction.
`static Operand`	`Attempt.getOldValue(Instruction i)` Get the operand called OldValue from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getOldValueHigh(Instruction i)` Get the operand called OldValueHigh from the argument instruction.
`static RegisterOperand`	`MIR_CompareExchange8B.getOldValueLow(Instruction i)` Get the operand called OldValueLow from the argument instruction.
`static 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 IntConstantOperand`	`MIR_Return.getPopBytes(Instruction i)` Get the operand called PopBytes from the argument instruction.
`static BasicBlockOperand`	`Phi.getPred(Instruction i, int k)` Get the k'th operand called Pred from the argument instruction.
`static Operand`	`InstanceOf.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`	`GuardedSet.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`	`CacheOp.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`MonitorOp.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 RegisterOperand`	`Binary.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 RegisterOperand`	`InstanceOf.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Call.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Multianewarray.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`ALoad.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Move.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Nullary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`NewArray.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static 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_UnaryAcc.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GetStatic.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`TypeCheck.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Move.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`BooleanCmp.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Lea.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`CondMove.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Unary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Nullary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GetField.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Load.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Prepare.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GuardedBinary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`New.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GuardedUnary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Call.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Attempt.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`ResultCarrier.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_CondMove.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_Set.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Multiply.getResult1(Instruction i)` Get the operand called Result1 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.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`MIR_ConvertDW2QW.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static RegisterOperand`	`MIR_Call.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`	`NewArray.getSize(Instruction i)` Get the operand called Size from the argument instruction.
`static RegisterOperand`	`MIR_DoubleShift.getSource(Instruction i)` Get the operand called Source from the argument instruction.
`static BranchOperand`	`Goto.getTarget(Instruction i)` Get the operand called Target from the argument instruction.
`static BranchOperand`	`MIR_CondBranch.getTarget(Instruction i)` Get the operand called Target from the argument instruction.
`static BranchOperand`	`InlineGuard.getTarget(Instruction i)` Get the operand called Target 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 BranchOperand`	`IfCmp.getTarget(Instruction i)` Get the operand called Target from the argument instruction.
`static BranchOperand`	`MIR_Branch.getTarget(Instruction i)` Get the operand called Target from the argument instruction.
`static BranchOperand`	`MIR_LowTableSwitch.getTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction.
`static BranchOperand`	`LookupSwitch.getTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction.
`static BranchOperand`	`TableSwitch.getTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction.
`static BranchOperand`	`LowTableSwitch.getTarget(Instruction i, int k)` Get the k'th operand called Target from the argument instruction.
`static BranchOperand`	`IfCmp2.getTarget1(Instruction i)` Get the operand called Target1 from the argument instruction.
`static BranchOperand`	`MIR_CondBranch2.getTarget1(Instruction i)` Get the operand called Target1 from the argument instruction.
`static BranchOperand`	`IfCmp2.getTarget2(Instruction i)` Get the operand called Target2 from the argument instruction.
`static BranchOperand`	`MIR_CondBranch2.getTarget2(Instruction i)` Get the operand called Target2 from the argument instruction.
`static TrapCodeOperand`	`TrapIf.getTCode(Instruction i)` Get the operand called TCode from the argument instruction.
`static TrapCodeOperand`	`Trap.getTCode(Instruction i)` Get the operand called TCode from the argument instruction.
`static TrapCodeOperand`	`MIR_Trap.getTrapCode(Instruction i)` Get the operand called TrapCode from the argument instruction.
`static TrapCodeOperand`	`MIR_TrapIf.getTrapCode(Instruction i)` Get the operand called TrapCode from the argument instruction.
`static Operand`	`CondMove.getTrueValue(Instruction i)` Get the operand called TrueValue from the argument instruction.
`static TypeOperand`	`InstanceOf.getType(Instruction i)` Get the operand called Type from the argument instruction.
`static TypeOperand`	`Multianewarray.getType(Instruction i)` Get the operand called Type from the argument instruction.
`static TypeOperand`	`NewArray.getType(Instruction i)` Get the operand called Type from the argument instruction.
`static TypeOperand`	`TypeCheck.getType(Instruction i)` Get the operand called Type from the argument instruction.
`static TypeOperand`	`New.getType(Instruction i)` Get the operand called Type from the argument instruction.
`static OsrTypeInfoOperand`	`OsrBarrier.getTypeInfo(Instruction i)` Get the operand called TypeInfo from the argument instruction.
`static Operand`	`LookupSwitch.getUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction.
`static Operand`	`TableSwitch.getUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction.
`static Operand`	`LookupSwitch.getUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction.
`static Operand`	`TableSwitch.getUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction.
`static Operand`	`MIR_Unary.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_Return.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`	`StoreCheck.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`	`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`	`IfCmp2.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_XChng.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`	`BooleanCmp.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`CondMove.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`	`GuardedBinary.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`	`IfCmp.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`	`IfCmp2.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_Return.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`	`TrapIf.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`	`CondMove.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`	`GuardedBinary.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`	`IfCmp.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_Multiply.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`	`AStore.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`	`MIR_Move.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static MemoryOperand`	`MIR_Lea.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`	`LookupSwitch.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`TableSwitch.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`	`ZeroCheck.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`	`MIR_Divide.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`	`MIR_CondMove.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.
`static boolean`	`Call.hasAddress(Instruction i)` Does the argument instruction have a non-null operand named Address?
`static boolean`	`Store.hasAddress(Instruction i)` Does the argument instruction have a non-null operand named Address?
`static boolean`	`Load.hasAddress(Instruction i)` Does the argument instruction have a non-null operand named Address?
`static boolean`	`Prepare.hasAddress(Instruction i)` Does the argument instruction have a non-null operand named Address?
`static boolean`	`Attempt.hasAddress(Instruction i)` Does the argument instruction have a non-null operand named Address?
`static boolean`	`MIR_CacheOp.hasAddress(Instruction i)` Does the argument instruction have a non-null operand named Address?
`boolean`	`BasicBlock.hasApplicableExceptionalOut(Instruction instr)` Are there any exceptional out edges that are applicable to the given instruction (assumed to be in instruction in 'this')
`static boolean`	`ALoad.hasArray(Instruction i)` Does the argument instruction have a non-null operand named Array?
`static boolean`	`AStore.hasArray(Instruction i)` Does the argument instruction have a non-null operand named Array?
`static boolean`	`MIR_DoubleShift.hasBitsToShift(Instruction i)` Does the argument instruction have a non-null operand named BitsToShift?
`static boolean`	`Label.hasBlock(Instruction i)` Does the argument instruction have a non-null operand named Block?
`static boolean`	`BBend.hasBlock(Instruction i)` Does the argument instruction have a non-null operand named Block?
`static boolean`	`BranchProfileCarrier.hasBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile?
`static boolean`	`MIR_CondBranch.hasBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile?
`static boolean`	`InlineGuard.hasBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile?
`static boolean`	`BooleanCmp.hasBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile?
`static boolean`	`IfCmp.hasBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile?
`static boolean`	`MIR_LowTableSwitch.hasBranchProfile(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named BranchProfile?
`static boolean`	`LookupSwitch.hasBranchProfile(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named BranchProfile?
`static boolean`	`TableSwitch.hasBranchProfile(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named BranchProfile?
`static boolean`	`LowTableSwitch.hasBranchProfile(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named BranchProfile?
`static boolean`	`IfCmp2.hasBranchProfile1(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile1?
`static boolean`	`MIR_CondBranch2.hasBranchProfile1(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile1?
`static boolean`	`IfCmp2.hasBranchProfile2(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile2?
`static boolean`	`MIR_CondBranch2.hasBranchProfile2(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile2?
`static boolean`	`MIR_LowTableSwitch.hasBranchProfiles(Instruction i)` Does the argument instruction have any operands named BranchProfile?
`static boolean`	`LookupSwitch.hasBranchProfiles(Instruction i)` Does the argument instruction have any operands named BranchProfile?
`static boolean`	`TableSwitch.hasBranchProfiles(Instruction i)` Does the argument instruction have any operands named BranchProfile?
`static boolean`	`LowTableSwitch.hasBranchProfiles(Instruction i)` Does the argument instruction have any operands named BranchProfile?
`static boolean`	`MIR_CondBranch.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`TrapIf.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`BooleanCmp.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`CondMove.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`MIR_TrapIf.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`IfCmp.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`MIR_CondMove.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`MIR_Set.hasCond(Instruction i)` Does the argument instruction have a non-null operand named Cond?
`static boolean`	`IfCmp2.hasCond1(Instruction i)` Does the argument instruction have a non-null operand named Cond1?
`static boolean`	`MIR_CondBranch2.hasCond1(Instruction i)` Does the argument instruction have a non-null operand named Cond1?
`static boolean`	`IfCmp2.hasCond2(Instruction i)` Does the argument instruction have a non-null operand named Cond2?
`static boolean`	`MIR_CondBranch2.hasCond2(Instruction i)` Does the argument instruction have a non-null operand named Cond2?
`static boolean`	`InstrumentedCounter.hasData(Instruction i)` Does the argument instruction have a non-null operand named Data?
`static boolean`	`LookupSwitch.hasDefault(Instruction i)` Does the argument instruction have a non-null operand named Default?
`static boolean`	`TableSwitch.hasDefault(Instruction i)` Does the argument instruction have a non-null operand named Default?
`static boolean`	`LookupSwitch.hasDefaultBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named DefaultBranchProfile?
`static boolean`	`TableSwitch.hasDefaultBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named DefaultBranchProfile?
`static boolean`	`MIR_RDTSC.hasDest1(Instruction i)` Does the argument instruction have a non-null operand named Dest1?
`static boolean`	`MIR_RDTSC.hasDest2(Instruction i)` Does the argument instruction have a non-null operand named Dest2?
`static boolean`	`MIR_FSave.hasDestination(Instruction i)` Does the argument instruction have a non-null operand named Destination?
`static boolean`	`Multianewarray.hasDimension(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Dimension?
`static boolean`	`Multianewarray.hasDimensions(Instruction i)` Does the argument instruction have any operands named Dimension?
`static boolean`	`OsrPoint.hasElement(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Element?
`static boolean`	`OsrBarrier.hasElement(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Element?
`static boolean`	`OsrPoint.hasElements(Instruction i)` Does the argument instruction have any operands named Element?
`static boolean`	`OsrBarrier.hasElements(Instruction i)` Does the argument instruction have any operands named Element?
`static boolean`	`CondMove.hasFalseValue(Instruction i)` Does the argument instruction have a non-null operand named FalseValue?
`static boolean`	`Prologue.hasFormal(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Formal?
`static boolean`	`Prologue.hasFormals(Instruction i)` Does the argument instruction have any operands named Formal?
`static boolean`	`InlineGuard.hasGoal(Instruction i)` Does the argument instruction have a non-null operand named Goal?
`static boolean`	`InstanceOf.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`Call.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`ALoad.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`AStore.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`InlineGuard.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`StoreCheck.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`GuardedSet.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`BoundsCheck.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`TypeCheck.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`GuardCarrier.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`Store.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`GetField.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`Load.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`Prepare.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`GuardedBinary.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`MonitorOp.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`PutField.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`GuardedUnary.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`Attempt.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`MIR_Divide.hasGuard(Instruction i)` Does the argument instruction have a non-null operand named Guard?
`static boolean`	`IfCmp2.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`MIR_Trap.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`NullCheck.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`TrapIf.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`StoreCheck.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`BoundsCheck.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`GuardResultCarrier.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`MIR_TrapIf.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`ZeroCheck.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`IfCmp.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`Trap.hasGuardResult(Instruction i)` Does the argument instruction have a non-null operand named GuardResult?
`static boolean`	`TableSwitch.hasHigh(Instruction i)` Does the argument instruction have a non-null operand named High?
`static boolean`	`InstrumentedCounter.hasIncrement(Instruction i)` Does the argument instruction have a non-null operand named Increment?
`static boolean`	`ALoad.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`AStore.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`BoundsCheck.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`MIR_CaseLabel.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`InstrumentedCounter.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`MIR_LowTableSwitch.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`LowTableSwitch.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`static boolean`	`OsrPoint.hasInlinedTypeInfo(Instruction i)` Does the argument instruction have a non-null operand named InlinedTypeInfo?
`static boolean`	`ALoad.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`AStore.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`LocationCarrier.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`GetStatic.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`Store.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`GetField.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`Load.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`Prepare.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`PutField.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`Attempt.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`PutStatic.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`TableSwitch.hasLow(Instruction i)` Does the argument instruction have a non-null operand named Low?
`static boolean`	`LookupSwitch.hasMatch(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Match?
`static boolean`	`LookupSwitch.hasMatches(Instruction i)` Does the argument instruction have any Matches operands?
`static boolean`	`MIR_CompareExchange.hasMemAddr(Instruction i)` Does the argument instruction have a non-null operand named MemAddr?
`static boolean`	`MIR_CompareExchange8B.hasMemAddr(Instruction i)` Does the argument instruction have a non-null operand named MemAddr?
`static boolean`	`Call.hasMethod(Instruction i)` Does the argument instruction have a non-null operand named Method?
`static boolean`	`MIR_Call.hasMethod(Instruction i)` Does the argument instruction have a non-null operand named Method?
`static boolean`	`MIR_LowTableSwitch.hasMethodStart(Instruction i)` Does the argument instruction have a non-null operand named MethodStart?
`static boolean`	`MIR_CompareExchange.hasNewValue(Instruction i)` Does the argument instruction have a non-null operand named NewValue?
`static boolean`	`Attempt.hasNewValue(Instruction i)` Does the argument instruction have a non-null operand named NewValue?
`static boolean`	`MIR_CompareExchange8B.hasNewValueHigh(Instruction i)` Does the argument instruction have a non-null operand named NewValueHigh?
`static boolean`	`MIR_CompareExchange8B.hasNewValueLow(Instruction i)` Does the argument instruction have a non-null operand named NewValueLow?
`static boolean`	`GetStatic.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`Store.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`GetField.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`Load.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`Prepare.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`PutField.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`Attempt.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`PutStatic.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`MIR_CompareExchange.hasOldValue(Instruction i)` Does the argument instruction have a non-null operand named OldValue?
`static boolean`	`Attempt.hasOldValue(Instruction i)` Does the argument instruction have a non-null operand named OldValue?
`static boolean`	`MIR_CompareExchange8B.hasOldValueHigh(Instruction i)` Does the argument instruction have a non-null operand named OldValueHigh?
`static boolean`	`MIR_CompareExchange8B.hasOldValueLow(Instruction i)` Does the argument instruction have a non-null operand named OldValueLow?
`static boolean`	`Call.hasParam(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Param?
`static boolean`	`MIR_Call.hasParam(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Param?
`static boolean`	`Call.hasParams(Instruction i)` Does the argument instruction have any operands named Param?
`static boolean`	`MIR_Call.hasParams(Instruction i)` Does the argument instruction have any operands named Param?
`(package private) static boolean`	`GenericPhysicalRegisterTools.hasPhysicalOperand(Instruction s)` Does instruction s have an operand that contains a physical register?
`static boolean`	`MIR_Return.hasPopBytes(Instruction i)` Does the argument instruction have a non-null operand named PopBytes?
`static boolean`	`Phi.hasPred(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Pred?
`static boolean`	`Phi.hasPreds(Instruction i)` Does the argument instruction have any operands named Pred?
`static boolean`	`InstanceOf.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`NullCheck.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`StoreCheck.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`GuardedSet.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`BoundsCheck.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`TypeCheck.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`GetField.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`CacheOp.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`MonitorOp.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`PutField.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`Binary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Unary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`InstanceOf.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Call.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Multianewarray.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`ALoad.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Move.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Nullary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`NewArray.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_BinaryAcc.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_DoubleShift.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_UnaryAcc.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`GetStatic.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`TypeCheck.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Move.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`BooleanCmp.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Lea.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`CondMove.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Unary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Nullary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`GetField.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Load.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Prepare.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`GuardedBinary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`New.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`GuardedUnary.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Call.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Attempt.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`ResultCarrier.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_CondMove.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`Phi.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Set.hasResult(Instruction i)` Does the argument instruction have a non-null operand named Result?
`static boolean`	`MIR_Multiply.hasResult1(Instruction i)` Does the argument instruction have a non-null operand named Result1?
`static boolean`	`MIR_ConvertDW2QW.hasResult1(Instruction i)` Does the argument instruction have a non-null operand named Result1?
`static boolean`	`MIR_Divide.hasResult1(Instruction i)` Does the argument instruction have a non-null operand named Result1?
`static boolean`	`MIR_Multiply.hasResult2(Instruction i)` Does the argument instruction have a non-null operand named Result2?
`static boolean`	`MIR_ConvertDW2QW.hasResult2(Instruction i)` Does the argument instruction have a non-null operand named Result2?
`static boolean`	`MIR_Call.hasResult2(Instruction i)` Does the argument instruction have a non-null operand named Result2?
`static boolean`	`MIR_Divide.hasResult2(Instruction i)` Does the argument instruction have a non-null operand named Result2?
`static boolean`	`NewArray.hasSize(Instruction i)` Does the argument instruction have a non-null operand named Size?
`static boolean`	`MIR_DoubleShift.hasSource(Instruction i)` Does the argument instruction have a non-null operand named Source?
`static boolean`	`Goto.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`MIR_CondBranch.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`InlineGuard.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`MIR_CaseLabel.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`MIR_Call.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`IfCmp.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`MIR_Branch.hasTarget(Instruction i)` Does the argument instruction have a non-null operand named Target?
`static boolean`	`MIR_LowTableSwitch.hasTarget(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Target?
`static boolean`	`LookupSwitch.hasTarget(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Target?
`static boolean`	`TableSwitch.hasTarget(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Target?
`static boolean`	`LowTableSwitch.hasTarget(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Target?
`static boolean`	`IfCmp2.hasTarget1(Instruction i)` Does the argument instruction have a non-null operand named Target1?
`static boolean`	`MIR_CondBranch2.hasTarget1(Instruction i)` Does the argument instruction have a non-null operand named Target1?
`static boolean`	`IfCmp2.hasTarget2(Instruction i)` Does the argument instruction have a non-null operand named Target2?
`static boolean`	`MIR_CondBranch2.hasTarget2(Instruction i)` Does the argument instruction have a non-null operand named Target2?
`static boolean`	`MIR_LowTableSwitch.hasTargets(Instruction i)` Does the argument instruction have any operands named Target?
`static boolean`	`LookupSwitch.hasTargets(Instruction i)` Does the argument instruction have any operands named Target?
`static boolean`	`TableSwitch.hasTargets(Instruction i)` Does the argument instruction have any operands named Target?
`static boolean`	`LowTableSwitch.hasTargets(Instruction i)` Does the argument instruction have any operands named Target?
`static boolean`	`TrapIf.hasTCode(Instruction i)` Does the argument instruction have a non-null operand named TCode?
`static boolean`	`Trap.hasTCode(Instruction i)` Does the argument instruction have a non-null operand named TCode?
`static boolean`	`MIR_Trap.hasTrapCode(Instruction i)` Does the argument instruction have a non-null operand named TrapCode?
`static boolean`	`MIR_TrapIf.hasTrapCode(Instruction i)` Does the argument instruction have a non-null operand named TrapCode?
`static boolean`	`CondMove.hasTrueValue(Instruction i)` Does the argument instruction have a non-null operand named TrueValue?
`static boolean`	`InstanceOf.hasType(Instruction i)` Does the argument instruction have a non-null operand named Type?
`static boolean`	`Multianewarray.hasType(Instruction i)` Does the argument instruction have a non-null operand named Type?
`static boolean`	`NewArray.hasType(Instruction i)` Does the argument instruction have a non-null operand named Type?
`static boolean`	`TypeCheck.hasType(Instruction i)` Does the argument instruction have a non-null operand named Type?
`static boolean`	`New.hasType(Instruction i)` Does the argument instruction have a non-null operand named Type?
`static boolean`	`OsrBarrier.hasTypeInfo(Instruction i)` Does the argument instruction have a non-null operand named TypeInfo?
`static boolean`	`LookupSwitch.hasUnknown1(Instruction i)` Does the argument instruction have a non-null operand named Unknown1?
`static boolean`	`TableSwitch.hasUnknown1(Instruction i)` Does the argument instruction have a non-null operand named Unknown1?
`static boolean`	`LookupSwitch.hasUnknown2(Instruction i)` Does the argument instruction have a non-null operand named Unknown2?
`static boolean`	`TableSwitch.hasUnknown2(Instruction i)` Does the argument instruction have a non-null operand named Unknown2?
`static boolean`	`MIR_Unary.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`Move.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`MIR_Return.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`Return.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`StoreCheck.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`GuardedSet.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`Unary.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`GuardedUnary.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`MIR_UnaryNoRes.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`IfCmp2.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`Binary.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`MIR_XChng.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`TrapIf.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`BooleanCmp.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`CondMove.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`MIR_Test.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`GuardedBinary.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`MIR_TrapIf.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`IfCmp.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`MIR_Compare.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`IfCmp2.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`Binary.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`MIR_Return.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`MIR_XChng.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`TrapIf.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`BooleanCmp.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`CondMove.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`MIR_Test.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`GuardedBinary.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`MIR_TrapIf.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`IfCmp.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`MIR_Compare.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`MIR_Multiply.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`MIR_BinaryAcc.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`AStore.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`InlineGuard.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`MIR_Move.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`MIR_Lea.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`Store.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`LookupSwitch.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`TableSwitch.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`PutField.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`ZeroCheck.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`Athrow.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`MIR_Divide.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`PutStatic.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`MIR_CondMove.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`Phi.hasValue(Instruction i, int k)` Does the argument instruction have a non-null k'th operand named Value?
`static boolean`	`Phi.hasValues(Instruction i)` Does the argument instruction have any operands named Value?
`static int`	`Call.indexOfAddress(Instruction i)` Return the index of the operand called Address in the argument instruction.
`static int`	`Store.indexOfAddress(Instruction i)` Return the index of the operand called Address in the argument instruction.
`static int`	`Load.indexOfAddress(Instruction i)` Return the index of the operand called Address in the argument instruction.
`static int`	`Prepare.indexOfAddress(Instruction i)` Return the index of the operand called Address in the argument instruction.
`static int`	`Attempt.indexOfAddress(Instruction i)` Return the index of the operand called Address in the argument instruction.
`static int`	`MIR_CacheOp.indexOfAddress(Instruction i)` Return the index of the operand called Address in the argument instruction.
`static int`	`ALoad.indexOfArray(Instruction i)` Return the index of the operand called Array in the argument instruction.
`static int`	`AStore.indexOfArray(Instruction i)` Return the index of the operand called Array in the argument instruction.
`static int`	`MIR_DoubleShift.indexOfBitsToShift(Instruction i)` Return the index of the operand called BitsToShift in the argument instruction.
`static int`	`Label.indexOfBlock(Instruction i)` Return the index of the operand called Block in the argument instruction.
`static int`	`BBend.indexOfBlock(Instruction i)` Return the index of the operand called Block in the argument instruction.
`static int`	`BranchProfileCarrier.indexOfBranchProfile(Instruction i)` Return the index of the operand called BranchProfile in the argument instruction.
`static int`	`MIR_CondBranch.indexOfBranchProfile(Instruction i)` Return the index of the operand called BranchProfile in the argument instruction.
`static int`	`InlineGuard.indexOfBranchProfile(Instruction i)` Return the index of the operand called BranchProfile in the argument instruction.
`static int`	`BooleanCmp.indexOfBranchProfile(Instruction i)` Return the index of the operand called BranchProfile in the argument instruction.
`static int`	`IfCmp.indexOfBranchProfile(Instruction i)` Return the index of the operand called BranchProfile in the argument instruction.
`static int`	`MIR_LowTableSwitch.indexOfBranchProfile(Instruction i, int k)` Return the index of the k'th operand called BranchProfile in the argument instruction.
`static int`	`LookupSwitch.indexOfBranchProfile(Instruction i, int k)` Return the index of the k'th operand called BranchProfile in the argument instruction.
`static int`	`TableSwitch.indexOfBranchProfile(Instruction i, int k)` Return the index of the k'th operand called BranchProfile in the argument instruction.
`static int`	`LowTableSwitch.indexOfBranchProfile(Instruction i, int k)` Return the index of the k'th operand called BranchProfile in the argument instruction.
`static int`	`IfCmp2.indexOfBranchProfile1(Instruction i)` Return the index of the operand called BranchProfile1 in the argument instruction.
`static int`	`MIR_CondBranch2.indexOfBranchProfile1(Instruction i)` Return the index of the operand called BranchProfile1 in the argument instruction.
`static int`	`IfCmp2.indexOfBranchProfile2(Instruction i)` Return the index of the operand called BranchProfile2 in the argument instruction.
`static int`	`MIR_CondBranch2.indexOfBranchProfile2(Instruction i)` Return the index of the operand called BranchProfile2 in the argument instruction.
`static int`	`MIR_LowTableSwitch.indexOfBranchProfiles(Instruction i)` Return the index of the first operand called BranchProfile in the argument instruction.
`static int`	`LookupSwitch.indexOfBranchProfiles(Instruction i)` Return the index of the first operand called BranchProfile in the argument instruction.
`static int`	`TableSwitch.indexOfBranchProfiles(Instruction i)` Return the index of the first operand called BranchProfile in the argument instruction.
`static int`	`LowTableSwitch.indexOfBranchProfiles(Instruction i)` Return the index of the first operand called BranchProfile in the argument instruction.
`static int`	`MIR_CondBranch.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`TrapIf.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`BooleanCmp.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`CondMove.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`MIR_TrapIf.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`IfCmp.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`MIR_CondMove.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`MIR_Set.indexOfCond(Instruction i)` Return the index of the operand called Cond in the argument instruction.
`static int`	`IfCmp2.indexOfCond1(Instruction i)` Return the index of the operand called Cond1 in the argument instruction.
`static int`	`MIR_CondBranch2.indexOfCond1(Instruction i)` Return the index of the operand called Cond1 in the argument instruction.
`static int`	`IfCmp2.indexOfCond2(Instruction i)` Return the index of the operand called Cond2 in the argument instruction.
`static int`	`MIR_CondBranch2.indexOfCond2(Instruction i)` Return the index of the operand called Cond2 in the argument instruction.
`static int`	`InstrumentedCounter.indexOfData(Instruction i)` Return the index of the operand called Data in the argument instruction.
`static int`	`LookupSwitch.indexOfDefault(Instruction i)` Return the index of the operand called Default in the argument instruction.
`static int`	`TableSwitch.indexOfDefault(Instruction i)` Return the index of the operand called Default in the argument instruction.
`static int`	`LookupSwitch.indexOfDefaultBranchProfile(Instruction i)` Return the index of the operand called DefaultBranchProfile in the argument instruction.
`static int`	`TableSwitch.indexOfDefaultBranchProfile(Instruction i)` Return the index of the operand called DefaultBranchProfile in the argument instruction.
`static int`	`MIR_RDTSC.indexOfDest1(Instruction i)` Return the index of the operand called Dest1 in the argument instruction.
`static int`	`MIR_RDTSC.indexOfDest2(Instruction i)` Return the index of the operand called Dest2 in the argument instruction.
`static int`	`MIR_FSave.indexOfDestination(Instruction i)` Return the index of the operand called Destination in the argument instruction.
`static int`	`Multianewarray.indexOfDimension(Instruction i, int k)` Return the index of the k'th operand called Dimension in the argument instruction.
`static int`	`Multianewarray.indexOfDimensions(Instruction i)` Return the index of the first operand called Dimension in the argument instruction.
`static int`	`OsrPoint.indexOfElement(Instruction i, int k)` Return the index of the k'th operand called Element in the argument instruction.
`static int`	`OsrBarrier.indexOfElement(Instruction i, int k)` Return the index of the k'th operand called Element in the argument instruction.
`static int`	`OsrPoint.indexOfElements(Instruction i)` Return the index of the first operand called Element in the argument instruction.
`static int`	`OsrBarrier.indexOfElements(Instruction i)` Return the index of the first operand called Element in the argument instruction.
`static int`	`CondMove.indexOfFalseValue(Instruction i)` Return the index of the operand called FalseValue in the argument instruction.
`static int`	`Prologue.indexOfFormal(Instruction i, int k)` Return the index of the k'th operand called Formal in the argument instruction.
`static int`	`Prologue.indexOfFormals(Instruction i)` Return the index of the first operand called Formal in the argument instruction.
`static int`	`InlineGuard.indexOfGoal(Instruction i)` Return the index of the operand called Goal in the argument instruction.
`static int`	`InstanceOf.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`Call.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`ALoad.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`AStore.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`InlineGuard.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`StoreCheck.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`GuardedSet.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`BoundsCheck.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`TypeCheck.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`GuardCarrier.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`Store.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`GetField.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`Load.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`Prepare.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`GuardedBinary.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`MonitorOp.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`PutField.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`GuardedUnary.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`Attempt.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`MIR_Divide.indexOfGuard(Instruction i)` Return the index of the operand called Guard in the argument instruction.
`static int`	`IfCmp2.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`MIR_Trap.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`NullCheck.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`TrapIf.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`StoreCheck.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`BoundsCheck.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`GuardResultCarrier.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`MIR_TrapIf.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`ZeroCheck.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`IfCmp.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`Trap.indexOfGuardResult(Instruction i)` Return the index of the operand called GuardResult in the argument instruction.
`static int`	`TableSwitch.indexOfHigh(Instruction i)` Return the index of the operand called High in the argument instruction.
`static int`	`InstrumentedCounter.indexOfIncrement(Instruction i)` Return the index of the operand called Increment in the argument instruction.
`static int`	`ALoad.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`AStore.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`BoundsCheck.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`MIR_CaseLabel.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`InstrumentedCounter.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`MIR_LowTableSwitch.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`LowTableSwitch.indexOfIndex(Instruction i)` Return the index of the operand called Index in the argument instruction.
`static int`	`OsrPoint.indexOfInlinedTypeInfo(Instruction i)` Return the index of the operand called InlinedTypeInfo in the argument instruction.
`static int`	`ALoad.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`AStore.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`LocationCarrier.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`GetStatic.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`Store.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`GetField.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`Load.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`Prepare.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`PutField.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`Attempt.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`PutStatic.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`TableSwitch.indexOfLow(Instruction i)` Return the index of the operand called Low in the argument instruction.
`static int`	`LookupSwitch.indexOfMatch(Instruction i, int k)` Return the index of the k'th operand called Match in the argument instruction.
`static int`	`LookupSwitch.indexOfMatches(Instruction i)` Return the index of the first operand called Matches in the argument instruction.
`static int`	`MIR_CompareExchange.indexOfMemAddr(Instruction i)` Return the index of the operand called MemAddr in the argument instruction.
`static int`	`MIR_CompareExchange8B.indexOfMemAddr(Instruction i)` Return the index of the operand called MemAddr in the argument instruction.
`static int`	`Call.indexOfMethod(Instruction i)` Return the index of the operand called Method in the argument instruction.
`static int`	`MIR_Call.indexOfMethod(Instruction i)` Return the index of the operand called Method in the argument instruction.
`static int`	`MIR_LowTableSwitch.indexOfMethodStart(Instruction i)` Return the index of the operand called MethodStart in the argument instruction.
`static int`	`MIR_CompareExchange.indexOfNewValue(Instruction i)` Return the index of the operand called NewValue in the argument instruction.
`static int`	`Attempt.indexOfNewValue(Instruction i)` Return the index of the operand called NewValue in the argument instruction.
`static int`	`MIR_CompareExchange8B.indexOfNewValueHigh(Instruction i)` Return the index of the operand called NewValueHigh in the argument instruction.
`static int`	`MIR_CompareExchange8B.indexOfNewValueLow(Instruction i)` Return the index of the operand called NewValueLow in the argument instruction.
`static int`	`GetStatic.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`Store.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`GetField.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`Load.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`Prepare.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`PutField.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`Attempt.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`PutStatic.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`MIR_CompareExchange.indexOfOldValue(Instruction i)` Return the index of the operand called OldValue in the argument instruction.
`static int`	`Attempt.indexOfOldValue(Instruction i)` Return the index of the operand called OldValue in the argument instruction.
`static int`	`MIR_CompareExchange8B.indexOfOldValueHigh(Instruction i)` Return the index of the operand called OldValueHigh in the argument instruction.
`static int`	`MIR_CompareExchange8B.indexOfOldValueLow(Instruction i)` Return the index of the operand called OldValueLow in the argument instruction.
`static int`	`Call.indexOfParam(Instruction i, int k)` Return the index of the k'th operand called Param in the argument instruction.
`static int`	`MIR_Call.indexOfParam(Instruction i, int k)` Return the index of the k'th operand called Param in the argument instruction.
`static int`	`Call.indexOfParams(Instruction i)` Return the index of the first operand called Param in the argument instruction.
`static int`	`MIR_Call.indexOfParams(Instruction i)` Return the index of the first operand called Param in the argument instruction.
`static int`	`MIR_Return.indexOfPopBytes(Instruction i)` Return the index of the operand called PopBytes in the argument instruction.
`static int`	`Phi.indexOfPred(Instruction i, int k)` Return the index of the k'th operand called Pred in the argument instruction.
`static int`	`Phi.indexOfPreds(Instruction i)` Return the index of the first operand called Pred in the argument instruction.
`static int`	`InstanceOf.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`NullCheck.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`StoreCheck.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`GuardedSet.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`BoundsCheck.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`TypeCheck.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`GetField.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`CacheOp.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`MonitorOp.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`PutField.indexOfRef(Instruction i)` Return the index of the operand called Ref in the argument instruction.
`static int`	`Binary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Unary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`InstanceOf.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Call.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Multianewarray.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`ALoad.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Move.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Nullary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`NewArray.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_BinaryAcc.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_DoubleShift.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_UnaryAcc.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`GetStatic.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`TypeCheck.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Move.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`BooleanCmp.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Lea.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`CondMove.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Unary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Nullary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`GetField.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Load.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Prepare.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`GuardedBinary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`New.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`GuardedUnary.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Call.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Attempt.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`ResultCarrier.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_CondMove.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`Phi.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Set.indexOfResult(Instruction i)` Return the index of the operand called Result in the argument instruction.
`static int`	`MIR_Multiply.indexOfResult1(Instruction i)` Return the index of the operand called Result1 in the argument instruction.
`static int`	`MIR_ConvertDW2QW.indexOfResult1(Instruction i)` Return the index of the operand called Result1 in the argument instruction.
`static int`	`MIR_Divide.indexOfResult1(Instruction i)` Return the index of the operand called Result1 in the argument instruction.
`static int`	`MIR_Multiply.indexOfResult2(Instruction i)` Return the index of the operand called Result2 in the argument instruction.
`static int`	`MIR_ConvertDW2QW.indexOfResult2(Instruction i)` Return the index of the operand called Result2 in the argument instruction.
`static int`	`MIR_Call.indexOfResult2(Instruction i)` Return the index of the operand called Result2 in the argument instruction.
`static int`	`MIR_Divide.indexOfResult2(Instruction i)` Return the index of the operand called Result2 in the argument instruction.
`static int`	`NewArray.indexOfSize(Instruction i)` Return the index of the operand called Size in the argument instruction.
`static int`	`MIR_DoubleShift.indexOfSource(Instruction i)` Return the index of the operand called Source in the argument instruction.
`static int`	`Goto.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`MIR_CondBranch.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`InlineGuard.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`MIR_CaseLabel.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`MIR_Call.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`IfCmp.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`MIR_Branch.indexOfTarget(Instruction i)` Return the index of the operand called Target in the argument instruction.
`static int`	`MIR_LowTableSwitch.indexOfTarget(Instruction i, int k)` Return the index of the k'th operand called Target in the argument instruction.
`static int`	`LookupSwitch.indexOfTarget(Instruction i, int k)` Return the index of the k'th operand called Target in the argument instruction.
`static int`	`TableSwitch.indexOfTarget(Instruction i, int k)` Return the index of the k'th operand called Target in the argument instruction.
`static int`	`LowTableSwitch.indexOfTarget(Instruction i, int k)` Return the index of the k'th operand called Target in the argument instruction.
`static int`	`IfCmp2.indexOfTarget1(Instruction i)` Return the index of the operand called Target1 in the argument instruction.
`static int`	`MIR_CondBranch2.indexOfTarget1(Instruction i)` Return the index of the operand called Target1 in the argument instruction.
`static int`	`IfCmp2.indexOfTarget2(Instruction i)` Return the index of the operand called Target2 in the argument instruction.
`static int`	`MIR_CondBranch2.indexOfTarget2(Instruction i)` Return the index of the operand called Target2 in the argument instruction.
`static int`	`MIR_LowTableSwitch.indexOfTargets(Instruction i)` Return the index of the first operand called Target in the argument instruction.
`static int`	`LookupSwitch.indexOfTargets(Instruction i)` Return the index of the first operand called Target in the argument instruction.
`static int`	`TableSwitch.indexOfTargets(Instruction i)` Return the index of the first operand called Target in the argument instruction.
`static int`	`LowTableSwitch.indexOfTargets(Instruction i)` Return the index of the first operand called Target in the argument instruction.
`static int`	`TrapIf.indexOfTCode(Instruction i)` Return the index of the operand called TCode in the argument instruction.
`static int`	`Trap.indexOfTCode(Instruction i)` Return the index of the operand called TCode in the argument instruction.
`static int`	`MIR_Trap.indexOfTrapCode(Instruction i)` Return the index of the operand called TrapCode in the argument instruction.
`static int`	`MIR_TrapIf.indexOfTrapCode(Instruction i)` Return the index of the operand called TrapCode in the argument instruction.
`static int`	`CondMove.indexOfTrueValue(Instruction i)` Return the index of the operand called TrueValue in the argument instruction.
`static int`	`InstanceOf.indexOfType(Instruction i)` Return the index of the operand called Type in the argument instruction.
`static int`	`Multianewarray.indexOfType(Instruction i)` Return the index of the operand called Type in the argument instruction.
`static int`	`NewArray.indexOfType(Instruction i)` Return the index of the operand called Type in the argument instruction.
`static int`	`TypeCheck.indexOfType(Instruction i)` Return the index of the operand called Type in the argument instruction.
`static int`	`New.indexOfType(Instruction i)` Return the index of the operand called Type in the argument instruction.
`static int`	`OsrBarrier.indexOfTypeInfo(Instruction i)` Return the index of the operand called TypeInfo in the argument instruction.
`static int`	`LookupSwitch.indexOfUnknown1(Instruction i)` Return the index of the operand called Unknown1 in the argument instruction.
`static int`	`TableSwitch.indexOfUnknown1(Instruction i)` Return the index of the operand called Unknown1 in the argument instruction.
`static int`	`LookupSwitch.indexOfUnknown2(Instruction i)` Return the index of the operand called Unknown2 in the argument instruction.
`static int`	`TableSwitch.indexOfUnknown2(Instruction i)` Return the index of the operand called Unknown2 in the argument instruction.
`static int`	`MIR_Unary.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`Move.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`MIR_Return.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`Return.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`StoreCheck.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`GuardedSet.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`Unary.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`GuardedUnary.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`MIR_UnaryNoRes.indexOfVal(Instruction i)` Return the index of the operand called Val in the argument instruction.
`static int`	`IfCmp2.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`Binary.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`MIR_XChng.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`TrapIf.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`BooleanCmp.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`CondMove.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`MIR_Test.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`GuardedBinary.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`MIR_TrapIf.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`IfCmp.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`MIR_Compare.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`IfCmp2.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`Binary.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`MIR_Return.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`MIR_XChng.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`TrapIf.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`BooleanCmp.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`CondMove.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`MIR_Test.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`GuardedBinary.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`MIR_TrapIf.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`IfCmp.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`MIR_Compare.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`MIR_Multiply.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`MIR_BinaryAcc.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`AStore.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`InlineGuard.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`MIR_Move.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`MIR_Lea.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`Store.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`LookupSwitch.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`TableSwitch.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`PutField.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`ZeroCheck.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`Athrow.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`MIR_Divide.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`PutStatic.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`MIR_CondMove.indexOfValue(Instruction i)` Return the index of the operand called Value in the argument instruction.
`static int`	`Phi.indexOfValue(Instruction i, int k)` Return the index of the k'th operand called Value in the argument instruction.
`static int`	`Phi.indexOfValues(Instruction i)` Return the index of the first operand called Value in the argument instruction.
`void`	`GCIRMap.insert(Instruction inst, List<RegSpillListElement> regList)` This method inserts a new entry into the GCIRMap
`void`	`Instruction.insertAfter(Instruction newInstr)` Insertion: Insert newInstr immediately after this in the instruction stream.
`void`	`Instruction.insertBefore(Instruction newInstr)` Insertion: Insert newInstr immediately before this in the instruction stream.
`static void`	`IRTools.insertInstructionsAfter(Instruction after, BasicBlock temp)` Inserts the instructions in the given basic block after the given instruction.
`void`	`GCIRMap.insertTwin(Instruction inst, Instruction twin)` This method inserts an entry for a "twin" instruction immediately after the original entry.
`(package private) void`	`Instruction.linkWithNext(Instruction other)` For IR internal use only; general clients should always use higer level mutation functions.
`static boolean`	`IRTools.mayBeVolatileFieldLoad(Instruction s)` Might this instruction be a load from a field that is declared to be volatile?
`abstract boolean`	`MachineSpecificIR.mayEscapeMethod(Instruction instruction)`
`abstract boolean`	`MachineSpecificIR.mayEscapeThread(Instruction instruction)`
`static void`	`IRTools.moveInstruction(Instruction from, Instruction to)` Moves the 'from' instruction to immediately before the 'to' instruction.
`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.
`void`	`GCIRMap.moveToEnd(Instruction inst)` This method moves an entry in the GCIRMap that is specified by inst to the end of the list.
`static Instruction`	`Empty.mutate(Instruction i, Operator o)` Mutate the argument instruction into an instruction of the Empty instruction format having the specified operator and operands.
`static Instruction`	`MIR_Empty.mutate(Instruction i, Operator o)` Mutate the argument instruction into an instruction of the MIR_Empty instruction format having the specified operator and operands.
`static Instruction`	`Return.mutate(Instruction i, Operator o)` Mutate the argument instruction into an instruction of the Return instruction format having the specified operator and operands.
`static Instruction`	`Label.mutate(Instruction i, Operator o, BasicBlockOperand Block)` Mutate the argument instruction into an instruction of the Label instruction format having the specified operator and operands.
`static Instruction`	`BBend.mutate(Instruction i, Operator o, BasicBlockOperand Block)` Mutate the argument instruction into an instruction of the BBend instruction format having the specified operator and operands.
`static Instruction`	`Goto.mutate(Instruction i, Operator o, BranchOperand Target)` Mutate the argument instruction into an instruction of the Goto instruction format having the specified operator and operands.
`static Instruction`	`MIR_Branch.mutate(Instruction i, Operator o, BranchOperand Target)` Mutate the argument instruction into an instruction of the MIR_Branch instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch.mutate(Instruction i, Operator o, IA32ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the MIR_CondBranch instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch.mutate(Instruction i, Operator o, IA32ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the MIR_CondBranch instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondBranch2.mutate(Instruction i, Operator o, IA32ConditionOperand Cond1, BranchProfileOperand BranchProfile1, IA32ConditionOperand Cond2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the MIR_CondBranch2 instruction format having the specified operator and operands.
`static Instruction`	`OsrPoint.mutate(Instruction i, Operator o, InlinedOsrTypeInfoOperand InlinedTypeInfo, int numVarOps)` Mutate the argument instruction into an instruction of the OsrPoint instruction format having the specified operator and operands.
`static Instruction`	`Prologue.mutate(Instruction i, Operator o, int numVarOps)` Mutate the argument instruction into an instruction of the Prologue instruction format having the specified operator and operands.
`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_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`	`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_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_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`	`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_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`	`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`	`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`	`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_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_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_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_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`	`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_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`	`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_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_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`	`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`	`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`	`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`	`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`	`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`	`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`	`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`	`OsrBarrier.mutate(Instruction i, Operator o, OsrTypeInfoOperand TypeInfo, int numVarOps)` Mutate the argument instruction into an instruction of the OsrBarrier instruction format having the specified operator and operands.
`static Instruction`	`Nullary.mutate(Instruction i, Operator o, RegisterOperand Result)` Mutate the argument instruction into an instruction of the Nullary instruction format having the specified operator and operands.
`static Instruction`	`LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, int numVarOps)` Mutate the argument instruction into an instruction of the LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Lea.mutate(Instruction i, Operator o, RegisterOperand Result, MemoryOperand Value)` Mutate the argument instruction into an instruction of the MIR_Lea instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange.mutate(Instruction i, Operator o, RegisterOperand OldValue, MemoryOperand MemAddr, RegisterOperand NewValue)` Mutate the argument instruction into an instruction of the MIR_CompareExchange instruction format having the specified operator and operands.
`static Instruction`	`Move.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Move instruction format having the specified operator and operands.
`static Instruction`	`NullCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref)` Mutate the argument instruction into an instruction of the NullCheck instruction format having the specified operator and operands.
`static Instruction`	`Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Unary instruction format having the specified operator and operands.
`static Instruction`	`ZeroCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Value)` Mutate the argument instruction into an instruction of the ZeroCheck instruction format having the specified operator and operands.
`static Instruction`	`GetStatic.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the GetStatic instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Binary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the Binary instruction format having the specified operator and operands.
`static Instruction`	`GuardedUnary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedUnary instruction format having the specified operator and operands.
`static Instruction`	`IfCmp.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the IfCmp instruction format having the specified operator and operands.
`static Instruction`	`IfCmp2.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the IfCmp2 instruction format having the specified operator and operands.
`static Instruction`	`BooleanCmp.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the BooleanCmp instruction format having the specified operator and operands.
`static Instruction`	`CondMove.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Mutate the argument instruction into an instruction of the CondMove instruction format having the specified operator and operands.
`static Instruction`	`TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the TrapIf instruction format having the specified operator and operands.
`static Instruction`	`MIR_TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_TrapIf instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`ALoad.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the ALoad instruction format having the specified operator and operands.
`static Instruction`	`GetField.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the GetField instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`StoreCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the StoreCheck instruction format having the specified operator and operands.
`static Instruction`	`BoundsCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Mutate the argument instruction into an instruction of the BoundsCheck instruction format having the specified operator and operands.
`static Instruction`	`GuardedBinary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedBinary instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`MIR_RDTSC.mutate(Instruction i, Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Mutate the argument instruction into an instruction of the MIR_RDTSC instruction format having the specified operator and operands.
`static Instruction`	`MIR_LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange8B.mutate(Instruction i, Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Mutate the argument instruction into an instruction of the MIR_CompareExchange8B instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
`static Instruction`	`Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the Trap instruction format having the specified operator and operands.
`static Instruction`	`New.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type)` Mutate the argument instruction into an instruction of the New instruction format having the specified operator and operands.
`static Instruction`	`Multianewarray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Mutate the argument instruction into an instruction of the Multianewarray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`NewArray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Mutate the argument instruction into an instruction of the NewArray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`abstract void`	`MachineSpecificIR.mutateMIRCondBranch(Instruction cb)`
`static Instruction`	`IRTools.nonPEIGC(Instruction instr)` Mark the parameter as nonGC and nonPEI and return it.
`void`	`BasicBlock.prependInstruction(Instruction i)` Prepend instruction to this basic block by inserting it right after the LABEL instruction in the instruction list.
`void`	`BasicBlock.prependInstructionRespectingPrologue(Instruction i)` Prepend instruction to this basic block but respect the prologue instruction, which must come first.
`void`	`Instruction.replace(Instruction newInstr)` Replacement: Replace this with newInstr.
`static void`	`MIR_LowTableSwitch.resizeNumberOfBranchProfiles(Instruction i, int numVarOps)` Change the number of BranchProfiles that may be stored in the argument instruction to numVarOps.
`static void`	`LookupSwitch.resizeNumberOfBranchProfiles(Instruction i, int numVarOps)` Change the number of BranchProfiles that may be stored in the argument instruction to numVarOps.
`static void`	`TableSwitch.resizeNumberOfBranchProfiles(Instruction i, int numVarOps)` Change the number of BranchProfiles that may be stored in the argument instruction to numVarOps.
`static void`	`LowTableSwitch.resizeNumberOfBranchProfiles(Instruction i, int numVarOps)` Change the number of BranchProfiles that may be stored in the argument instruction to numVarOps.
`static void`	`Multianewarray.resizeNumberOfDimensions(Instruction i, int numVarOps)` Change the number of Dimensions that may be stored in the argument instruction to numVarOps.
`static void`	`OsrPoint.resizeNumberOfElements(Instruction i, int numVarOps)` Change the number of Elements that may be stored in the argument instruction to numVarOps.
`static void`	`OsrBarrier.resizeNumberOfElements(Instruction i, int numVarOps)` Change the number of Elements that may be stored in the argument instruction to numVarOps.
`static void`	`Prologue.resizeNumberOfFormals(Instruction i, int numVarOps)` Change the number of Formals that may be stored in the argument instruction to numVarOps.
`static void`	`LookupSwitch.resizeNumberOfMatches(Instruction i, int numVarOps)` Change the number of Matches operands that may be stored in the argument instruction to numVarOps.
`static void`	`Call.resizeNumberOfParams(Instruction i, int numVarOps)` Change the number of Params that may be stored in the argument instruction to numVarOps.
`static void`	`MIR_Call.resizeNumberOfParams(Instruction i, int numVarOps)` Change the number of Params that may be stored in the argument instruction to numVarOps.
`static void`	`Phi.resizeNumberOfPreds(Instruction i, int numVarOps)` Change the number of Preds that may be stored in the argument instruction to numVarOps.
`static void`	`MIR_LowTableSwitch.resizeNumberOfTargets(Instruction i, int numVarOps)` Change the number of Targets that may be stored in the argument instruction to numVarOps.
`static void`	`LookupSwitch.resizeNumberOfTargets(Instruction i, int numVarOps)` Change the number of Targets that may be stored in the argument instruction to numVarOps.
`static void`	`TableSwitch.resizeNumberOfTargets(Instruction i, int numVarOps)` Change the number of Targets that may be stored in the argument instruction to numVarOps.
`static void`	`LowTableSwitch.resizeNumberOfTargets(Instruction i, int numVarOps)` Change the number of Targets that may be stored in the argument instruction to numVarOps.
`static void`	`Phi.resizeNumberOfValues(Instruction i, int numVarOps)` Change the number of Values that may be stored in the argument instruction to numVarOps.
`static InstructionEnumeration`	`IREnumeration.reverseIntraBlockIE(Instruction start, Instruction end)` Reverse intra basic block instruction enumerations from from start...last inclusive.
`BasicBlock`	`BasicBlock.segregateInstruction(Instruction target, IR ir)` Ensure that the target instruction is the only real instruction in its basic block and that it has exactly one successor and one predecessor basic blocks that are linked to it by fall through edges.
`static void`	`Call.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`	`Load.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`	`Attempt.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`	`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`	`Label.setBlock(Instruction i, BasicBlockOperand Block)` Set the operand called Block in the argument instruction to the argument operand.
`static void`	`BBend.setBlock(Instruction i, BasicBlockOperand Block)` Set the operand called Block in the argument instruction to the argument operand.
`static void`	`BranchProfileCarrier.setBranchProfile(Instruction i, BranchProfileOperand op)` Set the operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` Set the operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`InlineGuard.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` Set the operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` Set the operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`IfCmp.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` Set the operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setBranchProfile(Instruction i, int k, BranchProfileOperand o)` Set the k'th operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setBranchProfile(Instruction i, int k, BranchProfileOperand o)` Set the k'th operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`TableSwitch.setBranchProfile(Instruction i, int k, BranchProfileOperand o)` Set the k'th operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`LowTableSwitch.setBranchProfile(Instruction i, int k, BranchProfileOperand o)` Set the k'th operand called BranchProfile in the argument instruction to the argument operand.
`static void`	`IfCmp2.setBranchProfile1(Instruction i, BranchProfileOperand BranchProfile1)` Set the operand called BranchProfile1 in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch2.setBranchProfile1(Instruction i, BranchProfileOperand BranchProfile1)` Set the operand called BranchProfile1 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setBranchProfile2(Instruction i, BranchProfileOperand BranchProfile2)` Set the operand called BranchProfile2 in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch2.setBranchProfile2(Instruction i, BranchProfileOperand BranchProfile2)` Set the operand called BranchProfile2 in the argument instruction to the argument operand.
`static void`	`TrapIf.setCond(Instruction i, ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setCond(Instruction i, ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`CondMove.setCond(Instruction i, ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`IfCmp.setCond(Instruction i, ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch.setCond(Instruction i, IA32ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setCond(Instruction i, IA32ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`MIR_CondMove.setCond(Instruction i, IA32ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`MIR_Set.setCond(Instruction i, IA32ConditionOperand Cond)` Set the operand called Cond in the argument instruction to the argument operand.
`static void`	`IfCmp2.setCond1(Instruction i, ConditionOperand Cond1)` Set the operand called Cond1 in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch2.setCond1(Instruction i, IA32ConditionOperand Cond1)` Set the operand called Cond1 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setCond2(Instruction i, ConditionOperand Cond2)` Set the operand called Cond2 in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch2.setCond2(Instruction i, IA32ConditionOperand Cond2)` Set the operand called Cond2 in the argument instruction to the argument operand.
`static void`	`InstrumentedCounter.setData(Instruction i, IntConstantOperand Data)` Set the operand called Data in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setDefault(Instruction i, BranchOperand Default)` Set the operand called Default in the argument instruction to the argument operand.
`static void`	`TableSwitch.setDefault(Instruction i, BranchOperand Default)` Set the operand called Default in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setDefaultBranchProfile(Instruction i, BranchProfileOperand DefaultBranchProfile)` Set the operand called DefaultBranchProfile in the argument instruction to the argument operand.
`static void`	`TableSwitch.setDefaultBranchProfile(Instruction i, BranchProfileOperand DefaultBranchProfile)` Set the operand called DefaultBranchProfile in the argument instruction to the argument operand.
`static void`	`MIR_RDTSC.setDest1(Instruction i, RegisterOperand Dest1)` Set the operand called Dest1 in the argument instruction to the argument operand.
`static void`	`MIR_RDTSC.setDest2(Instruction i, RegisterOperand Dest2)` Set the operand called Dest2 in the argument instruction to the argument operand.
`static void`	`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`	`Prologue.setFormal(Instruction i, int k, RegisterOperand o)` Set the k'th operand called Formal in the argument instruction to the argument operand.
`static void`	`InlineGuard.setGoal(Instruction i, Operand Goal)` Set the operand called Goal 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`	`Call.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`	`AStore.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`	`StoreCheck.setGuard(Instruction i, Operand Guard)` 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`	`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`	`GuardCarrier.setGuard(Instruction i, Operand op)` 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`	`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`	`Prepare.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`	`PutField.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`	`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`	`IfCmp2.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`MIR_Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`NullCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`TrapIf.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`StoreCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`GuardResultCarrier.setGuardResult(Instruction i, RegisterOperand op)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`ZeroCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`IfCmp.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`TableSwitch.setHigh(Instruction i, IntConstantOperand High)` Set the operand called High 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`	`MIR_CaseLabel.setIndex(Instruction i, IntConstantOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`InstrumentedCounter.setIndex(Instruction i, IntConstantOperand 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`	`BoundsCheck.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setIndex(Instruction i, RegisterOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`LowTableSwitch.setIndex(Instruction i, RegisterOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`OsrPoint.setInlinedTypeInfo(Instruction i, InlinedOsrTypeInfoOperand InlinedTypeInfo)` Set the operand called InlinedTypeInfo in the argument instruction to the argument operand.
`static void`	`ALoad.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`AStore.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`LocationCarrier.setLocation(Instruction i, LocationOperand op)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`GetStatic.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`Store.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`GetField.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`Load.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`Prepare.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`PutField.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`Attempt.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`PutStatic.setLocation(Instruction i, LocationOperand Location)` Set the operand called Location in the argument instruction to the argument operand.
`static void`	`TableSwitch.setLow(Instruction i, IntConstantOperand Low)` Set the operand called Low in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setMatch(Instruction i, int k, IntConstantOperand o)` Set the k'th operand called Match in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange.setMemAddr(Instruction i, MemoryOperand MemAddr)` Set the operand called MemAddr in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setMemAddr(Instruction i, MemoryOperand MemAddr)` Set the operand called MemAddr in the argument instruction to the argument operand.
`static void`	`Call.setMethod(Instruction i, MethodOperand Method)` Set the operand called Method in the argument instruction to the argument operand.
`static void`	`MIR_Call.setMethod(Instruction i, MethodOperand Method)` Set the operand called Method in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setMethodStart(Instruction i, RegisterOperand MethodStart)` Set the operand called MethodStart in the argument instruction to the argument operand.
`static void`	`Attempt.setNewValue(Instruction i, Operand NewValue)` Set the operand called NewValue in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange.setNewValue(Instruction i, RegisterOperand NewValue)` Set the operand called NewValue in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setNewValueHigh(Instruction i, RegisterOperand NewValueHigh)` Set the operand called NewValueHigh in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setNewValueLow(Instruction i, RegisterOperand NewValueLow)` Set the operand called NewValueLow in the argument instruction to the argument operand.
`(package private) void`	`Instruction.setNext(Instruction n)` For IR internal use only; general clients should always use higer level mutation functions.
`static void`	`GetStatic.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`	`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`	`Prepare.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`	`PutStatic.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`	`MIR_CompareExchange.setOldValue(Instruction i, RegisterOperand OldValue)` Set the operand called OldValue in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setOldValueHigh(Instruction i, RegisterOperand OldValueHigh)` Set the operand called OldValueHigh in the argument instruction to the argument operand.
`static void`	`MIR_CompareExchange8B.setOldValueLow(Instruction i, RegisterOperand OldValueLow)` Set the operand called OldValueLow in the argument instruction to the argument operand.
`static void`	`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`	`MIR_Return.setPopBytes(Instruction i, IntConstantOperand PopBytes)` Set the operand called PopBytes in the argument instruction to the argument operand.
`static void`	`Phi.setPred(Instruction i, int k, BasicBlockOperand o)` Set the k'th operand called Pred in the argument instruction to the argument operand.
`(package private) void`	`Instruction.setPrev(Instruction p)` For IR internal use only; general clients should always use higer level mutation functions.
`static void`	`InstanceOf.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`	`GuardedSet.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`	`CacheOp.setRef(Instruction i, Operand Ref)` Set the operand called Ref 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`	`PutField.setRef(Instruction i, Operand Ref)` Set the operand called Ref 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`	`MIR_Nullary.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_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`	`Phi.setResult(Instruction i, Operand Result)` Set the operand called Result 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`	`Binary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`InstanceOf.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Call.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Multianewarray.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`ALoad.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Move.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`NewArray.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GetStatic.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`TypeCheck.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Lea.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`CondMove.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Unary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Nullary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GetField.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Load.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Prepare.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`New.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Call.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Attempt.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`ResultCarrier.setResult(Instruction i, RegisterOperand op)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 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.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 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_Call.setResult2(Instruction i, RegisterOperand 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_DoubleShift.setSource(Instruction i, RegisterOperand Source)` Set the operand called Source in the argument instruction to the argument operand.
`static void`	`Goto.setTarget(Instruction i, BranchOperand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch.setTarget(Instruction i, BranchOperand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`InlineGuard.setTarget(Instruction i, BranchOperand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`IfCmp.setTarget(Instruction i, BranchOperand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`MIR_Branch.setTarget(Instruction i, BranchOperand Target)` Set the operand called Target in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setTarget(Instruction i, int k, BranchOperand o)` Set the k'th operand called Target in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setTarget(Instruction i, int k, BranchOperand o)` Set the k'th operand called Target in the argument instruction to the argument operand.
`static void`	`TableSwitch.setTarget(Instruction i, int k, BranchOperand o)` Set the k'th operand called Target in the argument instruction to the argument operand.
`static void`	`LowTableSwitch.setTarget(Instruction i, int k, BranchOperand o)` Set the k'th operand called Target 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`	`IfCmp2.setTarget1(Instruction i, BranchOperand Target1)` Set the operand called Target1 in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch2.setTarget1(Instruction i, BranchOperand Target1)` Set the operand called Target1 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setTarget2(Instruction i, BranchOperand Target2)` Set the operand called Target2 in the argument instruction to the argument operand.
`static void`	`MIR_CondBranch2.setTarget2(Instruction i, BranchOperand Target2)` Set the operand called Target2 in the argument instruction to the argument operand.
`static void`	`TrapIf.setTCode(Instruction i, TrapCodeOperand TCode)` Set the operand called TCode in the argument instruction to the argument operand.
`static void`	`Trap.setTCode(Instruction i, TrapCodeOperand TCode)` Set the operand called TCode in the argument instruction to the argument operand.
`static void`	`MIR_Trap.setTrapCode(Instruction i, TrapCodeOperand TrapCode)` Set the operand called TrapCode in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setTrapCode(Instruction i, TrapCodeOperand TrapCode)` Set the operand called TrapCode 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`	`InstanceOf.setType(Instruction i, TypeOperand Type)` Set the operand called Type in the argument instruction to the argument operand.
`static void`	`Multianewarray.setType(Instruction i, TypeOperand Type)` Set the operand called Type in the argument instruction to the argument operand.
`static void`	`NewArray.setType(Instruction i, TypeOperand Type)` Set the operand called Type in the argument instruction to the argument operand.
`static void`	`TypeCheck.setType(Instruction i, TypeOperand Type)` Set the operand called Type in the argument instruction to the argument operand.
`static void`	`New.setType(Instruction i, TypeOperand Type)` Set the operand called Type in the argument instruction to the argument operand.
`static void`	`OsrBarrier.setTypeInfo(Instruction i, OsrTypeInfoOperand TypeInfo)` Set the operand called TypeInfo 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.setUnknown1(Instruction i, Operand Unknown1)` Set the operand called Unknown1 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`	`TableSwitch.setUnknown2(Instruction i, Operand Unknown2)` Set the operand called Unknown2 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`	`Move.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`	`Return.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`	`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`	`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`	`IfCmp2.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`Binary.setVal1(Instruction`

Uses of Classorg.jikesrvm.compilers.opt.ir.Instruction

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