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.
`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`	`MIRBranchOptimizations.flipConditionalBranch(Instruction cb)` Flip a conditional branch and remove the trailing goto.
`private void`	`BranchOptimizations.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`	`MIRBranchOptimizations.isFlipCandidate(Instruction cb, Instruction target)` Is a conditional branch a candidate to be flipped?
`private boolean`	`BranchOptimizations.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 boolean`	`MIRBranchOptimizations.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 abstract boolean`	`BranchOptimizationDriver.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`	`MIRBranchOptimizations.processGoto(IR ir, Instruction g, BasicBlock bb)` Perform optimizations for an unconditonal branch.
`private boolean`	`BranchOptimizations.processGoto(IR ir, Instruction g, BasicBlock bb)` Perform optimizations for a Goto.
`(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`	`MIRBranchOptimizations.processTwoTargetConditionalBranch(IR ir, Instruction cb, BasicBlock bb)` Perform optimizations for a two way conditional branch.
`private boolean`	`BranchOptimizations.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 `<parent,ebag>` 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.

Fields in org.jikesrvm.compilers.opt.instrsched with type parameters of type Instruction
`private Enumeration<Instruction>`	`DefaultPriority.instr`

Methods in org.jikesrvm.compilers.opt.instrsched that return Instruction
`Instruction`	`DefaultPriority.nextElement()`
`abstract 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 Enumeration<Instruction>`	`IREnumeration.AllInstructionsEnum.explicitInstructions` An enumeration of the explicit instructions in the IR for a basic block
`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`	`MIR_Empty.create(Operator o)` Create an instruction of the MIR_Empty instruction format.
`static Instruction`	`Empty.create(Operator o)` Create an instruction of the 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_UnaryAcc.create(Operator o, Operand Result)` Create an instruction of the MIR_UnaryAcc instruction format.
`static Instruction`	`MIR_UnaryNoRes.create(Operator o, Operand Val)` Create an instruction of the MIR_UnaryNoRes instruction format.
`static Instruction`	`CacheOp.create(Operator o, Operand Ref)` Create an instruction of the CacheOp instruction format.
`static Instruction`	`MIR_CacheOp.create(Operator o, Operand Address)` Create an instruction of the MIR_CacheOp instruction format.
`static Instruction`	`Athrow.create(Operator o, Operand Value)` Create an instruction of the Athrow instruction format.
`static Instruction`	`Return.create(Operator o, Operand Val)` Create an instruction of the Return instruction format.
`static Instruction`	`MIR_Nullary.create(Operator o, Operand Result)` Create an instruction of the MIR_Nullary instruction format.
`static Instruction`	`MIR_FSave.create(Operator o, Operand Destination)` Create an instruction of the MIR_FSave instruction format.
`static Instruction`	`MIR_Set.create(Operator o, Operand Result, IA32ConditionOperand Cond)` Create an instruction of the MIR_Set instruction format.
`static Instruction`	`Phi.create(Operator o, Operand Result, int numVarOps)` Create an instruction of the Phi instruction format.
`static Instruction`	`MIR_ConvertDW2QW.create(Operator o, Operand Result1, Operand Result2)` Create an instruction of the MIR_ConvertDW2QW instruction format.
`static Instruction`	`MonitorOp.create(Operator o, Operand Ref, Operand Guard)` Create an instruction of the MonitorOp instruction format.
`static Instruction`	`MIR_Move.create(Operator o, Operand Result, Operand Value)` Create an instruction of the MIR_Move instruction format.
`static Instruction`	`MIR_XChng.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_XChng instruction format.
`static Instruction`	`MIR_BinaryAcc.create(Operator o, Operand Result, Operand Value)` Create an instruction of the MIR_BinaryAcc instruction format.
`static Instruction`	`MIR_Compare.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_Compare instruction format.
`static Instruction`	`MIR_Test.create(Operator o, Operand Val1, Operand Val2)` Create an instruction of the MIR_Test instruction format.
`static Instruction`	`MIR_Unary.create(Operator o, Operand Result, Operand Val)` Create an instruction of the MIR_Unary instruction format.
`static Instruction`	`MIR_CondMove.create(Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond)` Create an instruction of the MIR_CondMove instruction format.
`static Instruction`	`PutStatic.create(Operator o, Operand Value, Operand Offset, LocationOperand Location)` Create an instruction of the PutStatic instruction format.
`static Instruction`	`GuardedSet.create(Operator o, Operand Ref, Operand Val, Operand Guard)` Create an instruction of the GuardedSet instruction format.
`static Instruction`	`MIR_Multiply.create(Operator o, Operand Result1, Operand Result2, Operand Value)` Create an instruction of the MIR_Multiply instruction format.
`static Instruction`	`InlineGuard.create(Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile)` Create an instruction of the InlineGuard instruction format.
`static Instruction`	`LookupSwitch.create(Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Create an instruction of the LookupSwitch instruction format.
`static Instruction`	`TableSwitch.create(Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Create an instruction of the TableSwitch instruction format.
`static Instruction`	`Store.create(Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Store instruction format.
`static Instruction`	`PutField.create(Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the PutField instruction format.
`static Instruction`	`Store.create(Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Store instruction format.
`static Instruction`	`AStore.create(Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the AStore instruction format.
`static Instruction`	`MIR_Divide.create(Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard)` Create an instruction of the MIR_Divide instruction format.
`static Instruction`	`MIR_DoubleShift.create(Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift)` Create an instruction of the MIR_DoubleShift instruction format.
`static Instruction`	`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`	`Unary.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Unary instruction format.
`static Instruction`	`NullCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref)` Create an instruction of the NullCheck instruction format.
`static Instruction`	`ZeroCheck.create(Operator o, RegisterOperand GuardResult, Operand Value)` Create an instruction of the ZeroCheck instruction format.
`static Instruction`	`Move.create(Operator o, RegisterOperand Result, Operand Val)` Create an instruction of the Move instruction format.
`static Instruction`	`GetStatic.create(Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Create an instruction of the GetStatic instruction format.
`static Instruction`	`Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Create an instruction of the Call instruction format.
`static Instruction`	`Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Create an instruction of the Call instruction format.
`static Instruction`	`GuardedUnary.create(Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Create an instruction of the GuardedUnary instruction format.
`static Instruction`	`Binary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Create an instruction of the Binary instruction format.
`static Instruction`	`IfCmp.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Create an instruction of the IfCmp instruction format.
`static Instruction`	`IfCmp2.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Create an instruction of the IfCmp2 instruction format.
`static Instruction`	`BooleanCmp.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Create an instruction of the BooleanCmp instruction format.
`static Instruction`	`CondMove.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Create an instruction of the CondMove instruction format.
`static Instruction`	`TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Create an instruction of the TrapIf instruction format.
`static Instruction`	`MIR_TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Create an instruction of the MIR_TrapIf instruction format.
`static Instruction`	`Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Load instruction format.
`static Instruction`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Create an instruction of the Prepare instruction format.
`static Instruction`	`GetField.create(Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the GetField instruction format.
`static Instruction`	`Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Load instruction format.
`static Instruction`	`ALoad.create(Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Create an instruction of the ALoad instruction format.
`static Instruction`	`Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Create an instruction of the Prepare instruction format.
`static Instruction`	`GuardedBinary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Create an instruction of the GuardedBinary instruction format.
`static Instruction`	`BoundsCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Create an instruction of the BoundsCheck instruction format.
`static Instruction`	`StoreCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Create an instruction of the StoreCheck instruction format.
`static Instruction`	`Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Create an instruction of the Attempt instruction format.
`static Instruction`	`Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Create an instruction of the Attempt instruction format.
`static Instruction`	`TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Create an instruction of the TypeCheck instruction format.
`static Instruction`	`TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Create an instruction of the TypeCheck instruction format.
`static Instruction`	`MIR_RDTSC.create(Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Create an instruction of the MIR_RDTSC instruction format.
`static Instruction`	`MIR_LowTableSwitch.create(Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Create an instruction of the MIR_LowTableSwitch instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_CompareExchange8B.create(Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Create an instruction of the MIR_CompareExchange8B instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Create an instruction of the MIR_Call instruction format.
`static Instruction`	`MIR_Trap.create(Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Create an instruction of the MIR_Trap instruction format.
`static Instruction`	`Trap.create(Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Create an instruction of the Trap instruction format.
`static Instruction`	`New.create(Operator o, RegisterOperand Result, TypeOperand Type)` Create an instruction of the New instruction format.
`static Instruction`	`Multianewarray.create(Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Create an instruction of the Multianewarray instruction format.
`static Instruction`	`NewArray.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Create an instruction of the NewArray instruction format.
`static Instruction`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Create an instruction of the InstanceOf instruction format.
`static Instruction`	`InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Create an instruction of the InstanceOf instruction format.
`static Instruction`	`Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Create an instruction of the Call instruction format with 0 variable arguments.
`static Instruction`	`Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Create an instruction of the Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Create an instruction of the MIR_Call instruction format with 0 variable arguments.
`static Instruction`	`Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Create an instruction of the Call instruction format with 1 variable arguments.
`static Instruction`	`Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Create an instruction of the Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Create an instruction of the MIR_Call instruction format with 1 variable arguments.
`static Instruction`	`Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Create an instruction of the Call instruction format with 2 variable arguments.
`static Instruction`	`Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Create an instruction of the Call instruction format with 2 variable arguments.
`static Instruction`	`Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Create an instruction of the Call instruction format with 3 variable arguments.
`static Instruction`	`Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Create an instruction of the Call instruction format with 3 variable arguments.
`static Instruction`	`Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Create an instruction of the Call instruction format with 4 variable arguments.
`static Instruction`	`Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Create an instruction of the Call instruction format with 4 variable arguments.
`static Instruction`	`Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Create an instruction of the Call instruction format with 5 variable arguments.
`static Instruction`	`Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Create an instruction of the Call instruction format with 5 variable arguments.
`static Instruction`	`Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Create an instruction of the Call instruction format with 6 variable arguments.
`static Instruction`	`Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Create an instruction of the Call instruction format with 6 variable arguments.
`static Instruction`	`Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Create an instruction of the Call instruction format with 7 variable arguments.
`static Instruction`	`Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Create an instruction of the Call instruction format with 7 variable arguments.
`static Instruction`	`Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Create an instruction of the Call instruction format with 8 variable arguments.
`static Instruction`	`Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Create an instruction of the Call instruction format with 8 variable arguments.
`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`	`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`	`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`	`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_UnaryAcc.mutate(Instruction i, Operator o, Operand Result)` Mutate the argument instruction into an instruction of the MIR_UnaryAcc instruction format having the specified operator and operands.
`static Instruction`	`MIR_UnaryNoRes.mutate(Instruction i, Operator o, Operand Val)` Mutate the argument instruction into an instruction of the MIR_UnaryNoRes instruction format having the specified operator and operands.
`static Instruction`	`CacheOp.mutate(Instruction i, Operator o, Operand Ref)` Mutate the argument instruction into an instruction of the CacheOp instruction format having the specified operator and operands.
`static Instruction`	`MIR_CacheOp.mutate(Instruction i, Operator o, Operand Address)` Mutate the argument instruction into an instruction of the MIR_CacheOp instruction format having the specified operator and operands.
`static Instruction`	`Athrow.mutate(Instruction i, Operator o, Operand Value)` Mutate the argument instruction into an instruction of the Athrow instruction format having the specified operator and operands.
`static Instruction`	`Return.mutate(Instruction i, Operator o, Operand Val)` Mutate the argument instruction into an instruction of the Return instruction format having the specified operator and operands.
`static Instruction`	`MIR_Nullary.mutate(Instruction i, Operator o, Operand Result)` Mutate the argument instruction into an instruction of the MIR_Nullary instruction format having the specified operator and operands.
`static Instruction`	`MIR_FSave.mutate(Instruction i, Operator o, Operand Destination)` Mutate the argument instruction into an instruction of the MIR_FSave instruction format having the specified operator and operands.
`static Instruction`	`MIR_Set.mutate(Instruction i, Operator o, Operand Result, IA32ConditionOperand Cond)` Mutate the argument instruction into an instruction of the MIR_Set instruction format having the specified operator and operands.
`static Instruction`	`Phi.mutate(Instruction i, Operator o, Operand Result, int numVarOps)` Mutate the argument instruction into an instruction of the Phi instruction format having the specified operator and operands.
`static Instruction`	`MIR_ConvertDW2QW.mutate(Instruction i, Operator o, Operand Result1, Operand Result2)` Mutate the argument instruction into an instruction of the MIR_ConvertDW2QW instruction format having the specified operator and operands.
`static Instruction`	`MonitorOp.mutate(Instruction i, Operator o, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the MonitorOp instruction format having the specified operator and operands.
`static Instruction`	`MIR_Move.mutate(Instruction i, Operator o, Operand Result, Operand Value)` Mutate the argument instruction into an instruction of the MIR_Move instruction format having the specified operator and operands.
`static Instruction`	`MIR_XChng.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_XChng instruction format having the specified operator and operands.
`static Instruction`	`MIR_BinaryAcc.mutate(Instruction i, Operator o, Operand Result, Operand Value)` Mutate the argument instruction into an instruction of the MIR_BinaryAcc instruction format having the specified operator and operands.
`static Instruction`	`MIR_Compare.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Compare instruction format having the specified operator and operands.
`static Instruction`	`MIR_Test.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Test instruction format having the specified operator and operands.
`static Instruction`	`MIR_Unary.mutate(Instruction i, Operator o, Operand Result, Operand Val)` Mutate the argument instruction into an instruction of the MIR_Unary instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondMove.mutate(Instruction i, Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond)` Mutate the argument instruction into an instruction of the MIR_CondMove instruction format having the specified operator and operands.
`static Instruction`	`PutStatic.mutate(Instruction i, Operator o, Operand Value, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the PutStatic instruction format having the specified operator and operands.
`static Instruction`	`GuardedSet.mutate(Instruction i, Operator o, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedSet instruction format having the specified operator and operands.
`static Instruction`	`MIR_Multiply.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value)` Mutate the argument instruction into an instruction of the MIR_Multiply instruction format having the specified operator and operands.
`static Instruction`	`InlineGuard.mutate(Instruction i, Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the InlineGuard instruction format having the specified operator and operands.
`static Instruction`	`LookupSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Mutate the argument instruction into an instruction of the LookupSwitch instruction format having the specified operator and operands.
`static Instruction`	`TableSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Mutate the argument instruction into an instruction of the TableSwitch instruction format having the specified operator and operands.
`static Instruction`	`Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
`static Instruction`	`PutField.mutate(Instruction i, Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the PutField instruction format having the specified operator and operands.
`static Instruction`	`Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
`static Instruction`	`AStore.mutate(Instruction i, Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the AStore instruction format having the specified operator and operands.
`static Instruction`	`MIR_Divide.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard)` Mutate the argument instruction into an instruction of the MIR_Divide instruction format having the specified operator and operands.
`static Instruction`	`MIR_DoubleShift.mutate(Instruction i, Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift)` Mutate the argument instruction into an instruction of the MIR_DoubleShift instruction format having the specified operator and operands.
`static Instruction`	`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`	`Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Unary instruction format having the specified operator and operands.
`static Instruction`	`NullCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref)` Mutate the argument instruction into an instruction of the NullCheck instruction format having the specified operator and operands.
`static Instruction`	`ZeroCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Value)` Mutate the argument instruction into an instruction of the ZeroCheck instruction format having the specified operator and operands.
`static Instruction`	`Move.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Move instruction format having the specified operator and operands.
`static Instruction`	`GetStatic.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the GetStatic instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`GuardedUnary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedUnary instruction format having the specified operator and operands.
`static Instruction`	`Binary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the Binary instruction format having the specified operator and operands.
`static Instruction`	`IfCmp.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the IfCmp instruction format having the specified operator and operands.
`static Instruction`	`IfCmp2.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the IfCmp2 instruction format having the specified operator and operands.
`static Instruction`	`BooleanCmp.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the BooleanCmp instruction format having the specified operator and operands.
`static Instruction`	`CondMove.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Mutate the argument instruction into an instruction of the CondMove instruction format having the specified operator and operands.
`static Instruction`	`TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the TrapIf instruction format having the specified operator and operands.
`static Instruction`	`MIR_TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_TrapIf instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`GetField.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the GetField instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`ALoad.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the ALoad instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`GuardedBinary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedBinary instruction format having the specified operator and operands.
`static Instruction`	`BoundsCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Mutate the argument instruction into an instruction of the BoundsCheck instruction format having the specified operator and operands.
`static Instruction`	`StoreCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the StoreCheck instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`MIR_RDTSC.mutate(Instruction i, Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Mutate the argument instruction into an instruction of the MIR_RDTSC instruction format having the specified operator and operands.
`static Instruction`	`MIR_LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange8B.mutate(Instruction i, Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Mutate the argument instruction into an instruction of the MIR_CompareExchange8B instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
`static Instruction`	`Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the Trap instruction format having the specified operator and operands.
`static Instruction`	`New.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type)` Mutate the argument instruction into an instruction of the New instruction format having the specified operator and operands.
`static Instruction`	`Multianewarray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Mutate the argument instruction into an instruction of the Multianewarray instruction format having the specified operator and operands.
`static Instruction`	`NewArray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Mutate the argument instruction into an instruction of the NewArray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`Instruction`	`IREnumeration.AllInstructionsEnum.nextElement()`
`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 that return types with arguments of type Instruction
`Enumeration<Instruction>`	`BasicBlock.enumerateBranchInstructions()` Return an enumeration of the branch instructions in this basic block.
`static Enumeration<Instruction>`	`IREnumeration.forwardGlobalIE(IR ir)` A forward enumeration of all the instructions in the IR.
`Enumeration<Instruction>`	`BasicBlock.forwardInstrEnumerator()` Forward enumeration of all the instruction in the block.
`Enumeration<Instruction>`	`IR.forwardInstrEnumerator()` Forward (with respect to the current code linearization order) iteration over all the instructions in this IR.
`static Enumeration<Instruction>`	`IREnumeration.forwardIntraBlockIE(Instruction start, Instruction end)` Forward intra basic block instruction enumerations from from start...last inclusive.
`Enumeration<Instruction>`	`BasicBlock.forwardRealInstrEnumerator()` Forward enumeration of all the real instruction in the block.
`static Enumeration<Instruction>`	`IREnumeration.reverseGlobalIE(IR ir)` A reverse enumeration of all the instructions in the IR.
`Enumeration<Instruction>`	`BasicBlock.reverseInstrEnumerator()` Reverse enumeration of all the instruction in the block.
`Enumeration<Instruction>`	`IR.reverseInstrEnumerator()` Reverse (with respect to the current code linearization order) iteration over all the instructions in this IR.
`static Enumeration<Instruction>`	`IREnumeration.reverseIntraBlockIE(Instruction start, Instruction end)` Reverse intra basic block instruction enumerations from from start...last inclusive.
`Enumeration<Instruction>`	`BasicBlock.reverseRealInstrEnumerator()` Reverse enumeration of all the real instruction in the block.

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_ConvertDW2QW.conforms(Instruction i)` InstructionFormat identification method for MIR_ConvertDW2QW.
`static boolean`	`TableSwitch.conforms(Instruction i)` InstructionFormat identification method for TableSwitch.
`static boolean`	`MIR_Set.conforms(Instruction i)` InstructionFormat identification method for MIR_Set.
`static boolean`	`New.conforms(Instruction i)` InstructionFormat identification method for New.
`static boolean`	`CondMove.conforms(Instruction i)` InstructionFormat identification method for CondMove.
`static boolean`	`MIR_CompareExchange.conforms(Instruction i)` InstructionFormat identification method for MIR_CompareExchange.
`static boolean`	`IfCmp2.conforms(Instruction i)` InstructionFormat identification method for IfCmp2.
`static boolean`	`LowTableSwitch.conforms(Instruction i)` InstructionFormat identification method for LowTableSwitch.
`static boolean`	`Call.conforms(Instruction i)` InstructionFormat identification method for Call.
`static boolean`	`MIR_UnaryAcc.conforms(Instruction i)` InstructionFormat identification method for MIR_UnaryAcc.
`static boolean`	`GuardedBinary.conforms(Instruction i)` InstructionFormat identification method for GuardedBinary.
`static boolean`	`MonitorOp.conforms(Instruction i)` InstructionFormat identification method for MonitorOp.
`static boolean`	`MIR_Move.conforms(Instruction i)` InstructionFormat identification method for MIR_Move.
`static boolean`	`NewArray.conforms(Instruction i)` InstructionFormat identification method for NewArray.
`static boolean`	`GuardedUnary.conforms(Instruction i)` InstructionFormat identification method for GuardedUnary.
`static boolean`	`MIR_UnaryNoRes.conforms(Instruction i)` InstructionFormat identification method for MIR_UnaryNoRes.
`static boolean`	`MIR_Return.conforms(Instruction i)` InstructionFormat identification method for MIR_Return.
`static boolean`	`BoundsCheck.conforms(Instruction i)` InstructionFormat identification method for BoundsCheck.
`static boolean`	`TypeCheck.conforms(Instruction i)` InstructionFormat identification method for TypeCheck.
`static boolean`	`GetField.conforms(Instruction i)` InstructionFormat identification method for GetField.
`static boolean`	`MIR_LowTableSwitch.conforms(Instruction i)` InstructionFormat identification method for MIR_LowTableSwitch.
`static boolean`	`Goto.conforms(Instruction i)` InstructionFormat identification method for Goto.
`static boolean`	`Load.conforms(Instruction i)` InstructionFormat identification method for Load.
`static boolean`	`GuardCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called Guard?
`static boolean`	`Binary.conforms(Instruction i)` InstructionFormat identification method for Binary.
`static boolean`	`MIR_Empty.conforms(Instruction i)` InstructionFormat identification method for MIR_Empty.
`static boolean`	`GuardResultCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called GuardResult?
`static boolean`	`MIR_TrapIf.conforms(Instruction i)` InstructionFormat identification method for MIR_TrapIf.
`static boolean`	`InstrumentedCounter.conforms(Instruction i)` InstructionFormat identification method for InstrumentedCounter.
`static boolean`	`MIR_RDTSC.conforms(Instruction i)` InstructionFormat identification method for MIR_RDTSC.
`static boolean`	`Empty.conforms(Instruction i)` InstructionFormat identification method for Empty.
`static boolean`	`GuardedSet.conforms(Instruction i)` InstructionFormat identification method for GuardedSet.
`static boolean`	`PutField.conforms(Instruction i)` InstructionFormat identification method for PutField.
`static boolean`	`MIR_CaseLabel.conforms(Instruction i)` InstructionFormat identification method for MIR_CaseLabel.
`static boolean`	`CacheOp.conforms(Instruction i)` InstructionFormat identification method for CacheOp.
`static boolean`	`OsrPoint.conforms(Instruction i)` InstructionFormat identification method for OsrPoint.
`static boolean`	`Multianewarray.conforms(Instruction i)` InstructionFormat identification method for Multianewarray.
`static boolean`	`MIR_XChng.conforms(Instruction i)` InstructionFormat identification method for MIR_XChng.
`static boolean`	`MIR_CacheOp.conforms(Instruction i)` InstructionFormat identification method for MIR_CacheOp.
`static boolean`	`Attempt.conforms(Instruction i)` InstructionFormat identification method for Attempt.
`static boolean`	`MIR_Lea.conforms(Instruction i)` InstructionFormat identification method for MIR_Lea.
`static boolean`	`MIR_Divide.conforms(Instruction i)` InstructionFormat identification method for MIR_Divide.
`static boolean`	`MIR_Call.conforms(Instruction i)` InstructionFormat identification method for MIR_Call.
`static boolean`	`LocationCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called Location?
`static boolean`	`MIR_Trap.conforms(Instruction i)` InstructionFormat identification method for MIR_Trap.
`static boolean`	`Prologue.conforms(Instruction i)` InstructionFormat identification method for Prologue.
`static boolean`	`ALoad.conforms(Instruction i)` InstructionFormat identification method for ALoad.
`static boolean`	`Unary.conforms(Instruction i)` InstructionFormat identification method for Unary.
`static boolean`	`MIR_CondMove.conforms(Instruction i)` InstructionFormat identification method for MIR_CondMove.
`static boolean`	`Nullary.conforms(Instruction i)` InstructionFormat identification method for Nullary.
`static boolean`	`BooleanCmp.conforms(Instruction i)` InstructionFormat identification method for BooleanCmp.
`static boolean`	`MIR_BinaryAcc.conforms(Instruction i)` InstructionFormat identification method for MIR_BinaryAcc.
`static boolean`	`Trap.conforms(Instruction i)` InstructionFormat identification method for Trap.
`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`	`IfCmp.conforms(Instruction i)` InstructionFormat identification method for IfCmp.
`static boolean`	`StoreCheck.conforms(Instruction i)` InstructionFormat identification method for StoreCheck.
`static boolean`	`TrapIf.conforms(Instruction i)` InstructionFormat identification method for TrapIf.
`static boolean`	`BranchProfileCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called BranchProfile?
`static boolean`	`MIR_CompareExchange8B.conforms(Instruction i)` InstructionFormat identification method for MIR_CompareExchange8B.
`static boolean`	`MIR_Multiply.conforms(Instruction i)` InstructionFormat identification method for MIR_Multiply.
`static boolean`	`LookupSwitch.conforms(Instruction i)` InstructionFormat identification method for LookupSwitch.
`static boolean`	`Athrow.conforms(Instruction i)` InstructionFormat identification method for Athrow.
`static boolean`	`Label.conforms(Instruction i)` InstructionFormat identification method for Label.
`static boolean`	`InstanceOf.conforms(Instruction i)` InstructionFormat identification method for InstanceOf.
`static boolean`	`Return.conforms(Instruction i)` InstructionFormat identification method for Return.
`static boolean`	`BBend.conforms(Instruction i)` InstructionFormat identification method for BBend.
`static boolean`	`InlineGuard.conforms(Instruction i)` InstructionFormat identification method for InlineGuard.
`static boolean`	`MIR_Compare.conforms(Instruction i)` InstructionFormat identification method for MIR_Compare.
`static boolean`	`MIR_DoubleShift.conforms(Instruction i)` InstructionFormat identification method for MIR_DoubleShift.
`static boolean`	`Store.conforms(Instruction i)` InstructionFormat identification method for Store.
`static boolean`	`ZeroCheck.conforms(Instruction i)` InstructionFormat identification method for ZeroCheck.
`static boolean`	`Move.conforms(Instruction i)` InstructionFormat identification method for Move.
`static boolean`	`GetStatic.conforms(Instruction i)` InstructionFormat identification method for GetStatic.
`static boolean`	`MIR_CondBranch2.conforms(Instruction i)` InstructionFormat identification method for MIR_CondBranch2.
`static boolean`	`MIR_Branch.conforms(Instruction i)` InstructionFormat identification method for MIR_Branch.
`static boolean`	`ResultCarrier.conforms(Instruction i)` Does the instruction belong to an instruction format that has an operand called Result?
`static boolean`	`MIR_Test.conforms(Instruction i)` InstructionFormat identification method for MIR_Test.
`static boolean`	`MIR_Unary.conforms(Instruction i)` InstructionFormat identification method for MIR_Unary.
`static boolean`	`AStore.conforms(Instruction i)` InstructionFormat identification method for AStore.
`static boolean`	`PutStatic.conforms(Instruction i)` InstructionFormat identification method for PutStatic.
`static boolean`	`Phi.conforms(Instruction i)` InstructionFormat identification method for Phi.
`static boolean`	`MIR_Nullary.conforms(Instruction i)` InstructionFormat identification method for MIR_Nullary.
`static boolean`	`OsrBarrier.conforms(Instruction i)` InstructionFormat identification method for OsrBarrier.
`static boolean`	`Prepare.conforms(Instruction i)` InstructionFormat identification method for Prepare.
`static boolean`	`MIR_FSave.conforms(Instruction i)` InstructionFormat identification method for MIR_FSave.
`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 Enumeration<Instruction>`	`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`	`Load.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`MIR_CacheOp.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Attempt.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Store.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`static Operand`	`Prepare.getAddress(Instruction i)` Get the operand called Address from the argument instruction.
`Enumeration<BasicBlock>`	`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`	`BooleanCmp.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`	`IfCmp.getBranchProfile(Instruction i)` Get the operand called BranchProfile from the argument instruction.
`static BranchProfileOperand`	`BranchProfileCarrier.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`	`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`	`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`	`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`	`Load.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CacheOp.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`Prepare.getClearAddress(Instruction i)` Get the operand called Address from the argument instruction clearing its instruction pointer.
`static Operand`	`ALoad.getClearArray(Instruction i)` Get the operand called Array from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearArray(Instruction i)` Get the operand called Array from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_DoubleShift.getClearBitsToShift(Instruction i)` Get the operand called BitsToShift from the argument instruction clearing its instruction pointer.
`static 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`	`BooleanCmp.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`	`IfCmp.getClearBranchProfile(Instruction i)` Get the operand called BranchProfile 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`	`InlineGuard.getClearBranchProfile(Instruction i)` Get the 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`	`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`	`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_Set.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 IA32ConditionOperand`	`MIR_CondMove.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 IA32ConditionOperand`	`MIR_CondBranch.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 ConditionOperand`	`TrapIf.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`	`TableSwitch.getClearDefault(Instruction i)` Get the operand called Default 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 BranchProfileOperand`	`TableSwitch.getClearDefaultBranchProfile(Instruction i)` Get the operand called DefaultBranchProfile 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 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`	`Call.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedBinary.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`MonitorOp.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedUnary.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`BoundsCheck.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`TypeCheck.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GetField.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Load.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardCarrier.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedSet.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`ALoad.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`StoreCheck.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`InstanceOf.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`InlineGuard.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static Operand`	`Prepare.getClearGuard(Instruction i)` Get the operand called Guard from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`IfCmp2.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`BoundsCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardResultCarrier.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_TrapIf.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Trap.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`NullCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`IfCmp.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`StoreCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`TrapIf.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ZeroCheck.getClearGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction clearing its instruction pointer.
`static 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 RegisterOperand`	`LowTableSwitch.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 RegisterOperand`	`MIR_LowTableSwitch.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 IntConstantOperand`	`MIR_CaseLabel.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static Operand`	`ALoad.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearIndex(Instruction i)` Get the operand called Index from the argument instruction clearing its instruction pointer.
`static InlinedOsrTypeInfoOperand`	`OsrPoint.getClearInlinedTypeInfo(Instruction i)` Get the operand called InlinedTypeInfo 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`	`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`	`LocationCarrier.getClearLocation(Instruction i)` Get the operand called Location 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`	`Store.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`	`AStore.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 LocationOperand`	`Prepare.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`	`GetField.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Load.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Attempt.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`GetStatic.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`PutStatic.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static Operand`	`Prepare.getClearOffset(Instruction i)` Get the operand called Offset from the argument instruction clearing its instruction pointer.
`static 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`	`MonitorOp.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`BoundsCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`TypeCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`GetField.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedSet.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`CacheOp.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`NullCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`StoreCheck.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`InstanceOf.getClearRef(Instruction i)` Get the operand called Ref from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Set.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`New.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`CondMove.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Call.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_UnaryAcc.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 Operand`	`MIR_Move.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`NewArray.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GuardedUnary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`TypeCheck.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GetField.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Load.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Binary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Multianewarray.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Attempt.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Lea.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Call.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ALoad.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Unary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CondMove.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Nullary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`BooleanCmp.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_BinaryAcc.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 Operand`	`MIR_DoubleShift.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Move.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`GetStatic.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`ResultCarrier.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Unary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`Phi.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Nullary.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`Prepare.getClearResult(Instruction i)` Get the operand called Result from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_ConvertDW2QW.getClearResult1(Instruction i)` Get the operand called Result1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearResult1(Instruction i)` Get the operand called Result1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Multiply.getClearResult1(Instruction i)` Get the operand called Result1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_ConvertDW2QW.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static RegisterOperand`	`MIR_Call.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Multiply.getClearResult2(Instruction i)` Get the operand called Result2 from the argument instruction clearing its instruction pointer.
`static Operand`	`NewArray.getClearSize(Instruction i)` Get the operand called Size from the argument instruction clearing its instruction pointer.
`static 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 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`	`MIR_CondBranch.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`	`InlineGuard.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`	`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`	`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`	`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`	`Trap.getClearTCode(Instruction i)` Get the operand called TCode 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`	`MIR_TrapIf.getClearTrapCode(Instruction i)` Get the operand called TrapCode 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 Operand`	`CondMove.getClearTrueValue(Instruction i)` Get the operand called TrueValue 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 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`	`Multianewarray.getClearType(Instruction i)` Get the operand called Type 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 OsrTypeInfoOperand`	`OsrBarrier.getClearTypeInfo(Instruction i)` Get the operand called TypeInfo from the argument instruction clearing its instruction pointer.
`static Operand`	`TableSwitch.getClearUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction clearing its instruction pointer.
`static Operand`	`LookupSwitch.getClearUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction clearing its instruction pointer.
`static Operand`	`TableSwitch.getClearUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction clearing its instruction pointer.
`static Operand`	`LookupSwitch.getClearUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedUnary.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_UnaryNoRes.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Return.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedSet.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`Unary.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`StoreCheck.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`Return.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`Move.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Unary.getClearVal(Instruction i)` Get the operand called Val from the argument instruction clearing its instruction pointer.
`static Operand`	`CondMove.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp2.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedBinary.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`Binary.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_TrapIf.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_XChng.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`BooleanCmp.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`TrapIf.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Compare.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Test.getClearVal1(Instruction i)` Get the operand called Val1 from the argument instruction clearing its instruction pointer.
`static Operand`	`CondMove.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp2.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`GuardedBinary.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Return.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`Binary.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_TrapIf.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_XChng.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`BooleanCmp.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`IfCmp.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`TrapIf.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Compare.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Test.getClearVal2(Instruction i)` Get the operand called Val2 from the argument instruction clearing its instruction pointer.
`static Operand`	`TableSwitch.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Move.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`PutField.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static MemoryOperand`	`MIR_Lea.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Divide.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_CondMove.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_BinaryAcc.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`MIR_Multiply.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`LookupSwitch.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`Athrow.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`InlineGuard.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`Store.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`ZeroCheck.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`AStore.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`PutStatic.getClearValue(Instruction i)` Get the operand called Value from the argument instruction clearing its instruction pointer.
`static Operand`	`Phi.getClearValue(Instruction i, int k)` Get the k'th operand called Value from the argument instruction clearing its instruction pointer.
`static IA32ConditionOperand`	`MIR_Set.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 IA32ConditionOperand`	`MIR_CondMove.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 IA32ConditionOperand`	`MIR_CondBranch.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 ConditionOperand`	`TrapIf.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`	`TableSwitch.getDefault(Instruction i)` Get the operand called Default from the argument instruction.
`static BranchOperand`	`LookupSwitch.getDefault(Instruction i)` Get the operand called Default from the argument instruction.
`static BranchProfileOperand`	`TableSwitch.getDefaultBranchProfile(Instruction i)` Get the operand called DefaultBranchProfile from the argument instruction.
`static BranchProfileOperand`	`LookupSwitch.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`	`Call.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardedBinary.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`MonitorOp.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardedUnary.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`BoundsCheck.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`TypeCheck.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GetField.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Load.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardCarrier.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`GuardedSet.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`PutField.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Attempt.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`MIR_Divide.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`ALoad.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`StoreCheck.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`InstanceOf.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`InlineGuard.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Store.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`AStore.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static Operand`	`Prepare.getGuard(Instruction i)` Get the operand called Guard from the argument instruction.
`static RegisterOperand`	`IfCmp2.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`BoundsCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`GuardResultCarrier.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_TrapIf.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`MIR_Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`Trap.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`NullCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`IfCmp.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`StoreCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`TrapIf.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static RegisterOperand`	`ZeroCheck.getGuardResult(Instruction i)` Get the operand called GuardResult from the argument instruction.
`static 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 RegisterOperand`	`LowTableSwitch.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 RegisterOperand`	`MIR_LowTableSwitch.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 IntConstantOperand`	`MIR_CaseLabel.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static Operand`	`ALoad.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static Operand`	`AStore.getIndex(Instruction i)` Get the operand called Index from the argument instruction.
`static InlinedOsrTypeInfoOperand`	`OsrPoint.getInlinedTypeInfo(Instruction i)` Get the operand called InlinedTypeInfo 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`	`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`	`LocationCarrier.getLocation(Instruction i)` Get the operand called Location from the argument instruction.
`static LocationOperand`	`ALoad.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`	`GetStatic.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`	`PutStatic.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 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`	`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`	`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`	`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`	`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`	`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`	`Phi.getNumberOfValues(Instruction i)` How many variable-length operands called Values does the argument instruction have?
`static Operand`	`GetField.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Load.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`PutField.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Attempt.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Store.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`GetStatic.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`PutStatic.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static Operand`	`Prepare.getOffset(Instruction i)` Get the operand called Offset from the argument instruction.
`static 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`	`MonitorOp.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`BoundsCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`TypeCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`GetField.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`GuardedSet.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`PutField.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`CacheOp.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`NullCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`StoreCheck.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`InstanceOf.getRef(Instruction i)` Get the operand called Ref from the argument instruction.
`static Operand`	`MIR_Set.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`New.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`CondMove.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Call.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_UnaryAcc.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 Operand`	`MIR_Move.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`NewArray.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GuardedUnary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`TypeCheck.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GetField.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Load.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Binary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Multianewarray.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Attempt.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Lea.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`MIR_Call.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`ALoad.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Unary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_CondMove.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Nullary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`BooleanCmp.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_BinaryAcc.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 Operand`	`MIR_DoubleShift.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Move.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`GetStatic.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`ResultCarrier.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Unary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`Phi.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_Nullary.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static RegisterOperand`	`Prepare.getResult(Instruction i)` Get the operand called Result from the argument instruction.
`static Operand`	`MIR_ConvertDW2QW.getResult1(Instruction i)` Get the operand called Result1 from the argument instruction.
`static Operand`	`MIR_Divide.getResult1(Instruction i)` Get the operand called Result1 from the argument instruction.
`static Operand`	`MIR_Multiply.getResult1(Instruction i)` Get the operand called Result1 from the argument instruction.
`static Operand`	`MIR_ConvertDW2QW.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`MIR_Divide.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static RegisterOperand`	`MIR_Call.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`MIR_Multiply.getResult2(Instruction i)` Get the operand called Result2 from the argument instruction.
`static Operand`	`NewArray.getSize(Instruction i)` Get the operand called Size from the argument instruction.
`static 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 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`	`MIR_CondBranch.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`	`InlineGuard.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`	`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`	`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`	`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`	`Trap.getTCode(Instruction i)` Get the operand called TCode from the argument instruction.
`static TrapCodeOperand`	`TrapIf.getTCode(Instruction i)` Get the operand called TCode from the argument instruction.
`static TrapCodeOperand`	`MIR_TrapIf.getTrapCode(Instruction i)` Get the operand called TrapCode from the argument instruction.
`static TrapCodeOperand`	`MIR_Trap.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`	`New.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`	`Multianewarray.getType(Instruction i)` Get the operand called Type from the argument instruction.
`static TypeOperand`	`InstanceOf.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`	`TableSwitch.getUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction.
`static Operand`	`LookupSwitch.getUnknown1(Instruction i)` Get the operand called Unknown1 from the argument instruction.
`static Operand`	`TableSwitch.getUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction.
`static Operand`	`LookupSwitch.getUnknown2(Instruction i)` Get the operand called Unknown2 from the argument instruction.
`static Operand`	`GuardedUnary.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`MIR_UnaryNoRes.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`MIR_Return.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`GuardedSet.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`Unary.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`StoreCheck.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`Return.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`Move.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`MIR_Unary.getVal(Instruction i)` Get the operand called Val from the argument instruction.
`static Operand`	`CondMove.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`IfCmp2.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`GuardedBinary.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`Binary.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_TrapIf.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_XChng.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`BooleanCmp.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`IfCmp.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`TrapIf.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_Compare.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`MIR_Test.getVal1(Instruction i)` Get the operand called Val1 from the argument instruction.
`static Operand`	`CondMove.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`IfCmp2.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`GuardedBinary.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_Return.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`Binary.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_TrapIf.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_XChng.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`BooleanCmp.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`IfCmp.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`TrapIf.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_Compare.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`MIR_Test.getVal2(Instruction i)` Get the operand called Val2 from the argument instruction.
`static Operand`	`TableSwitch.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_Move.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`PutField.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static MemoryOperand`	`MIR_Lea.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_Divide.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_CondMove.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_BinaryAcc.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`MIR_Multiply.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`LookupSwitch.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`Athrow.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`InlineGuard.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`Store.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`ZeroCheck.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`AStore.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`PutStatic.getValue(Instruction i)` Get the operand called Value from the argument instruction.
`static Operand`	`Phi.getValue(Instruction i, int k)` Get the k'th operand called Value from the argument instruction.
`static boolean`	`Call.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`	`MIR_CacheOp.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`	`Store.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?
`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`	`BooleanCmp.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`	`IfCmp.hasBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named BranchProfile?
`static boolean`	`BranchProfileCarrier.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`	`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`	`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`	`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`	`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_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`	`MIR_Set.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`	`MIR_CondMove.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`	`MIR_CondBranch.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`	`TrapIf.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`	`TableSwitch.hasDefault(Instruction i)` Does the argument instruction have a non-null operand named Default?
`static boolean`	`LookupSwitch.hasDefault(Instruction i)` Does the argument instruction have a non-null operand named Default?
`static boolean`	`TableSwitch.hasDefaultBranchProfile(Instruction i)` Does the argument instruction have a non-null operand named DefaultBranchProfile?
`static boolean`	`LookupSwitch.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`	`Call.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`	`GuardedUnary.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`	`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`	`GuardCarrier.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`	`PutField.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`	`ALoad.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`	`InstanceOf.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`	`Store.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`	`Prepare.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`	`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`	`MIR_Trap.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`	`NullCheck.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`	`StoreCheck.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`	`ZeroCheck.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`	`LowTableSwitch.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_LowTableSwitch.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_CaseLabel.hasIndex(Instruction i)` Does the argument instruction have a non-null operand named Index?
`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`	`OsrPoint.hasInlinedTypeInfo(Instruction i)` Does the argument instruction have a non-null operand named InlinedTypeInfo?
`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`	`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`	`LocationCarrier.hasLocation(Instruction i)` Does the argument instruction have a non-null operand named Location?
`static boolean`	`ALoad.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`	`GetStatic.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`	`PutStatic.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`	`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`	`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`	`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`	`Store.hasOffset(Instruction i)` Does the argument instruction have a non-null operand named Offset?
`static boolean`	`GetStatic.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`	`Prepare.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`	`MonitorOp.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`	`GuardedSet.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`	`CacheOp.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`	`InstanceOf.hasRef(Instruction i)` Does the argument instruction have a non-null operand named Ref?
`static boolean`	`MIR_Set.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`	`CondMove.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`	`MIR_UnaryAcc.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`	`MIR_Move.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`	`GuardedUnary.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`	`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`	`Binary.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`	`Attempt.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`	`MIR_Call.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`	`Unary.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`	`Nullary.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_BinaryAcc.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`	`MIR_DoubleShift.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`	`GetStatic.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_Unary.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_Nullary.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`	`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.hasResult1(Instruction i)` Does the argument instruction have a non-null operand named Result1?
`static boolean`	`MIR_ConvertDW2QW.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`	`MIR_Call.hasResult2(Instruction i)` Does the argument instruction have a non-null operand named Result2?
`static boolean`	`MIR_Multiply.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_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`	`MIR_CondBranch.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`	`InlineGuard.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`	`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`	`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`	`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`	`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`	`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`	`Trap.hasTCode(Instruction i)` Does the argument instruction have a non-null operand named TCode?
`static boolean`	`TrapIf.hasTCode(Instruction i)` Does the argument instruction have a non-null operand named TCode?
`static boolean`	`MIR_TrapIf.hasTrapCode(Instruction i)` Does the argument instruction have a non-null operand named TrapCode?
`static boolean`	`MIR_Trap.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`	`New.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`	`Multianewarray.hasType(Instruction i)` Does the argument instruction have a non-null operand named Type?
`static boolean`	`InstanceOf.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`	`TableSwitch.hasUnknown1(Instruction i)` Does the argument instruction have a non-null operand named Unknown1?
`static boolean`	`LookupSwitch.hasUnknown1(Instruction i)` Does the argument instruction have a non-null operand named Unknown1?
`static boolean`	`TableSwitch.hasUnknown2(Instruction i)` Does the argument instruction have a non-null operand named Unknown2?
`static boolean`	`LookupSwitch.hasUnknown2(Instruction i)` Does the argument instruction have a non-null operand named Unknown2?
`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`	`MIR_Return.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`	`StoreCheck.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`	`Move.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`MIR_Unary.hasVal(Instruction i)` Does the argument instruction have a non-null operand named Val?
`static boolean`	`CondMove.hasVal1(Instruction i)` Does the argument instruction have a non-null operand named Val1?
`static boolean`	`IfCmp2.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`	`Binary.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`	`MIR_XChng.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`	`IfCmp.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`	`MIR_Compare.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`	`CondMove.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`IfCmp2.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_Return.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_TrapIf.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`	`BooleanCmp.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`	`TrapIf.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_Test.hasVal2(Instruction i)` Does the argument instruction have a non-null operand named Val2?
`static boolean`	`TableSwitch.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`	`PutField.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`	`MIR_Divide.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`	`MIR_BinaryAcc.hasValue(Instruction i)` Does the argument instruction have a non-null operand named Value?
`static boolean`	`MIR_Multiply.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`	`Athrow.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`	`Store.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`	`AStore.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`	`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`	`Load.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`	`Attempt.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`	`Prepare.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`	`BooleanCmp.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`	`IfCmp.indexOfBranchProfile(Instruction i)` Return the index of the operand called BranchProfile in the argument instruction.
`static int`	`BranchProfileCarrier.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`	`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`	`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`	`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`	`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_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`	`MIR_Set.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`	`MIR_CondMove.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`	`MIR_CondBranch.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`	`TrapIf.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`	`TableSwitch.indexOfDefault(Instruction i)` Return the index of the operand called Default 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.indexOfDefaultBranchProfile(Instruction i)` Return the index of the operand called DefaultBranchProfile in the argument instruction.
`static int`	`LookupSwitch.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`	`Call.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`	`GuardedUnary.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`	`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`	`GuardCarrier.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`	`PutField.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`	`ALoad.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`	`InstanceOf.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`	`Store.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`	`Prepare.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`	`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`	`MIR_Trap.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`	`NullCheck.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`	`StoreCheck.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`	`ZeroCheck.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`	`LowTableSwitch.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_LowTableSwitch.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_CaseLabel.indexOfIndex(Instruction i)` Return the index of the operand called Index 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`	`OsrPoint.indexOfInlinedTypeInfo(Instruction i)` Return the index of the operand called InlinedTypeInfo 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`	`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`	`LocationCarrier.indexOfLocation(Instruction i)` Return the index of the operand called Location in the argument instruction.
`static int`	`ALoad.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`	`GetStatic.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`	`PutStatic.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`	`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`	`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`	`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`	`Store.indexOfOffset(Instruction i)` Return the index of the operand called Offset in the argument instruction.
`static int`	`GetStatic.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`	`Prepare.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`	`MonitorOp.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`	`GuardedSet.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`	`CacheOp.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`	`InstanceOf.indexOfRef(Instruction i)` Return the index of the operand called Ref 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`	`New.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`	`Call.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`	`GuardedBinary.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`	`NewArray.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`	`TypeCheck.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`	`Binary.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`	`Attempt.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`	`MIR_Call.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`	`Unary.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`	`Nullary.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_BinaryAcc.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`	`MIR_DoubleShift.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`	`GetStatic.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_Unary.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_Nullary.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`	`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.indexOfResult1(Instruction i)` Return the index of the operand called Result1 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_Divide.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_Multiply.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_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`	`MIR_CondBranch.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`	`InlineGuard.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`	`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`	`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`	`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`	`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`	`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`	`Trap.indexOfTCode(Instruction i)` Return the index of the operand called TCode in the argument instruction.
`static int`	`TrapIf.indexOfTCode(Instruction i)` Return the index of the operand called TCode 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`	`MIR_Trap.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`	`New.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`	`Multianewarray.indexOfType(Instruction i)` Return the index of the operand called Type in the argument instruction.
`static int`	`InstanceOf.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`	`TableSwitch.indexOfUnknown1(Instruction i)` Return the index of the operand called Unknown1 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.indexOfUnknown2(Instruction i)` Return the index of the operand called Unknown2 in the argument instruction.
`static int`	`LookupSwitch.indexOfUnknown2(Instruction i)` Return the index of the operand called Unknown2 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`	`MIR_Return.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`	`StoreCheck.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`	`Move.indexOfVal(Instruction i)` Return the index of the operand called Val 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`	`CondMove.indexOfVal1(Instruction i)` Return the index of the operand called Val1 in the argument instruction.
`static int`	`IfCmp2.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`	`Binary.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`	`MIR_XChng.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`	`IfCmp.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`	`MIR_Compare.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`	`CondMove.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`IfCmp2.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_Return.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_TrapIf.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`	`BooleanCmp.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`	`TrapIf.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_Test.indexOfVal2(Instruction i)` Return the index of the operand called Val2 in the argument instruction.
`static int`	`TableSwitch.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`	`PutField.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`	`MIR_Divide.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`	`MIR_BinaryAcc.indexOfValue(Instruction i)` Return the index of the operand called Value 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`	`LookupSwitch.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`	`InlineGuard.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`	`ZeroCheck.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`	`PutStatic.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`	`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`	`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`	`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_UnaryAcc.mutate(Instruction i, Operator o, Operand Result)` Mutate the argument instruction into an instruction of the MIR_UnaryAcc instruction format having the specified operator and operands.
`static Instruction`	`MIR_UnaryNoRes.mutate(Instruction i, Operator o, Operand Val)` Mutate the argument instruction into an instruction of the MIR_UnaryNoRes instruction format having the specified operator and operands.
`static Instruction`	`CacheOp.mutate(Instruction i, Operator o, Operand Ref)` Mutate the argument instruction into an instruction of the CacheOp instruction format having the specified operator and operands.
`static Instruction`	`MIR_CacheOp.mutate(Instruction i, Operator o, Operand Address)` Mutate the argument instruction into an instruction of the MIR_CacheOp instruction format having the specified operator and operands.
`static Instruction`	`Athrow.mutate(Instruction i, Operator o, Operand Value)` Mutate the argument instruction into an instruction of the Athrow instruction format having the specified operator and operands.
`static Instruction`	`Return.mutate(Instruction i, Operator o, Operand Val)` Mutate the argument instruction into an instruction of the Return instruction format having the specified operator and operands.
`static Instruction`	`MIR_Nullary.mutate(Instruction i, Operator o, Operand Result)` Mutate the argument instruction into an instruction of the MIR_Nullary instruction format having the specified operator and operands.
`static Instruction`	`MIR_FSave.mutate(Instruction i, Operator o, Operand Destination)` Mutate the argument instruction into an instruction of the MIR_FSave instruction format having the specified operator and operands.
`static Instruction`	`MIR_Set.mutate(Instruction i, Operator o, Operand Result, IA32ConditionOperand Cond)` Mutate the argument instruction into an instruction of the MIR_Set instruction format having the specified operator and operands.
`static Instruction`	`Phi.mutate(Instruction i, Operator o, Operand Result, int numVarOps)` Mutate the argument instruction into an instruction of the Phi instruction format having the specified operator and operands.
`static Instruction`	`MIR_ConvertDW2QW.mutate(Instruction i, Operator o, Operand Result1, Operand Result2)` Mutate the argument instruction into an instruction of the MIR_ConvertDW2QW instruction format having the specified operator and operands.
`static Instruction`	`MonitorOp.mutate(Instruction i, Operator o, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the MonitorOp instruction format having the specified operator and operands.
`static Instruction`	`MIR_Move.mutate(Instruction i, Operator o, Operand Result, Operand Value)` Mutate the argument instruction into an instruction of the MIR_Move instruction format having the specified operator and operands.
`static Instruction`	`MIR_XChng.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_XChng instruction format having the specified operator and operands.
`static Instruction`	`MIR_BinaryAcc.mutate(Instruction i, Operator o, Operand Result, Operand Value)` Mutate the argument instruction into an instruction of the MIR_BinaryAcc instruction format having the specified operator and operands.
`static Instruction`	`MIR_Compare.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Compare instruction format having the specified operator and operands.
`static Instruction`	`MIR_Test.mutate(Instruction i, Operator o, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the MIR_Test instruction format having the specified operator and operands.
`static Instruction`	`MIR_Unary.mutate(Instruction i, Operator o, Operand Result, Operand Val)` Mutate the argument instruction into an instruction of the MIR_Unary instruction format having the specified operator and operands.
`static Instruction`	`MIR_CondMove.mutate(Instruction i, Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond)` Mutate the argument instruction into an instruction of the MIR_CondMove instruction format having the specified operator and operands.
`static Instruction`	`PutStatic.mutate(Instruction i, Operator o, Operand Value, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the PutStatic instruction format having the specified operator and operands.
`static Instruction`	`GuardedSet.mutate(Instruction i, Operator o, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedSet instruction format having the specified operator and operands.
`static Instruction`	`MIR_Multiply.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value)` Mutate the argument instruction into an instruction of the MIR_Multiply instruction format having the specified operator and operands.
`static Instruction`	`InlineGuard.mutate(Instruction i, Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the InlineGuard instruction format having the specified operator and operands.
`static Instruction`	`LookupSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Mutate the argument instruction into an instruction of the LookupSwitch instruction format having the specified operator and operands.
`static Instruction`	`TableSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps)` Mutate the argument instruction into an instruction of the TableSwitch instruction format having the specified operator and operands.
`static Instruction`	`Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
`static Instruction`	`PutField.mutate(Instruction i, Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the PutField instruction format having the specified operator and operands.
`static Instruction`	`Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
`static Instruction`	`AStore.mutate(Instruction i, Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the AStore instruction format having the specified operator and operands.
`static Instruction`	`MIR_Divide.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard)` Mutate the argument instruction into an instruction of the MIR_Divide instruction format having the specified operator and operands.
`static Instruction`	`MIR_DoubleShift.mutate(Instruction i, Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift)` Mutate the argument instruction into an instruction of the MIR_DoubleShift instruction format having the specified operator and operands.
`static Instruction`	`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`	`Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Unary instruction format having the specified operator and operands.
`static Instruction`	`NullCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref)` Mutate the argument instruction into an instruction of the NullCheck instruction format having the specified operator and operands.
`static Instruction`	`ZeroCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Value)` Mutate the argument instruction into an instruction of the ZeroCheck instruction format having the specified operator and operands.
`static Instruction`	`Move.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val)` Mutate the argument instruction into an instruction of the Move instruction format having the specified operator and operands.
`static Instruction`	`GetStatic.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the GetStatic instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
`static Instruction`	`GuardedUnary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedUnary instruction format having the specified operator and operands.
`static Instruction`	`Binary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2)` Mutate the argument instruction into an instruction of the Binary instruction format having the specified operator and operands.
`static Instruction`	`IfCmp.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the IfCmp instruction format having the specified operator and operands.
`static Instruction`	`IfCmp2.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2)` Mutate the argument instruction into an instruction of the IfCmp2 instruction format having the specified operator and operands.
`static Instruction`	`BooleanCmp.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile)` Mutate the argument instruction into an instruction of the BooleanCmp instruction format having the specified operator and operands.
`static Instruction`	`CondMove.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue)` Mutate the argument instruction into an instruction of the CondMove instruction format having the specified operator and operands.
`static Instruction`	`TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the TrapIf instruction format having the specified operator and operands.
`static Instruction`	`MIR_TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_TrapIf instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`GetField.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the GetField instruction format having the specified operator and operands.
`static Instruction`	`Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
`static Instruction`	`ALoad.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the ALoad instruction format having the specified operator and operands.
`static Instruction`	`Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
`static Instruction`	`GuardedBinary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard)` Mutate the argument instruction into an instruction of the GuardedBinary instruction format having the specified operator and operands.
`static Instruction`	`BoundsCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard)` Mutate the argument instruction into an instruction of the BoundsCheck instruction format having the specified operator and operands.
`static Instruction`	`StoreCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard)` Mutate the argument instruction into an instruction of the StoreCheck instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard)` Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard)` Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
`static Instruction`	`MIR_RDTSC.mutate(Instruction i, Operator o, RegisterOperand Dest1, RegisterOperand Dest2)` Mutate the argument instruction into an instruction of the MIR_RDTSC instruction format having the specified operator and operands.
`static Instruction`	`MIR_LowTableSwitch.mutate(Instruction i, Operator o, RegisterOperand Index, RegisterOperand MethodStart, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_LowTableSwitch instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_CompareExchange8B.mutate(Instruction i, Operator o, RegisterOperand OldValueHigh, RegisterOperand OldValueLow, MemoryOperand MemAddr, RegisterOperand NewValueHigh, RegisterOperand NewValueLow)` Mutate the argument instruction into an instruction of the MIR_CompareExchange8B instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
`static Instruction`	`MIR_Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TrapCode)` Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
`static Instruction`	`Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, TrapCodeOperand TCode)` Mutate the argument instruction into an instruction of the Trap instruction format having the specified operator and operands.
`static Instruction`	`New.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type)` Mutate the argument instruction into an instruction of the New instruction format having the specified operator and operands.
`static Instruction`	`Multianewarray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, int numVarOps)` Mutate the argument instruction into an instruction of the Multianewarray instruction format having the specified operator and operands.
`static Instruction`	`NewArray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Size)` Mutate the argument instruction into an instruction of the NewArray instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard)` Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1)` Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`static Instruction`	`Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8)` Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
`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`	`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`	`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`	`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`	`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`	`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`	`Phi.resizeNumberOfValues(Instruction i, int numVarOps)` Change the number of Values that may be stored in the argument instruction to numVarOps.
`static Enumeration<Instruction>`	`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`	`Load.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`MIR_CacheOp.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Attempt.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Store.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`Prepare.setAddress(Instruction i, Operand Address)` Set the operand called Address in the argument instruction to the argument operand.
`static void`	`ALoad.setArray(Instruction i, Operand Array)` Set the operand called Array in the argument instruction to the argument operand.
`static void`	`AStore.setArray(Instruction i, Operand Array)` Set the operand called Array in the argument instruction to the argument operand.
`static void`	`MIR_DoubleShift.setBitsToShift(Instruction i, Operand BitsToShift)` Set the operand called BitsToShift in the argument instruction to the argument operand.
`static void`	`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`	`BooleanCmp.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` 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`	`IfCmp.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` Set the operand called BranchProfile 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`	`InlineGuard.setBranchProfile(Instruction i, BranchProfileOperand BranchProfile)` Set the 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`	`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`	`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`	`CondMove.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`	`IfCmp.setCond(Instruction i, ConditionOperand Cond)` Set the operand called Cond 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`	`MIR_Set.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_CondBranch.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`	`TableSwitch.setDefault(Instruction i, BranchOperand Default)` Set the operand called Default 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.setDefaultBranchProfile(Instruction i, BranchProfileOperand DefaultBranchProfile)` Set the operand called DefaultBranchProfile 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`	`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`	`Call.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`MonitorOp.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`TypeCheck.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GetField.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Load.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardCarrier.setGuard(Instruction i, Operand op)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`GuardedSet.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`PutField.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Attempt.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`ALoad.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`StoreCheck.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`InstanceOf.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`InlineGuard.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Store.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`AStore.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`Prepare.setGuard(Instruction i, Operand Guard)` Set the operand called Guard in the argument instruction to the argument operand.
`static void`	`IfCmp2.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`GuardResultCarrier.setGuardResult(Instruction i, RegisterOperand op)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`MIR_Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`Trap.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`NullCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`IfCmp.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`StoreCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`TrapIf.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`ZeroCheck.setGuardResult(Instruction i, RegisterOperand GuardResult)` Set the operand called GuardResult in the argument instruction to the argument operand.
`static void`	`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`	`InstrumentedCounter.setIndex(Instruction i, IntConstantOperand Index)` Set the operand called Index 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`	`BoundsCheck.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`ALoad.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`AStore.setIndex(Instruction i, Operand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`LowTableSwitch.setIndex(Instruction i, RegisterOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`MIR_LowTableSwitch.setIndex(Instruction i, RegisterOperand Index)` Set the operand called Index in the argument instruction to the argument operand.
`static void`	`OsrPoint.setInlinedTypeInfo(Instruction i, InlinedOsrTypeInfoOperand InlinedTypeInfo)` Set the operand called InlinedTypeInfo 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`	`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`	`LocationCarrier.setLocation(Instruction i, LocationOperand op)` Set the operand called Location 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`	`Store.setLocation(Instruction i, LocationOperand Location)` 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`	`AStore.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`	`Prepare.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`	`GetField.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Load.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`PutField.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Attempt.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Store.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`GetStatic.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`PutStatic.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Prepare.setOffset(Instruction i, Operand Offset)` Set the operand called Offset in the argument instruction to the argument operand.
`static void`	`Attempt.setOldValue(Instruction i, Operand OldValue)` Set the operand called OldValue in the argument instruction to the argument operand.
`static void`	`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`	`MonitorOp.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`BoundsCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`TypeCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`GetField.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`GuardedSet.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`PutField.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`CacheOp.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`NullCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`StoreCheck.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`InstanceOf.setRef(Instruction i, Operand Ref)` Set the operand called Ref in the argument instruction to the argument operand.
`static void`	`MIR_Set.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_UnaryAcc.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Move.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_CondMove.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_BinaryAcc.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_DoubleShift.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Unary.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Phi.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Nullary.setResult(Instruction i, Operand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`New.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`CondMove.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Call.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`NewArray.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`TypeCheck.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GetField.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Load.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Binary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Multianewarray.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Attempt.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Lea.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_Call.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`ALoad.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Unary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Nullary.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`InstanceOf.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Move.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`GetStatic.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`ResultCarrier.setResult(Instruction i, RegisterOperand op)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`Prepare.setResult(Instruction i, RegisterOperand Result)` Set the operand called Result in the argument instruction to the argument operand.
`static void`	`MIR_ConvertDW2QW.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setResult1(Instruction i, Operand Result1)` Set the operand called Result1 in the argument instruction to the argument operand.
`static void`	`MIR_ConvertDW2QW.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setResult2(Instruction i, Operand Result2)` Set the operand called Result2 in the argument instruction to the argument operand.
`static void`	`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`	`IfCmp.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`	`MIR_Branch.setTarget(Instruction i, BranchOperand Target)` Set the 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_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`	`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`	`Trap.setTCode(Instruction i, TrapCodeOperand TCode)` Set the operand called TCode 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`	`MIR_TrapIf.setTrapCode(Instruction i, TrapCodeOperand TrapCode)` Set the operand called TrapCode 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`	`CondMove.setTrueValue(Instruction i, Operand TrueValue)` Set the operand called TrueValue 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`	`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`	`Multianewarray.setType(Instruction i, TypeOperand Type)` Set the operand called Type 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`	`OsrBarrier.setTypeInfo(Instruction i, OsrTypeInfoOperand TypeInfo)` Set the operand called TypeInfo in the argument instruction to the argument operand.
`static void`	`TableSwitch.setUnknown1(Instruction i, Operand Unknown1)` Set the operand called Unknown1 in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setUnknown1(Instruction i, Operand Unknown1)` Set the operand called Unknown1 in the argument instruction to the argument operand.
`static void`	`TableSwitch.setUnknown2(Instruction i, Operand Unknown2)` Set the operand called Unknown2 in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setUnknown2(Instruction i, Operand Unknown2)` Set the operand called Unknown2 in the argument instruction to the argument operand.
`static void`	`GuardedUnary.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`MIR_UnaryNoRes.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`MIR_Return.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`GuardedSet.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`Unary.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`StoreCheck.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`Return.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`Move.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`MIR_Unary.setVal(Instruction i, Operand Val)` Set the operand called Val in the argument instruction to the argument operand.
`static void`	`CondMove.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`Binary.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_XChng.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`IfCmp.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`TrapIf.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_Compare.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`MIR_Test.setVal1(Instruction i, Operand Val1)` Set the operand called Val1 in the argument instruction to the argument operand.
`static void`	`CondMove.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`IfCmp2.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`GuardedBinary.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_Return.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`Binary.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_TrapIf.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_XChng.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`BooleanCmp.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`IfCmp.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`TrapIf.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_Compare.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`MIR_Test.setVal2(Instruction i, Operand Val2)` Set the operand called Val2 in the argument instruction to the argument operand.
`static void`	`Phi.setValue(Instruction i, int k, Operand o)` Set the k'th operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Lea.setValue(Instruction i, MemoryOperand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`TableSwitch.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Move.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`PutField.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Divide.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_CondMove.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_BinaryAcc.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`MIR_Multiply.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`LookupSwitch.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`Athrow.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`InlineGuard.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`Store.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`ZeroCheck.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`AStore.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`static void`	`PutStatic.setValue(Instruction i, Operand Value)` Set the operand called Value in the argument instruction to the argument operand.
`boolean`	`Instruction.similar(Instruction similarInstr)` Are two instructions similar, i.e. having the same operator and the same number of similar operands?
`BasicBlock`	`BasicBlock.splitNodeAt(Instruction last_instr_BB1, IR ir)` Splits a node at an instruction point.
`BasicBlock`	`BasicBlock.splitNodeWithLinksAt(Instruction last_instr_BB1, IR ir)` Splits a node at an instruction point.
`boolean`	`IR.strictFP(Instruction... is)` Should strictfp be adhered to for the given instructions?
`static boolean`	`IRTools.usedIn(Register r, Instruction s)` Does instruction s use register r?
`static boolean`	`IRTools.useDoublesAsDef(Operand u, Instruction s)` Is the operand u, which is a use in instruction s, also a def in instruction s?

Constructors in org.jikesrvm.compilers.opt.ir with parameters of type Instruction
`GCIRMapElement(Instruction inst, List<RegSpillListElement> regSpillList)` Constructor
`Instruction.BASE_OE(Instruction instr, int start, int end)`
`Instruction.MOE(Instruction instr, int start, int end)`
`Instruction.OE(Instruction instr, int start, int end, int defEnd)`
`Instruction.OEDefsOnly(Instruction instr, int start, int end)`
`Instruction.ROE(Instruction instr, int start, int end)`
`IREnumeration.AllDefsEnum(IR ir, Instruction instr)` Construct/initialize object
`IREnumeration.AllUsesEnum(IR ir, Instruction instr)` Construct/initialize object

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

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

Methods in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type Instruction
`Operand`	`RegisterPool.makeJTOCOp(IR ir, Instruction s)` Return a constant operand that is the base address of the JTOC.
`boolean`	`MachineSpecificIRIA.IA32.mayEscapeMethod(Instruction instruction)`
`boolean`	`MachineSpecificIRIA.EM64T.mayEscapeMethod(Instruction instruction)`
`boolean`	`MachineSpecificIRIA.IA32.mayEscapeThread(Instruction instruction)`
`boolean`	`MachineSpecificIRIA.EM64T.mayEscapeThread(Instruction instruction)`
`void`	`MachineSpecificIRIA.mutateMIRCondBranch(Instruction cb)`

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

Fields in org.jikesrvm.compilers.opt.ir.operand declared as Instruction
`Instruction`	`Operand.instruction` Handle back to containing instruction.
`Instruction`	`BranchOperand.target` Target of this branch.

Methods in org.jikesrvm.compilers.opt.ir.operand that return Instruction
`Instruction`	`HeapOperand.getInstruction()` Return the instruction associated with this operand.

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type Instruction
`void`	`HeapOperand.setInstruction(Instruction s)` Associate this operand with a given instruction.

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type Instruction
`BranchOperand(Instruction targ)` Construct a new branch operand with the given target.

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

Fields in org.jikesrvm.compilers.opt.lir2mir declared as Instruction
`protected Instruction`	`BURS.lastInstr`

Methods in org.jikesrvm.compilers.opt.lir2mir that return Instruction
`protected static Instruction`	`BURS_Common_Helpers.P(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLLLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLLLLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLLRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLLRLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLLRLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLRLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLRLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLLRLLR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLRLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLRLLRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PLRR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLLR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLLRLLL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRLRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRR(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRRL(ArchitectureSpecificOpt.BURS_TreeNode p)`
`protected static Instruction`	`BURS_Common_Helpers.PRRR(ArchitectureSpecificOpt.BURS_TreeNode p)`

Methods in org.jikesrvm.compilers.opt.lir2mir with parameters of type Instruction
`protected int`	`BURS_MemOp_Helpers.ADDRESS_EQUAL(Instruction store, Instruction load, int trueCost)`
`protected int`	`BURS_MemOp_Helpers.ADDRESS_EQUAL(Instruction store, Instruction load, int trueCost, int falseCost)`
`void`	`BURS.append(Instruction instruction)` Appends an instruction, i.e. emits an MIR instruction.
`protected int`	`BURS_MemOp_Helpers.ARRAY_ADDRESS_EQUAL(Instruction store, Instruction load, int trueCost)`
`protected int`	`BURS_MemOp_Helpers.ARRAY_ADDRESS_EQUAL(Instruction store, Instruction load, int trueCost, int falseCost)`
`private ArchitectureSpecificOpt.BURS_TreeNode`	`MinimalBURS.buildTree(Instruction s)` Build a BURS Tree for each Instruction.
`protected void`	`BURS_Common_Helpers.EMIT(Instruction s)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_AL(Instruction s, byte scale, byte size)` Construct a memory operand for the effective address of the array load instruction
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_AL(Instruction s, byte scale, byte size, int disp)` Construct a memory operand for the effective address of the array load instruction
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_AS(Instruction s, byte scale, byte size)` Construct a memory operand for the effective address of the array store instruction
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_AS(Instruction s, byte scale, byte size, int disp)`
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_L(Instruction s, byte size)` Construct a memory operand for the effective address of the load instruction
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_L(Instruction s, byte size, int disp)` Construct a displaced memory operand for the effective address of the load instruction
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_MC(Instruction s)` Construct memory operand for a MATERIALIZE_FP_CONSTANT
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_S(Instruction s, byte size)` Construct a memory operand for the effective address of the store instruction
`protected MemoryOperand`	`BURS_MemOp_Helpers.MO_S(Instruction s, byte size, int disp)` Construct a displaced memory operand for the effective address of the store instruction

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

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 that return Instruction
`private static Instruction`	`ComplexLIR2MIRExpansion.double_2int(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.double_2long(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.float_2int(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.float_2long(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.fp_ifcmp(Instruction s)`
`Instruction`	`BURS_TreeNode.getInstruction()`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_ifcmp_imm(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_ifcmp(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_mul(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_shl(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_shr(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_ushr(Instruction s, IR ir)`

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 with parameters of type Instruction
`(package private) static Operand`	`NormalizeConstants.asImmediateOrReg(Operand addr, Instruction s, IR ir)` IA32 supports 32 bit int immediates, so nothing to do.
`private Operand`	`BURS_Helpers.asReg(Instruction s, Operator movop, Operand op)` Move op into a register operand if it isn't one already.
`private static void`	`ComplexLIR2MIRExpansion.basic_long_ifcmp(Instruction s, IR ir, ConditionOperand cond, Register xh, Register xl, Operand yh, Operand yl)`
`protected void`	`BURS_Helpers.BOOLEAN_CMP_DOUBLE(Instruction s, RegisterOperand res, ConditionOperand cond, Operand val1, Operand val2)` Expansion of BOOLEAN_CMP_DOUBLE
`protected void`	`BURS_Helpers.BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, ConditionOperand cond)` Expansion of a special case of BOOLEAN_CMP_INT when the condition registers have already been set by the previous ALU op.
`protected void`	`BURS_Helpers.BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Expansion of BOOLEAN_CMP_INT
`protected void`	`BURS_Helpers.BOOLEAN_CMP_LONG(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Expansion of BOOLEAN_CMP_LONG
`protected void`	`BURS_Helpers.CALL(Instruction s, Operand address)` Expansion of CALL.
`protected void`	`BURS_Helpers.CMOV_FMOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate a floating point move portion of a conditional move.
`protected void`	`BURS_Helpers.CMOV_MOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate an integer move portion of a conditional move.
`private static Instruction`	`ComplexLIR2MIRExpansion.double_2int(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.double_2long(Instruction s, IR ir)`
`protected void`	`BURS_Helpers.EMIT_Commutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` Create the MIR instruction given by operator from the Binary LIR operands
`protected void`	`BURS_Helpers.EMIT_Lea(Instruction s, RegisterOperand result, MemoryOperand mo)` Create the MIR LEA instruction performing a few simplifications if possible
`protected void`	`BURS_Helpers.EMIT_NonCommutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` Create the MIR instruction given by operator from the Binary LIR operands
`protected void`	`BURS_Helpers.EMIT_Unary(Operator operator, Instruction s, Operand result, Operand value)` Create the MIR instruction given by operator from the Binary LIR operands
`private static Instruction`	`ComplexLIR2MIRExpansion.float_2int(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.float_2long(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.fp_ifcmp(Instruction s)`
`protected void`	`BURS_Helpers.FP_MOV_OP_MOV(Instruction s, Operator op, Operand result, Operand val1, Operand val2)` Expansion of FP_ADD_ACC, FP_MUL_ACC, FP_SUB_ACC, and FP_DIV_ACC.
`protected void`	`BURS_Helpers.FP_REM(Instruction s, Operand val1, Operand val2)` Expansion of FP_REM
`protected void`	`BURS_Helpers.FPR_2INT(Instruction s, RegisterOperand result, Operand value)` Expansion of FLOAT_2INT and DOUBLE_2INT, using the FIST instruction.
`protected void`	`BURS_Helpers.FPR2GPR_64(Instruction s)` Emit code to move 64 bits from FPRs to GPRs
`protected void`	`BURS_Helpers.GET_EXCEPTION_OBJECT(Instruction s)` Emit code to get a caught exception object into a register
`protected void`	`BURS_Helpers.GET_TIME_BASE(Instruction s, RegisterOperand result)` Expansion of RDTSC (called GET_TIME_BASE for consistency with PPC)
`protected Operator`	`BURS_Helpers.get387_FPC(Instruction s)`
`protected void`	`BURS_Helpers.GPR2FPR_64(Instruction s)` Emit code to move 64 bits from GPRs to FPRs
`protected void`	`BURS_Helpers.IFCMP(Instruction s, RegisterOperand guardResult, Operand val1, Operand val2, ConditionOperand cond)` Generate a compare and branch sequence.
`protected void`	`BURS_Helpers.INT_2LONG(Instruction s, RegisterOperand result, Operand value, boolean signExtend)` Expansion of INT_2LONG
`protected void`	`BURS_Helpers.INT_DIVIDES(Instruction s, RegisterOperand result, Operand val1, Operand val2, boolean isDiv)` Expansion of INT_DIV and INT_REM
`protected boolean`	`BURS_Helpers.IS_MATERIALIZE_ZERO(Instruction s)`
`protected int`	`BURS_Helpers.is387_FPC(Instruction s, int trueCost)` Is the given instruction's constant operand a x87 floating point constant
`protected void`	`BURS_Helpers.LCMP_CMOV(Instruction s, RegisterOperand result, Operand val1, Operand val2, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate a long compare and cmov
`protected void`	`BURS_Helpers.LONG_ADD(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_ADD
`protected void`	`BURS_Helpers.LONG_AND(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_AND
`protected void`	`BURS_Helpers.LONG_CMP(Instruction s, RegisterOperand res, Operand val1, Operand val2)` Expansion of LONG_CMP: compare to values and set result to -1, 0, 1 for <, =, >, respectively
`private static Instruction`	`ComplexLIR2MIRExpansion.long_ifcmp_imm(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_ifcmp(Instruction s, IR ir)`
`private static Instruction`	`ComplexLIR2MIRExpansion.long_mul(Instruction s, IR ir)`
`protected void`	`BURS_Helpers.LONG_MUL(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_MUL
`protected void`	`BURS_Helpers.LONG_NEG(Instruction s, RegisterOperand result, Operand value)` Expansion of LONG_NEG
`protected void`	`BURS_Helpers.LONG_NOT(Instruction s, RegisterOperand result, Operand value)` Expansion of LONG_NOT
`protected void`	`BURS_Helpers.LONG_OR(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_OR
`private static Instruction`	`ComplexLIR2MIRExpansion.long_shl(Instruction s, IR ir)`
`protected void`	`BURS_Helpers.LONG_SHL(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_SHL
`private static Instruction`	`ComplexLIR2MIRExpansion.long_shr(Instruction s, IR ir)`
`protected void`	`BURS_Helpers.LONG_SHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_SHR
`protected void`	`BURS_Helpers.LONG_SUB(Instruction s, Operand result, Operand val1, Operand val2)` Expansion of LONG_SUB
`private static Instruction`	`ComplexLIR2MIRExpansion.long_ushr(Instruction s, IR ir)`
`protected void`	`BURS_Helpers.LONG_USHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_USHR
`protected void`	`BURS_Helpers.LONG_XOR(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_XOR
`protected void`	`BURS_Helpers.LOWTABLESWITCH(Instruction s)` Expansion of LOWTABLESWITCH.
`(package private) void`	`BURS_Helpers.OSR(BURS burs, Instruction s)`
`protected void`	`BURS_Helpers.PROLOGUE(Instruction s)` Expand a prologue by expanding out longs into pairs of ints
`protected void`	`BURS_Helpers.RESOLVE(Instruction s)` Expansion of RESOLVE.
`protected void`	`BURS_Helpers.SET_EXCEPTION_OBJECT(Instruction s)` Emit code to move a value in a register to the stack location where a caught exception object is expected to be.
`protected void`	`BURS_Helpers.SSE2_ABS(boolean single, Instruction s, Operand result, Operand value)`
`protected void`	`BURS_Helpers.SSE2_CONV(Operator op, Instruction s, Operand result, Operand value)` Expansion of SSE2 conversions double <-> float
`protected void`	`BURS_Helpers.SSE2_COP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` BURS expansion of a commutative SSE2 operation.
`protected void`	`BURS_Helpers.SSE2_FCMP_FCMOV(Instruction s, RegisterOperand result, Operand lhsCmp, Operand rhsCmp, ConditionOperand cond, Operand trueValue, Operand falseValue)`
`protected void`	`BURS_Helpers.SSE2_FPCONSTANT(Instruction s)` Expansion of SSE2 floating point constant loads
`protected void`	`BURS_Helpers.SSE2_FPR2GPR_32(Instruction s)` Emit code to move 32 bits from FPRs to GPRs
`protected void`	`BURS_Helpers.SSE2_FPR2GPR_64(Instruction s)` Emit code to move 64 bits from SSE2 FPRs to GPRs
`protected void`	`BURS_Helpers.SSE2_GPR2FPR_32(Instruction s)` Emit code to move 32 bits from GPRs to FPRs
`protected void`	`BURS_Helpers.SSE2_GPR2FPR_64(Instruction s)` Emit code to move 64 bits from GPRs to SSE2 FPRs
`protected void`	`BURS_Helpers.SSE2_IFCMP(Operator op, Instruction s, Operand val1, Operand val2)` Expansion of SSE2 comparison operations
`protected void`	`BURS_Helpers.SSE2_NCOP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` BURS expansion of a non commutative SSE2 operation.
`protected void`	`BURS_Helpers.SSE2_NEG(boolean single, Instruction s, Operand result, Operand value)` Expansion of SSE2 negation ops
`protected void`	`BURS_Helpers.SSE2_X87_FROMLONG(Instruction s)` Performs a long -> double/float conversion using x87 and marshalls back to XMMs.
`protected void`	`BURS_Helpers.SSE2_X87_REM(Instruction s)` Performs a long -> double/float conversion using x87 and marshalls between to XMMs.
`protected void`	`BURS_Helpers.SYSCALL(Instruction s, Operand address)` Expansion of SYSCALL.
`protected void`	`BURS_Helpers.threeValueFPCmp(Instruction s)` Expansion for [DF]CMP[GL] compare to values and set result to -1, 0, 1 for <, =, >, respectively
`protected void`	`BURS_Helpers.TRAP_IF_IMM(Instruction s, boolean longConstant)` Expansion of TRAP_IF, with an int constant as the second value.

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

Fields in org.jikesrvm.compilers.opt.liveness declared as Instruction
`private Instruction`	`LiveAnalysis.MapElement.inst`

Methods in org.jikesrvm.compilers.opt.liveness that return Instruction
`Instruction`	`LiveAnalysis.MapElement.getInst()` returns the instruction

Methods in org.jikesrvm.compilers.opt.liveness with parameters of type Instruction
`private void`	`LiveAnalysis.collectOsrInfo(Instruction inst, LiveSet lives)`
`static void`	`LiveInterval.createEndLiveRange(LiveSet set, BasicBlock block, Instruction inst)` This method iterates over each element in the the passed live set.
`static void`	`LiveInterval.createEndLiveRange(Register reg, BasicBlock block, Instruction inst)` This method checks if an existing unresolved live interval node, i.e., one that has an end instruction, but no beginning instruction, is present for the register and basic block passed.
`static void`	`LiveInterval.setStartLiveRange(Register reg, Instruction inst, BasicBlock block)` This method finds the LiveInterval node for the register and basic block passed.

Constructors in org.jikesrvm.compilers.opt.liveness with parameters of type Instruction
`LiveAnalysis.MapElement(Instruction inst, List<RegSpillListElement> list)` constructor

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

Methods in org.jikesrvm.compilers.opt.mir2mc.ia32 with parameters of type Instruction
`private void`	`AssemblerOpt.doADC(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ADC operator
`private void`	`AssemblerOpt.doADD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ADD operator
`private void`	`AssemblerOpt.doADDSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ADDSD operator
`private void`	`AssemblerOpt.doADDSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ADDSS operator
`private void`	`AssemblerOpt.doAND(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a AND operator
`private void`	`AssemblerOpt.doANDNPD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ANDNPD operator
`private void`	`AssemblerOpt.doANDNPS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ANDNPS operator
`private void`	`AssemblerOpt.doANDPD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ANDPD operator
`private void`	`AssemblerOpt.doANDPS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ANDPS operator
`private void`	`AssemblerOpt.doBSWAP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryAcc instruction and has a BSWAP operator
`private void`	`AssemblerOpt.doBT(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Test instruction and has a BT operator
`private void`	`AssemblerOpt.doBTC(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Test instruction and has a BTC operator
`private void`	`AssemblerOpt.doBTR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Test instruction and has a BTR operator
`private void`	`AssemblerOpt.doBTS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Test instruction and has a BTS operator
`private void`	`AssemblerOpt.doCALL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Call instruction and has a CALL operator
`private void`	`AssemblerOpt.doCDO(Instruction inst)` Emit the given instruction, assuming that it is a MIR_ConvertDW2QW instruction and has a CDO operator
`private void`	`AssemblerOpt.doCDQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_ConvertDW2QW instruction and has a CDQ operator
`private void`	`AssemblerOpt.doCDQE(Instruction inst)` Emit the given instruction, assuming that it is a MIR_ConvertDW2QW instruction and has a CDQE operator
`private void`	`AssemblerOpt.doCMOV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CondMove instruction and has a CMOV operator
`private void`	`AssemblerOpt.doCMP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a CMP operator
`private void`	`AssemblerOpt.doCMPEQSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPEQSD operator
`private void`	`AssemblerOpt.doCMPEQSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPEQSS operator
`private void`	`AssemblerOpt.doCMPLESD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPLESD operator
`private void`	`AssemblerOpt.doCMPLESS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPLESS operator
`private void`	`AssemblerOpt.doCMPLTSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPLTSD operator
`private void`	`AssemblerOpt.doCMPLTSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPLTSS operator
`private void`	`AssemblerOpt.doCMPNESD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPNESD operator
`private void`	`AssemblerOpt.doCMPNESS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPNESS operator
`private void`	`AssemblerOpt.doCMPNLESD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPNLESD operator
`private void`	`AssemblerOpt.doCMPNLESS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPNLESS operator
`private void`	`AssemblerOpt.doCMPNLTSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPNLTSD operator
`private void`	`AssemblerOpt.doCMPNLTSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPNLTSS operator
`private void`	`AssemblerOpt.doCMPORDSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPORDSD operator
`private void`	`AssemblerOpt.doCMPORDSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPORDSS operator
`private void`	`AssemblerOpt.doCMPUNORDSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPUNORDSD operator
`private void`	`AssemblerOpt.doCMPUNORDSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a CMPUNORDSS operator
`private void`	`AssemblerOpt.doCMPXCHG(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CompareExchange instruction and has a CMPXCHG operator
`private void`	`AssemblerOpt.doCMPXCHG8B(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CompareExchange8B instruction and has a CMPXCHG8B operator
`private void`	`AssemblerOpt.doCVTSD2SI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSD2SI operator
`private void`	`AssemblerOpt.doCVTSD2SIQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSD2SIQ operator
`private void`	`AssemblerOpt.doCVTSD2SS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSD2SS operator
`private void`	`AssemblerOpt.doCVTSI2SD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSI2SD operator
`private void`	`AssemblerOpt.doCVTSI2SDQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSI2SDQ operator
`private void`	`AssemblerOpt.doCVTSI2SS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSI2SS operator
`private void`	`AssemblerOpt.doCVTSS2SD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSS2SD operator
`private void`	`AssemblerOpt.doCVTSS2SI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTSS2SI operator
`private void`	`AssemblerOpt.doCVTTSD2SI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTTSD2SI operator
`private void`	`AssemblerOpt.doCVTTSD2SIQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTTSD2SIQ operator
`private void`	`AssemblerOpt.doCVTTSS2SI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a CVTTSS2SI operator
`private void`	`AssemblerOpt.doDEC(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryAcc instruction and has a DEC operator
`private void`	`AssemblerOpt.doDIV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Divide instruction and has a DIV operator
`private void`	`AssemblerOpt.doDIVSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a DIVSD operator
`private void`	`AssemblerOpt.doDIVSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a DIVSS operator
`private void`	`AssemblerOpt.doFADD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FADD operator
`private void`	`AssemblerOpt.doFADDP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FADDP operator
`private void`	`AssemblerOpt.doFCHS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryAcc instruction and has a FCHS operator
`private void`	`AssemblerOpt.doFCMOV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CondMove instruction and has a FCMOV operator
`private void`	`AssemblerOpt.doFCOMI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a FCOMI operator
`private void`	`AssemblerOpt.doFCOMIP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a FCOMIP operator
`private void`	`AssemblerOpt.doFDIV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FDIV operator
`private void`	`AssemblerOpt.doFDIVP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FDIVP operator
`private void`	`AssemblerOpt.doFDIVR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FDIVR operator
`private void`	`AssemblerOpt.doFDIVRP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FDIVRP operator
`private void`	`AssemblerOpt.doFFREE(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FFREE operator
`private void`	`AssemblerOpt.doFIADD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FIADD operator
`private void`	`AssemblerOpt.doFIDIV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FIDIV operator
`private void`	`AssemblerOpt.doFIDIVR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FIDIVR operator
`private void`	`AssemblerOpt.doFILD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a FILD operator
`private void`	`AssemblerOpt.doFIMUL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FIMUL operator
`private void`	`AssemblerOpt.doFINIT(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Empty instruction and has a FINIT operator
`private void`	`AssemblerOpt.doFIST(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a FIST operator
`private void`	`AssemblerOpt.doFISTP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a FISTP operator
`private void`	`AssemblerOpt.doFISUB(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FISUB operator
`private void`	`AssemblerOpt.doFISUBR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FISUBR operator
`private void`	`AssemblerOpt.doFLD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a FLD operator
`private void`	`AssemblerOpt.doFLD1(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLD1 operator
`private void`	`AssemblerOpt.doFLDCW(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryNoRes instruction and has a FLDCW operator
`private void`	`AssemblerOpt.doFLDL2E(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLDL2E operator
`private void`	`AssemblerOpt.doFLDL2T(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLDL2T operator
`private void`	`AssemblerOpt.doFLDLG2(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLDLG2 operator
`private void`	`AssemblerOpt.doFLDLN2(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLDLN2 operator
`private void`	`AssemblerOpt.doFLDPI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLDPI operator
`private void`	`AssemblerOpt.doFLDZ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a FLDZ operator
`private void`	`AssemblerOpt.doFMUL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FMUL operator
`private void`	`AssemblerOpt.doFMULP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FMULP operator
`private void`	`AssemblerOpt.doFNINIT(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Empty instruction and has a FNINIT operator
`private void`	`AssemblerOpt.doFNSAVE(Instruction inst)` Emit the given instruction, assuming that it is a MIR_FSave instruction and has a FNSAVE operator
`private void`	`AssemblerOpt.doFNSTCW(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryNoRes instruction and has a FNSTCW operator
`private void`	`AssemblerOpt.doFPREM(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FPREM operator
`private void`	`AssemblerOpt.doFRSTOR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_FSave instruction and has a FRSTOR operator
`private void`	`AssemblerOpt.doFST(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a FST operator
`private void`	`AssemblerOpt.doFSTCW(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryNoRes instruction and has a FSTCW operator
`private void`	`AssemblerOpt.doFSTP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a FSTP operator
`private void`	`AssemblerOpt.doFSUB(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FSUB operator
`private void`	`AssemblerOpt.doFSUBP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FSUBP operator
`private void`	`AssemblerOpt.doFSUBR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FSUBR operator
`private void`	`AssemblerOpt.doFSUBRP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a FSUBRP operator
`private void`	`AssemblerOpt.doFUCOMI(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a FUCOMI operator
`private void`	`AssemblerOpt.doFUCOMIP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a FUCOMIP operator
`private void`	`AssemblerOpt.doFXCH(Instruction inst)` Emit the given instruction, assuming that it is a MIR_XChng instruction and has a FXCH operator
`private void`	`AssemblerOpt.doIDIV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Divide instruction and has a IDIV operator
`private void`	`AssemblerOpt.doIMUL1(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Multiply instruction and has a IMUL1 operator
`private void`	`AssemblerOpt.doIMUL2(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a IMUL2 operator
`private void`	`AssemblerOpt.doINC(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryAcc instruction and has a INC operator
`void`	`AssemblerOpt.doInst(Instruction inst)` Assemble the given instruction
`private void`	`AssemblerOpt.doINT(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Trap instruction and has a INT operator
`protected void`	`AssemblerBase.doJCC(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CondBranch instruction and has a JCC operator
`protected void`	`AssemblerBase.doJMP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Branch instruction and has a JMP operator
`private void`	`AssemblerOpt.doLEA(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Lea instruction and has a LEA operator
`protected void`	`AssemblerBase.doLOWTABLESWITCH(Instruction inst)` Emit the given instruction, assuming that it is a MIR_LowTableSwitch instruction and has a MIR_LOWTABLESWITCH operator
`private void`	`AssemblerOpt.doMETHODSTART(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a METHODSTART operator
`private void`	`AssemblerOpt.doMFENCE(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Empty instruction and has a MFENCE operator
`private void`	`AssemblerOpt.doMOV(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOV operator
`private void`	`AssemblerOpt.doMOVD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOVD operator
`private void`	`AssemblerOpt.doMOVLPD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOVLPD operator
`private void`	`AssemblerOpt.doMOVLPS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOVLPS operator
`private void`	`AssemblerOpt.doMOVQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOVQ operator
`private void`	`AssemblerOpt.doMOVSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOVSD operator
`private void`	`AssemblerOpt.doMOVSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Move instruction and has a MOVSS operator
`private void`	`AssemblerOpt.doMOVSX(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a MOVSX operator
`private void`	`AssemblerOpt.doMOVSXQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a MOVSXQ operator
`private void`	`AssemblerOpt.doMOVZX(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a MOVZX operator
`private void`	`AssemblerOpt.doMOVZXQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a MOVZXQ operator
`private void`	`AssemblerOpt.doMUL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Multiply instruction and has a MUL operator
`private void`	`AssemblerOpt.doMULSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a MULSD operator
`private void`	`AssemblerOpt.doMULSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a MULSS operator
`private void`	`AssemblerOpt.doNEG(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryAcc instruction and has a NEG operator
`private void`	`AssemblerOpt.doNOT(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryAcc instruction and has a NOT operator
`private void`	`AssemblerOpt.doOFFSET(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CaseLabel instruction and has a OFFSET operator
`private void`	`AssemblerOpt.doOR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a OR operator
`private void`	`AssemblerOpt.doORPD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ORPD operator
`private void`	`AssemblerOpt.doORPS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ORPS operator
`private void`	`AssemblerOpt.doPAUSE(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Empty instruction and has a PAUSE operator
`private void`	`AssemblerOpt.doPOP(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Nullary instruction and has a POP operator
`private void`	`AssemblerOpt.doPREFETCHNTA(Instruction inst)` Emit the given instruction, assuming that it is a MIR_CacheOp instruction and has a PREFETCHNTA operator
`private void`	`AssemblerOpt.doPSLLQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a PSLLQ operator
`private void`	`AssemblerOpt.doPSRLQ(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a PSRLQ operator
`private void`	`AssemblerOpt.doPUSH(Instruction inst)` Emit the given instruction, assuming that it is a MIR_UnaryNoRes instruction and has a PUSH operator
`private void`	`AssemblerOpt.doRCL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a RCL operator
`private void`	`AssemblerOpt.doRCR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a RCR operator
`private void`	`AssemblerOpt.doRDTSC(Instruction inst)` Emit the given instruction, assuming that it is a MIR_RDTSC instruction and has a RDTSC operator
`private void`	`AssemblerOpt.doRET(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Return instruction and has a RET operator
`private void`	`AssemblerOpt.doROL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ROL operator
`private void`	`AssemblerOpt.doROR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a ROR operator
`private void`	`AssemblerOpt.doSAL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SAL operator
`private void`	`AssemblerOpt.doSAR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SAR operator
`private void`	`AssemblerOpt.doSBB(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SBB operator
`private void`	`AssemblerOpt.doSET(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Set instruction and has a SET operator
`private void`	`AssemblerOpt.doSHL(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SHL operator
`private void`	`AssemblerOpt.doSHLD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_DoubleShift instruction and has a SHLD operator
`private void`	`AssemblerOpt.doSHR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SHR operator
`private void`	`AssemblerOpt.doSHRD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_DoubleShift instruction and has a SHRD operator
`private void`	`AssemblerOpt.doSQRTSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a SQRTSD operator
`private void`	`AssemblerOpt.doSQRTSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Unary instruction and has a SQRTSS operator
`private void`	`AssemblerOpt.doSUB(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SUB operator
`private void`	`AssemblerOpt.doSUBSD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SUBSD operator
`private void`	`AssemblerOpt.doSUBSS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a SUBSS operator
`private void`	`AssemblerOpt.doTEST(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Test instruction and has a TEST operator
`private void`	`AssemblerOpt.doUCOMISD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a UCOMISD operator
`private void`	`AssemblerOpt.doUCOMISS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_Compare instruction and has a UCOMISS operator
`private void`	`AssemblerOpt.doXOR(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a XOR operator
`private void`	`AssemblerOpt.doXORPD(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a XORPD operator
`private void`	`AssemblerOpt.doXORPS(Instruction inst)` Emit the given instruction, assuming that it is a MIR_BinaryAcc instruction and has a XORPS operator
`protected int`	`AssemblerBase.estimateSize(Instruction inst, int offset)`
`private static void`	`FinalMIRExpansion.expandFClear(Instruction s, IR ir)` expand an FCLEAR pseudo-insruction using FFREEs.
`private static void`	`FinalMIRExpansion.expandFmov(Instruction s, PhysicalRegisterSet phys)` expand an FMOV pseudo-insruction.
`private static void`	`FinalMIRExpansion.expandUnconditionalYieldpoint(Instruction s, IR ir, RVMMethod meth)`
`private static void`	`FinalMIRExpansion.expandYieldpoint(Instruction s, IR ir, RVMMethod meth, IA32ConditionOperand ypCond)`
`(package private) boolean`	`AssemblerBase.isByte(Instruction inst)` Does the given instruction operate upon byte-sized data?
`(package private) boolean`	`AssemblerBase.isQuad(Instruction inst)` Does the given instruction operate upon quad-sized data?
`(package private) boolean`	`AssemblerBase.isWord(Instruction inst)` Does the given instruction operate upon word-sized data?
`protected boolean`	`AssemblerBase.targetIsClose(Instruction start, int target)` Given a forward branch instruction and its target, determine (conservatively) if the relative offset to the target is less than 127 bytes

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

Fields in org.jikesrvm.compilers.opt.regalloc declared as Instruction
`private Instruction`	`LiveIntervalElement.begin` instruction where the live interval begins (null if alive at basic block entry)
`(package private) Instruction`	`ScratchMap.Interval.begin` The instruction before which the scratch range begins.
`private Instruction`	`LiveIntervalElement.end` instruction where the live interval ends (null if alive at basic block exit)
`(package private) Instruction`	`ScratchMap.Interval.end` The instruction before which the scratch range ends.

Fields in org.jikesrvm.compilers.opt.regalloc with type parameters of type Instruction
`private HashMap<Instruction,HashSet<Register>>`	`ScratchMap.dirtyMap` For each GC Point s, a set of symbolic registers that are cached in dirty scratch registers before s.

Methods in org.jikesrvm.compilers.opt.regalloc that return Instruction
`Instruction`	`LiveIntervalElement.getBegin()`
`Instruction`	`LiveIntervalElement.getEnd()`

Methods in org.jikesrvm.compilers.opt.regalloc with parameters of type Instruction
`private boolean`	`GenericStackManager.appearsIn(Register r, Instruction s)` Does register r appear in instruction s?
`(package private) void`	`ScratchMap.beginScratchInterval(Register r, Instruction begin)` Begin a new interval of scratch-ness for a physical register.
`(package private) void`	`ScratchMap.beginSymbolicInterval(Register r, Register scratch, Instruction begin)` Begin a new interval of scratch-ness for a symbolic register.
`private GenericStackManager.ScratchRegister`	`GenericStackManager.createScratchBefore(Instruction s, Register r, Register symb)` Make physical register r available to be used as a scratch register before instruction s.
`private boolean`	`GenericStackManager.definesSpillLocation(int loc, Instruction s)` Does instruction s define spill location loc?
`private boolean`	`GenericStackManager.definesSpillLocation(Register r, Instruction s)` Does instruction s define the spill location for a given register?
`void`	`ScratchMap.endScratchInterval(Register r, Instruction end)` End an interval of scratch-ness for a physical register.
`void`	`ScratchMap.endSymbolicInterval(Register r, Instruction end)` End an interval of scratch-ness for a symbolic register.
`(package private) LinearScan.BasicInterval`	`LinearScan.CompoundInterval.getBasicInterval(Instruction s)` Return the first basic interval that contains a given instruction.
`(package private) LinearScan.BasicInterval`	`LinearScan.ActiveSet.getBasicInterval(Register r, Instruction s)` Find the basic interval for register r containing instruction s.
`private GenericStackManager.ScratchRegister`	`GenericStackManager.getCurrentScratchRegister(Register r, Instruction s)` If there is a scratch register available which currently holds the value of symbolic register r, then return that scratch register.
`(package private) static int`	`LinearScan.getDFN(Instruction inst)` returns the dfn associated with the passed instruction
`private GenericStackManager.ScratchRegister`	`GenericStackManager.getFirstAvailableScratchRegister(Register r, Instruction s)` Find the first available register which can serve as a scratch register for symbolic register r in instruction s.
`private Register`	`GenericStackManager.getFirstDeadFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a FPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
`private Register`	`GenericStackManager.getFirstDeadGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a GPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
`private Register`	`GenericStackManager.getFirstFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a FPR that does not appear in instruction s, to be used as a scratch register to hold register r.
`private Register`	`GenericStackManager.getFirstGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a GPR that does not appear in instruction s, to hold symbolic register r.
`private ArrayList<Register>`	`GenericStackManager.getReservedScratchRegisters(Instruction s)` Return the set of scratch registers which are currently reserved for use in instruction s.
`private GenericStackManager.ScratchRegister`	`GenericStackManager.getScratchRegister(Register symb, Instruction s, boolean beCheap)` Get a scratch register to hold symbolic register symb in instruction s.
`private GenericStackManager.ScratchRegister`	`GenericStackManager.getScratchRegisterUsingIntervals(Register r, Instruction s)` Find a register which can serve as a scratch register for symbolic register r in instruction s.
`(package private) static boolean`	`SimpleSpillCost.hasBadSizeMemoryOperand(Instruction s)` Does instruction s have a memory operand of an inconvenient size?
`private GenericStackManager.ScratchRegister`	`GenericStackManager.holdInScratchAfter(Instruction s, Register symb, boolean beCheap)` Insert code as needed so that after instruction s, the value of a symbolic register will be held in a particular scratch physical register.
`void`	`GenericStackManager.insertSpillAfter(Instruction s, Register r, byte type, int location)` Insert a spill of a physical register after instruction s.
`abstract void`	`GenericStackManager.insertSpillBefore(Instruction s, Register r, byte type, int location)` Insert a spill of a physical register before instruction s.
`void`	`GenericStackManager.insertUnspillAfter(Instruction s, Register r, byte type, int location)` Insert a load of a physical register from a spill location before instruction s.
`abstract void`	`GenericStackManager.insertUnspillBefore(Instruction s, Register r, byte type, int location)` Insert a load of a physical register from a spill location before instruction s.
`boolean`	`GenericStackManager.isDeadBefore(Register r, Instruction s)` Is a particular register dead immediately before instruction s.
`boolean`	`ScratchMap.isDirty(Instruction s, Register r)` At GC point s, is the value of register r cached in a dirty scratch register?
`abstract boolean`	`GenericRegisterRestrictions.isForbidden(Register symb, Register r, Instruction s)` Is it forbidden to assign symbolic register symb to physical register r in instruction s?
`protected boolean`	`GenericStackManager.isLegal(Register symb, Register phys, Instruction s)` Is it legal to assign symbolic register symb to scratch register phys in instruction s?
`private boolean`	`GenericStackManager.isPEIWithCatch(Instruction s)` Is s a PEI with a reachable catch block?
`abstract boolean`	`GenericStackManager.isSysCall(Instruction s)` Is a particular instruction a system call?
`void`	`ScratchMap.markDirty(Instruction s, Register symb)` Note that at GC point s, the real value of register symb is cached in a dirty scratch register.
`private void`	`GenericStackManager.markDirtyScratchRegisters(Instruction s)` Walk over the currently available scratch registers.
`private GenericStackManager.ScratchRegister`	`GenericStackManager.moveToScratchBefore(Instruction s, Register symb, boolean beCheap)` Assign symbolic register symb to a physical register, and insert code before instruction s to load the register from the appropriate stack location.
`abstract boolean`	`GenericStackManager.needScratch(Register r, Instruction s)` Given symbolic register r in instruction s, do we need to ensure that r is in a scratch register is s (as opposed to a memory operand)
`protected void`	`GenericStackManager.reloadScratchRegisterBefore(Instruction s, GenericStackManager.ScratchRegister scratch)` Restore the contents of a scratch register before instruction s.
`abstract void`	`GenericStackManager.replaceOperandWithSpillLocation(Instruction s, RegisterOperand symb)` In instruction s, replace all appearances of a symbolic register operand with uses of the appropriate spill location, as cached by the register allocator.
`private void`	`GenericStackManager.replaceRegisterWithScratch(Instruction s, Register r1, Register r2)` Replace all occurrences of register r1 in an instruction with register r2.
`private void`	`GenericStackManager.restoreAllScratchRegistersBefore(Instruction s)` Walk over the currently available scratch registers, and spill their contents to memory before instruction s.
`abstract void`	`GenericStackManager.restoreScratchRegistersBefore(Instruction s)` Walk over the currently available scratch registers.
`void`	`LiveIntervalElement.setBegin(Instruction begin)`
`(package private) static void`	`LinearScan.setDFN(Instruction inst, int dfn)` Associates the passed dfn number with the instruction
`private Register`	`GenericStackManager.spillLocationUse(int loc, Instruction s)` Assuming instruction s uses the spill location loc, return the symbolic register that embodies that use.
`private Register`	`GenericStackManager.spillLocationUse(Register r, Instruction s)` Assuming instruction s uses the spill location for a given register, return the symbolic register that embodies that use.
`protected void`	`GenericStackManager.unloadScratchRegisterBefore(Instruction s, GenericStackManager.ScratchRegister scratch)` Spill the contents of a scratch register to memory before instruction s.
`private boolean`	`GenericStackManager.usesSpillLocation(int loc, Instruction s)` Does instruction s use spill location loc?
`private boolean`	`GenericStackManager.usesSpillLocation(Register r, Instruction s)` Does instruction s use the spill location for a given register?

Constructors in org.jikesrvm.compilers.opt.regalloc with parameters of type Instruction
`LiveIntervalElement(Register reg, Instruction begin, Instruction end)` Use this constructur when the live interval is within a basic block

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

Methods in org.jikesrvm.compilers.opt.regalloc.ia32 with parameters of type Instruction
`private static void`	`CallingConvention.callExpand(Instruction call, IR ir)` Expand the calling convention for a particular call instruction
`private boolean`	`StackManager.canModifyEFLAGS(Instruction s)`
`private static int`	`CallingConvention.countFPRParams(Instruction call)` Count the number of FPR parameters in a call instruction.
`private static int`	`CallingConvention.countFPRParamsInPrologue(Instruction p)` Count the number of FPR parameters in a prologue instruction.
`private static int`	`CallingConvention.expandParametersToCall(Instruction call, IR ir)` Explicitly copy parameters to a call into the appropriate physical registers as defined by the calling convention.
`private static int`	`CallingConvention.expandParametersToSysCall(Instruction call, IR ir)` Explicitly copy parameters to a system call into the appropriate physical registers as defined by the calling convention.
`private static void`	`CallingConvention.expandResultOfCall(Instruction call, boolean isSysCall, IR ir)` Explicitly copy the result of a call instruction from the result register to the appropriate symbolic register, as defined by the calling convention.
`static void`	`CallingConvention.expandSysCall(Instruction s, IR ir)` Calling convention to implement calls to native (C) routines using the Linux linkage conventions.
`(package private) void`	`RegisterRestrictions.handle8BitRestrictions(Instruction s)` Ensure that if an operand has an 8 bit memory operand that all of its register operands are in 8 bit registers.
`(package private) boolean`	`RegisterRestrictions.has8BitMemoryOperand(Instruction s)` Does instruction s contain an 8-bit memory operand?
`private void`	`StackManager.insertBigFrameStackOverflowCheck(Instruction plg)` Insert an explicit stack overflow check in the prologue before buying the stack frame.
`private void`	`StackManager.insertEpilogue(Instruction ret)` Insert the epilogue before a particular return instruction.
`private static void`	`MIRSplitRanges.insertMoveAfter(RegisterOperand r2, RegisterOperand r1, Instruction s)` Insert an instruction to move r1 into r2 after instruction s
`private static void`	`MIRSplitRanges.insertMoveBefore(RegisterOperand r2, RegisterOperand r1, Instruction s)` Insert an instruction to move r1 into r2 before instruction s
`private void`	`StackManager.insertNormalStackOverflowCheck(Instruction plg)` Insert an explicit stack overflow check in the prologue after buying the stack frame.
`void`	`StackManager.insertSpillBefore(Instruction s, Register r, byte type, int location)`
`void`	`StackManager.insertUnspillBefore(Instruction s, Register r, byte type, int location)`
`boolean`	`RegisterRestrictions.isForbidden(Register symb, Register r, Instruction s)`
`private boolean`	`StackManager.isScratchFreeMove(Instruction s)` Is s a MOVE instruction that can be generated without resorting to scratch registers?
`boolean`	`StackManager.isSysCall(Instruction s)`
`private void`	`StackManager.moveESPBefore(Instruction s, int desiredOffset)` Before instruction s, insert code to adjust ESP so that it lies at a particular offset from its usual location.
`static boolean`	`RegisterRestrictions.mustBeInRegister(Register r, Instruction s)` Given symbolic register r that appears in instruction s, does the architecture demand that r be assigned to a physical register in s?
`private boolean`	`StackManager.mutateMoveToNop(Instruction s)` Attempt to rewrite a move instruction to a NOP.
`boolean`	`StackManager.needScratch(Register r, Instruction s)`
`void`	`StackManager.replaceOperandWithSpillLocation(Instruction s, RegisterOperand symb)`
`private void`	`StackManager.restoreFloatingPointState(Instruction inst)` Insert code into the epilogue to restore the floating point state.
`private void`	`StackManager.restoreNonVolatiles(Instruction inst)` Insert code before a return instruction to restore the nonvolatile registers.
`(package private) static void`	`CallingConvention.restoreNonvolatilesAfterSysCall(Instruction call, IR ir)` Restore all nonvolatile registers after a syscall.
`void`	`StackManager.restoreScratchRegistersBefore(Instruction s)`
`private void`	`StackManager.restoreVolatileRegisters(Instruction inst)` Insert code before a return instruction to restore the volatile and volatile registers.
`private static void`	`CallingConvention.returnExpand(Instruction ret, IR ir)` Expand the calling convention for a particular return instruction
`private void`	`StackManager.rewriteMoveInstruction(Instruction s)` Rewrite a move instruction if it has 2 memory operands.
`private void`	`StackManager.saveFloatingPointState(Instruction inst)` Insert code into the prologue to save the floating point state.
`private void`	`StackManager.saveNonVolatiles(Instruction inst)` Insert code into the prologue to save any used non-volatile registers.
`static void`	`CallingConvention.saveNonvolatilesAroundSysCall(Instruction call, IR ir)` Save and restore all nonvolatile registers around a syscall.
`(package private) static void`	`CallingConvention.saveNonvolatilesBeforeSysCall(Instruction call, IR ir)` Save all nonvolatile registers before a syscall.
`private void`	`StackManager.saveVolatiles(Instruction inst)` Insert code into the prologue to save all volatile registers.
`private static void`	`MIRSplitRanges.splitAllLiveRanges(Instruction s, HashMap<Register,Register> newMap, IR ir, boolean rootOnly)` Split the live ranges of all register operands of an instruction

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

Fields in org.jikesrvm.compilers.opt.ssa declared as Instruction
`private Instruction[]`	`LICM.earlyPos`
`(package private) Instruction`	`LeaveSSA.guardPhis`
`private Instruction`	`SSADictionary.AllInstructionEnumeration.labelInstruction` The label instruction for the basic block
`(package private) Instruction`	`LeaveSSA.Copy.phi` The phi instruction which generated this copy instruction

Fields in org.jikesrvm.compilers.opt.ssa with type parameters of type Instruction
`private HashMap<Integer,Instruction>`	`GlobalCSE.avail` Available expressions.
`private HashMap<Instruction,HeapOperand<Object>[]>`	`SSADictionary.defs` A mapping from `Instruction` to the set of heap operands (an `HeapOperand[]`) that this instruction defines.
`private static ArrayList<Instruction>`	`SSADictionary.emptyArrayList` An empty vector, used for utility.
`private HashSet<Instruction>`	`SSADictionary.exits` The set of instructions which have been registered to potentially exit the procedure
`private Enumeration<Instruction>`	`SSADictionary.AllInstructionEnumeration.explicitInstructions` An enumeration of the explicit instructions in the IR for a basic block
`private HashSet<Instruction>`	`LeaveSSA.globalRenameTable`
`private HashMap<BasicBlock,ArrayList<Instruction>>`	`SSADictionary.heapPhi` A mapping from `BasicBlock` to `ArrayList` of `Instruction` .
`private Iterator<Instruction>`	`SSADictionary.AllInstructionEnumeration.implicitInstructions` An enumeration of the implicit instructions in the IR for a basic block.
`private HashSet<Instruction>`	`LICM.relocated`
`private HashSet<Instruction>`	`EnterSSA.scalarPhis` The set of scalar phi functions inserted
`private HashMap<Instruction,HeapOperand<Object>[]>`	`SSADictionary.uses` A mapping from `Instruction` to the set of heap operands (an `HeapOperand[]`) that this instruction uses.

Methods in org.jikesrvm.compilers.opt.ssa that return Instruction
`(package private) Instruction`	`LICM.definingInstruction(Operand op)` Return the instruction that defines the operand.
`private Instruction`	`LICM.dominanceSuccessor(Instruction a, Instruction b)` return `a's successor on the path from `a' to `b' in the dominator tree.
`(package private) Instruction`	`LICM.getEarlyPos(Instruction inst)` Get the early position of an instruction
`static Instruction`	`PiNodes.getGenerator(Instruction def)` Get the instruction a Pi node is linked to.
`(package private) static Instruction`	`SSA.makeMoveInstruction(IR ir, Register r1, ConstantOperand c)` Create a move instruction r1 := c.
`(package private) static Instruction`	`SSA.makeMoveInstruction(IR ir, Register r1, Register r2, TypeReference t)` Create a move instruction r1 := r2.
`private static Instruction`	`SSADictionary.makePhiInstruction(HeapVariable<Object> H, BasicBlock bb)` Create a phi-function instruction for a heap variable
`private Instruction`	`EnterSSA.makePhiInstruction(Register r, BasicBlock bb)` Create a phi-function instruction
`private Instruction`	`LICM.maxDominatorDepth(Instruction a, Instruction b)` compare a and b according to their depth in the dominator tree and return the one with the greatest depth.
`Instruction`	`SSADictionary.AllInstructionEnumeration.nextElement()` Get the next instruction in the enumeration
`private Instruction`	`LICM.scheduleEarly(Instruction inst)` Schedule this instruction as early as possible
`(package private) Instruction`	`LICM.scheduleHeapDefsEarly(HeapOperand<?>[] op, Instruction earlyPos, Instruction me)` Schedule me as early as possible, but behind the definitions of op[i] and behind earlyPos
`private Instruction`	`LICM.scheduleScalarDefsEarly(Enumeration<Operand> e, Instruction earlyPos, Instruction inst)` Schedule me as early as possible, but behind the definitions in e and behind earlyPos

Methods in org.jikesrvm.compilers.opt.ssa that return types with arguments of type Instruction
`Iterator<Instruction>`	`SSADictionary.getHeapPhiInstructions(BasicBlock bb)` Return an enumeration of the control-phi functions for Heap variables at the beginning of a basic block.

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type Instruction
`private int`	`LICM._checkLoop(Instruction inst, HeapOperand<?> hop, int xidx)` check that inside the loop, the heap variable is only used/defed by simple, non-volatile loads/stores returns one of: CL_LOADS_ONLY, CL_STORES_ONLY, CL_LOADS_AND_STORES, CL_COMPLEX
`(package private) static void`	`SSA.addAtEnd(IR ir, BasicBlock bb, Instruction c, boolean exp)` Add a move instruction at the end of a basic block, renaming with a temporary register if needed to protect conditional branches at the end of the block.
`(package private) void`	`SSADictionary.addExceptionStateToDefs(Instruction s, BasicBlock b)` Register that an instruction defines the exception state.
`(package private) void`	`SSADictionary.addExceptionStateToUses(Instruction s)` Register that an instruction defines the exception state.
`private void`	`SSADictionary.aloadHelper(Instruction s, BasicBlock b)` Record the effects of a aload instruction on the heap array SSA form.
`(package private) static void`	`LoadElimination.appendMove(Register r, Operand src, Instruction store)` Append an instruction after a store instruction that caches value in register r.
`private void`	`SSADictionary.arraylengthHelper(Instruction s, BasicBlock b)` Record the effects of an arraylength instruction on the heap array SSA form.
`private void`	`SSADictionary.astoreHelper(Instruction s, BasicBlock b)` Record the effects of an astore instruction on the heap array SSA form.
`private void`	`SSADictionary.bbendHelper(Instruction s, BasicBlock b)` Record the effects of a bbend instruction on the heap array SSA form.
`private int`	`LICM.checkLoop(Instruction inst, HeapOperand<Object> hop, int xidx, BasicBlock block)` check that inside the loop, the heap variable is only used/defed by simple, non-volatile loads/stores returns one of: CL_LOADS_ONLY, CL_STORES_ONLY, CL_LOADS_AND_STORES, CL_COMPLEX
`(package private) boolean`	`SSADictionary.defsHeapVariable(Instruction s)` Does a particular instruction define any heap variable?
`private Instruction`	`LICM.dominanceSuccessor(Instruction a, Instruction b)` return `a's successor on the path from `a' to `b' in the dominator tree.
`private BasicBlock`	`LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry)` Generate bound check branch blocks
`(package private) BasicBlock`	`LICM.getBlock(Instruction inst)` Get the basic block of an instruction
`(package private) Instruction`	`LICM.getEarlyPos(Instruction inst)` Get the early position of an instruction
`private void`	`SSADictionary.getFieldHelper(Instruction s, BasicBlock b)` Record the effects of a getfield instruction on the heap array SSA form.
`static Instruction`	`PiNodes.getGenerator(Instruction def)` Get the instruction a Pi node is linked to.
`HeapOperand<Object>[]`	`SSADictionary.getHeapDefs(Instruction s)` Return the heap operands defined by an instruction.
`HeapOperand<Object>[]`	`SSADictionary.getHeapUses(Instruction s)` Return the heap operands used by an instruction.
`private BasicBlock`	`RedundantBranchElimination.RBE.getNotTakenBlock(Instruction s)` Return the basic block that s's block will goto if s is not taken.
`(package private) int`	`SSADictionary.getNumberOfHeapDefs(Instruction s)` Return the number of heap operands defined by an instruction
`(package private) BasicBlock`	`LICM.getOrigBlock(Instruction inst)` Get the block, where the instruction was originally located
`private RegisterOperand`	`GlobalCSE.getResult(Instruction inst)` Get the result operand of the instruction
`(package private) Operand`	`LICM.getResult(Instruction inst)` Get the result operand of the instruction
`(package private) int`	`LICM.getState(Instruction inst)` In what state (initial, early, late, done) is this instruction
`private void`	`SSADictionary.getStaticHelper(Instruction s, BasicBlock b)` Record the effects of a getstatic instruction on the heap array SSA form.
`private boolean`	`LICM.inVariantLocation(Instruction inst, BasicBlock block)`
`static boolean`	`PiNodes.isBoundsCheckPi(Instruction def)` Is an instruction a Pi node linked to a bounds-check?
`static boolean`	`PiNodes.isNotTakenPi(Instruction def)` Is an instruction a Pi node linked to the not taken edge of a conditional branch instruction?
`static boolean`	`PiNodes.isNullCheckPi(Instruction def)` Is an instruction a Pi node linked to a null-check?
`static boolean`	`PiNodes.isTakenPi(Instruction def)` Is an instruction a Pi node linked to the taken edge of a conditional branch instruction?
`private void`	`SSADictionary.labelHelper(Instruction s, BasicBlock b)` Record the effects of a label instruction on the heap array SSA form.
`private Instruction`	`LICM.maxDominatorDepth(Instruction a, Instruction b)` compare a and b according to their depth in the dominator tree and return the one with the greatest depth.
`private static TypeReference`	`EnterSSA.meetPhiType(Instruction s)` Return the meet of the types on the rhs of a phi instruction SIDE EFFECT: bashes the Instruction scratch field.
`(package private) void`	`LICM.move(Instruction inst, BasicBlock to)` move `inst' behind `pred'
`private void`	`SSADictionary.newArrayHelper(Instruction s, BasicBlock b)` Update the heap array SSA form for an array allocation instruction
`private void`	`SSADictionary.newHelper(Instruction s, BasicBlock b)` Update the heap array SSA form for an allocation instruction
`private RegisterOperand`	`LoopVersioning.nullCheckPerformedInLoopPredecessors(BasicBlock header, Instruction instr)` Can we eliminate a null check as it has lready been performed?
`private void`	`SSADictionary.phiHelper(Instruction s, BasicBlock b)` Record the effects of a phi instruction on the heap array SSA form.
`(package private) void`	`IndexPropagationSystem.processALoad(Instruction s)` Update the set of dataflow equations to account for the actions of ALoad instruction s The load is of the form x = A[k].
`private void`	`ValueGraph.processALoad(Instruction s)` Update the value graph to account for a given ALOAD instruction.
`(package private) void`	`IndexPropagationSystem.processAStore(Instruction s)` Update the set of dataflow equations to account for the actions of AStore instruction s The store is of the form A[k] = val.
`private void`	`ValueGraph.processAStore(Instruction s)` Update the value graph to account for a given ASTORE instruction.
`private void`	`ValueGraph.processBinary(Instruction s)` Update the value graph to account for a given Binary instruction.
`(package private) void`	`IndexPropagationSystem.processCall(Instruction s)` Update the set of dataflow equations to account for the actions of CALL instruction.
`private void`	`ValueGraph.processCall(Instruction s)` Update the value graph to account for a given Call instruction.
`private void`	`ValueGraph.processGuardedBinary(Instruction s)` Update the value graph to account for a given GuardedBinary instruction.
`private void`	`ValueGraph.processGuardedUnary(Instruction s)` Update the value graph to account for a given GuardedUnary instruction.
`private void`	`ValueGraph.processIfCmp(Instruction s)` Update the value graph to account for a given IfCmp instruction.
`private void`	`ValueGraph.processInlineGuard(Instruction s)` Update the value graph to account for a given InlineGuard instruction.
`private void`	`ValueGraph.processInstruction(Instruction s)` Update the value graph to account for a given instruction.
`(package private) void`	`IndexPropagationSystem.processLoad(Instruction s)` Update the set of dataflow equations to account for the actions of a Load instruction The load is of the form x = A[k].
`private void`	`ValueGraph.processMove(Instruction s)` Update the value graph to account for a given MOVE instruction.
`(package private) void`	`IndexPropagationSystem.processNew(Instruction s)` Update the set of dataflow equations to account for the actions of allocation instruction s
`private void`	`ValueGraph.processNew(Instruction s)` Update the value graph to account for a given NEW instruction.
`private void`	`ValueGraph.processNewArray(Instruction s)` Update the value graph to account for a given NEWARRAY instruction.
`private void`	`ValueGraph.processNullCheck(Instruction s)` Update the value graph to account for a given NullCheck instruction.
`(package private) void`	`IndexPropagationSystem.processPhi(Instruction s)` Update the set of dataflow equations to account for the actions of Phi instruction.
`private void`	`ValueGraph.processPhi(Instruction s)` Update the value graph to account for a given Phi instruction.
`private void`	`ValueGraph.processPi(Instruction s)` Update the value graph to account for a given PI instruction.
`private void`	`ValueGraph.processPrologue(Instruction s)` Update the value graph to account for an IR_PROLOGUE instruction PRECONDITION: `Prologue.conforms(s);`
`private void`	`ValueGraph.processPutField(Instruction s)` Update the value graph to account for a given PUTFIELD instruction.
`private void`	`ValueGraph.processPutStatic(Instruction s)` Update the value graph to account for a given PUTSTATIC instruction.
`(package private) void`	`IndexPropagationSystem.processStore(Instruction s)` Update the set of dataflow equations to account for the actions of a Store instruction.
`private void`	`ValueGraph.processUnary(Instruction s)` Update the value graph to account for a given Unary instruction.
`private void`	`ValueGraph.processZeroCheck(Instruction s)` Update the value graph to account for a given NullCheck instruction.
`private void`	`SSADictionary.putFieldHelper(Instruction s, BasicBlock b)` Record the effects of a putfield instruction on the heap array SSA form.
`private void`	`SSADictionary.putStaticHelper(Instruction s, BasicBlock b)` Record the effects of a putstatic instruction on the heap array SSA form.
`private void`	`SSADictionary.registerDef(Instruction s, BasicBlock b, FieldReference fr)` Register that instruction `s` writes a heap variable for a given field.
`private void`	`SSADictionary.registerDef(Instruction s, BasicBlock b, String a)` Register that the instruction `s` writes a heap variable for a given field.
`private void`	`SSADictionary.registerDef(Instruction s, BasicBlock b, TypeReference t)` Register that an instruction writes a heap variable for a given type.
`(package private) void`	`SSADictionary.registerExit(Instruction s, BasicBlock b)` Register that an instruction s can potentially leave the procedure.
`(package private) void`	`SSADictionary.registerInstruction(Instruction s, BasicBlock b)` Record the heap variables that instruction s defines and uses.
`(package private) void`	`SSADictionary.registerUnknown(Instruction s, BasicBlock b)` Register that an instruction s has unknown side effects.
`private void`	`SSADictionary.registerUse(Instruction s, FieldReference fr)` Register that an instruction uses a heap variable for a given field.
`private void`	`SSADictionary.registerUse(Instruction s, String a)` Register that an instruction uses a heap variable for a given field.
`private void`	`SSADictionary.registerUse(Instruction s, TypeReference t)` Register that an instruction uses a heap variable of a given type.
`private void`	`RedundantBranchElimination.RBE.removeCondBranch(BasicBlock source, Instruction cb, IR ir, Instruction di)` Remove cb from source, updating PHI nodes to maintain SSA form.
`(package private) HeapOperand<Object>[]`	`SSADictionary.replaceDefs(Instruction s, BasicBlock b)` Replace all heap variables that an instruction defs with new heap variables.
`(package private) static void`	`LoadElimination.replaceLoadWithMove(Register r, Instruction load)` Replace a Load instruction s with a load from a scalar register r TODO: factor this functionality out elsewhere
`private boolean`	`LICM.replaceUses(Instruction inst, HeapOperand<?> replacement, BasicBlockOperand replacementBlock, boolean onlyPEIs)` In the consumers of `inst', replace uses of `inst's result with uses of `replacement'
`(package private) void`	`SSADictionary.replaceUses(Instruction s, HeapOperand<Object>[] H)` Register that an instruction now uses the set of heap operands
`private Instruction`	`LICM.scheduleEarly(Instruction inst)` Schedule this instruction as early as possible
`(package private) Instruction`	`LICM.scheduleHeapDefsEarly(HeapOperand<?>[] op, Instruction earlyPos, Instruction me)` Schedule me as early as possible, but behind the definitions of op[i] and behind earlyPos
`(package private) BasicBlock`	`LICM.scheduleHeapUsesLate(Instruction inst, BasicBlock lateBlock)` Schedule me as early as possible, but behind the definitions of op[i] and behind earlyPos
`(package private) BasicBlock`	`LICM.scheduleLate(Instruction inst)` Schedule as late as possible.
`private Instruction`	`LICM.scheduleScalarDefsEarly(Enumeration<Operand> e, Instruction earlyPos, Instruction inst)` Schedule me as early as possible, but behind the definitions in e and behind earlyPos
`private BasicBlock`	`LICM.scheduleScalarUsesLate(Instruction inst, BasicBlock lateBlock)` Schedule me as late as possible, but in front of my uses and before latePos
`(package private) void`	`LICM.setBlock(Instruction inst, BasicBlock b)` Set the basic block for an instruction
`(package private) void`	`LICM.setEarlyPos(Instruction inst, Instruction pos)` Set the early position for an instruction
`(package private) void`	`LICM.setOrigBlock(Instruction inst, BasicBlock b)` Set the block, where the instruction is originally located.
`(package private) void`	`LICM.setState(Instruction inst, int s)` Set the state (initial, early, late, done) of the instruction
`private boolean`	`GlobalCSE.shouldCSE(Instruction inst)` should this instruction be cse'd ?
`static boolean`	`LICM.shouldMove(Instruction inst, IR ir)` Is it save to move the given instruction, depending on we are in heapSSA form or not?
`private boolean`	`LICM.simplify(Instruction inst, BasicBlock block)`
`private void`	`RedundantBranchElimination.RBE.takeCondBranch(BasicBlock source, Instruction cb, IR ir)` Transform cb into a GOTO, updating PHI nodes to maintain SSA form.
`(package private) BasicBlock`	`LICM.upto(Instruction earlyPos, BasicBlock lateBlock, Instruction inst)` Visit the blocks between the late and the early position along their path in the dominator tree.
`(package private) BasicBlock`	`LICM.useBlock(Instruction use, Operand op)`
`(package private) boolean`	`SSADictionary.usesHeapVariable(Instruction s)` Does a particular instruction use any heap variable?
`static boolean`	`GCP.usesOrDefsPhysicalRegisterOrAddressType(Instruction inst)`

Method parameters in org.jikesrvm.compilers.opt.ssa with type arguments of type Instruction
`private void`	`EnterSSA.copyHeapDefs(IR ir, HashMap<Instruction,HeapOperand<?>[]> store)` Store a copy of the Heap variables each instruction defs.
`private boolean`	`LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop, BasicBlock block, ArrayList<Instruction> checksToEliminate, BasicBlock unoptimizedLoopEntry, BasicBlock optimizedLoopEntry, HashMap<Register,Register> optimalRegMap)` Create the block containing explict branches to either the optimized or unoptimized loops
`private HashMap<BasicBlock,BasicBlock>`	`LoopVersioning.createOptimizedLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, ArrayList<Instruction> instrToEliminate, HashMap<Register,BasicBlock> regToBlockMap)` Create a clone of the loop replacing definitions in the cloned loop with those found in the register map and eliminate unnecessary bound checks
`private void`	`LoopVersioning.fixUpPhiPredecessors(ArrayList<Instruction> phiInstructions, BasicBlock unoptimizedLoopExit, BasicBlock optimizedLoopExit)` When phi nodes were generated the basic blocks weren't known for the predecessors, fix this up now.
`private BasicBlock`	`LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop, ArrayList<Instruction> checksToEliminate, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry)` Generate null check branch blocks
`private void`	`LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)` Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
`private void`	`LoopVersioning.getListOfChecksToEliminate(AnnotatedLSTNode loop, ArrayList<Instruction> instrToEliminate)` Create a list of instructions to be eliminated
`private void`	`LoopVersioning.getRegistersDefinedInLoop(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> definingInstructions)` Get registers defined in the given loop.
`private void`	`LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)` Remove loop and replace register definitions in the original loop with phi instructions
`private void`	`LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)` Remove loop and replace register definitions in the original loop with phi instructions
`private void`	`EnterSSA.removeAllUnreachablePhis(HashSet<Instruction> scalarPhis)` Remove all phis that are unreachable
`private void`	`EnterSSA.removeUnreachableOperands(HashSet<Instruction> scalarPhis)` Remove all unreachable operands from scalar phi functions NOT CURRENTLY USED

Constructors in org.jikesrvm.compilers.opt.ssa with parameters of type Instruction
`LeaveSSA.Copy(Instruction phi, int index)` Create a pending copy operation for an operand of a phi instruction

Uses of Instruction in org.jikesrvm.osr

Fields in org.jikesrvm.osr declared as Instruction
`Instruction`	`VariableMapElement.osr`

Methods in org.jikesrvm.osr with parameters of type Instruction
`void`	`VariableMap.insert(Instruction inst, LinkedList<MethodVariables> mvarList)`
`void`	`VariableMap.insertFirst(Instruction inst, LinkedList<MethodVariables> mvarList)` Inserts a new entry at the begin of the list.

Constructors in org.jikesrvm.osr with parameters of type Instruction
`VariableMapElement(Instruction inst, LinkedList<MethodVariables> methVars)`

Overview

Package

Class

Use

Tree

Serialized

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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

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