Instruction (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.opt.ir.Instruction

```
public final class Instruction
extends Object
```
Instructions are the basic atomic unit of the IR. An instruction contains an operator and (optionally) some operands. In addition, an instruction may (or may not) have valid bcIndex andposition fields that together encode a description of the bytecode that it came from.
Although we use a single class, Instruction, to implement all IR instructions, there are logically a number of different kinds of instructions. For example, binary operators, array loads, calls, and null_checks all have different number of operands with differing semantics. To manage this in an abstract, somewhat object-oriented, but still highly efficient fashion we have the notion of an Instruction Format. An Instruction Format is a class external to Instruction (defined in the instructionFormat package) that provides static methods to create instructions and symbolically access their operands. Every instance of Operator is assigned to exactly one Instruction Format. Thus, the instruction's operator implies which Instruction Format class can be used to access the instruction's operands.
There are some common logical operands (eg Result, Location) that appear in a large number of Instruction Formats. In addition to the basic Instruction Format classes, we provided additional classes (eg ResultCarrier, LocationCarrier) that allow manipulation of all instructions that contain a common operands.
A configuration (OptOptVIFcopyingGC) is defined in which all methods of all Instruction Format classes verify that the operator of the instruction being manipulated actually belongs to the appropriate Instruction Format. This configuration is quite slow, but is an important sanity check to make sure that Instruction Formats are being used in a consistent fashion.
The instruction's operator also has a number of traits. Methods on Instruction are provided to query these operator traits. In general, clients should use the methods of Instruction to query traits, since a particular instruction may override the operator-provided default in some cases. For example, isMove(), isBranch(), isPEI(), and isCall() are some of the trait queries.
Unfortunately, the combination of operators, operator traits, and Instruction Formats often leads to a tricky decision of which of three roughly equivalent idioms one should use when writing code that needs to manipulate instructions and their operands. For example,
```
 if (Call.conforms(instr)) {
    return Call.getResult(instr);
 }
 
```
and
```
 if (instr.operator() == CALL) {
    return Call.getResult(instr);
 }
 
```
and
```
 if (instr.isCall()) {
    return ResultCarrier.getResult(instr);
 }
 
```
are more or less the same. In some cases, picking an idiom is simply a matter of taste, but in others making the wrong choice can lead to code that is less robust or maintainable as operators and/or instruction formats are added and removed from the IR. One should always think carefully about which idiom is the most concise, maintainable, robust and efficient means of accomplishing a given task. Some general rules of thumb (or at least one person's opinion):
- Tests against operator traits should be preferred to use of the conforms method of an Instruction Format class if both are possible. This is definitely true if the code in question does not need to access specific operands of the instruction. Things are murkier if the code needs to manipulate specific (non-common) operands of the instruction.
- If you find yourself writing long if-then-else constructs using either Instruction Format conforms or operator traits then you ought to at least consider writing a switch statement on the opcode of the operator. It should be more efficient and, depending on what your desired default behavior is, may be more robust/maintainable as well.
- Instruction Format classes are really intended to represent the "syntactic form" of an instruction, not the semantics of its operator. Using "conforms" when no specific operands are being manipulated is almost always not the right way to do things.
See Also:

Operator, Operand, BasicBlock

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`Instruction.BASE_OE` Shared functionality for operand enumerations
`private static class`	`Instruction.MOE` Enumerate the memory operands of an instruction
`private static class`	`Instruction.OE` enumerate leaf operands in the given ranges
`private static class`	`Instruction.OEDefsOnly` Enumerate the def operands of an instruction (ignores memory operands, since the contained operands of a MO are uses).
`private static class`	`Instruction.ROE` Enumerate the root operands of an instruction

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`bcIndex` The index of the bytecode that this instruction came from.
`private Instruction`	`next` The next instruction in the intra-basic-block list of instructions, will be `null` if no such instruction exists.
`private static byte`	`OI_GC` BITFIELD used to encode `operatorInfo`.
`private static byte`	`OI_GC_VALID` BITFIELD used to encode `operatorInfo`.
`private static byte`	`OI_INVALID` BITFIELD used to encode `operatorInfo`.
`private static byte`	`OI_PEI` BITFIELD used to encode `operatorInfo`.
`private static byte`	`OI_PEI_VALID` BITFIELD used to encode `operatorInfo`.
`private Operator`	`operator` The operator for this instruction.
`private byte`	`operatorInfo` Override and refine the operator-based trait (characteristic) information.
`private Operand[]`	`ops` The operands of this instruction.
`InlineSequence`	`position` A description of the tree of inlined methods that contains the bytecode that this instruction came from.
`private Instruction`	`prev` The previous instruction in the intra-basic-block list of instructions, will be `null` if no such instruction exists.

Constructor Summary

Constructors
Modifier Constructor and Description

private Instruction(Operator op, int size)

Constructors
Modifier	Constructor and Description
`private`	`Instruction(Operator op, int size)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`BURS_backdoor_linkWithNext(Instruction other)` Allow BURS a back door into linkWithNext.
`void`	`changeOperatorTo(Operator newlySetOperator)`
`(package private) void`	`clearLinks()` For IR internal use only; general clients should always use higer level mutation functions.
`void`	`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.
`Instruction`	`copyWithoutLinks()` Create a copy of this instruction.
`static Instruction`	`create(Operator op, int size)` INTERNAL IR USE ONLY: create a new instruction with the specified number of operands.
`void`	`flipBranchProbability()` Invert the probabilty of this branch being taken.
`BasicBlock`	`getBasicBlock()` Gets the basic block that contains this instruction.
`float`	`getBranchProbability()` Return the probability (in the range 0.0 - 1.0) that this two-way branch instruction is taken (as opposed to falling through).
`BasicBlock`	`getBranchTarget()` Returns the basic block jumped to by this BRANCH instruction.
`Enumeration<BasicBlock>`	`getBranchTargets()` Return an enumeration of the basic blocks that are targets of this branch instruction.
`int`	`getBytecodeIndex()` Get the `bytecode index` of the instruction.
`Operand`	`getClearOperand(int i)` NOTE: It is incorrect to use getClearOperand with a constant argument outside of the automatically generated code in Operators.
`Enumeration<Operand>`	`getDefs()` Enumerate all defs (both pure defs and def/uses) of an instruction.
`Enumeration<Operand>`	`getDefUses()` Enumerate all the def/uses of an instruction.
`Enumeration<Operand>`	`getMemoryOperands()` Enumerate all memory operands of an instruction
`private char`	`getMIR_START_opcode()`
`(package private) Instruction`	`getNext()` For IR internal use only; general clients should use `nextInstructionInCodeOrder()`.
`int`	`getNumberOfDefs()` Returns the number of operands that are defs (either pure defs or combined def/uses).
`int`	`getNumberOfOperands()` Get the number of operands in this instruction.
`private int`	`getNumberOfOperandsVarUsesOrDefs()`
`int`	`getNumberOfPureDefs()` Returns the number of operands that are pure defs.
`int`	`getNumberOfPureUses()` Returns the number of operands that are pure uses.
`int`	`getNumberOfUses()` Returns the number of operands that are uses (either combined def/uses or pure uses).
`char`	`getOpcode()` Return the opcode of the instruction's operator (a unique id suitable for use in switches); see `Operator.opcode`.
`Operand`	`getOperand(int i)` NOTE: It is incorrect to use getOperand with a constant argument outside of the automatically generated code in Operators.
`Enumeration<Operand>`	`getOperands()` Enumerate all "leaf" operands of an instruction.
`(package private) Instruction`	`getPrev()` For IR internal use only; General clients should use `prevInstructionInCodeOrder()`.
`Enumeration<Operand>`	`getPureDefs()` Enumerate all the pure defs (ie not including def/uses) of an instruction.
`Enumeration<Operand>`	`getPureUses()` Enumerate all the pure uses (ie not including def/uses) of an instruction.
`Enumeration<Operand>`	`getRootOperands()` Enumerate all the root operands of an instruction (DOES NOT ENUMERATE CONTAINED OPERANDS OF MEMORY OPERANDS).
`Enumeration<Operand>`	`getRootUses()` Enumerate all root uses of an instruction.
`Enumeration<Operand>`	`getUses()` Enumerate all uses of an instruction (includes def/use).
`boolean`	`hasMemoryOperand()`
`boolean`	`hasPrev()`
`void`	`insertAfter(Instruction newInstr)` Insertion: Insert newInstr immediately after this in the instruction stream.
`void`	`insertBefore(Instruction newInstr)` Insertion: Insert newInstr immediately before this in the instruction stream.
`boolean`	`isAcquire()` Is the instruction an acquire (monitorenter/lock)?
`boolean`	`isAllocation()` Is the instruction an actual memory allocation instruction (NEW, NEWARRAY, etc)?
`private void`	`isBackwardLinked()`
`boolean`	`isBbFirst()` Return `true` if this instruction is the first instruction in a basic block.
`boolean`	`isBbInside()` Mainly intended for assertion checking; returns true if the instruction is expected to appear on the "inside" of a basic block, false otherwise.
`boolean`	`isBbLast()` Return `true` if this instruction is the last instruction in a basic block.
`boolean`	`isBranch()` Is the instruction an intraprocedural branch?
`boolean`	`isCall()` Is the instruction a call (one kind of interprocedural branch)?
`boolean`	`isCompare()` Is the instruction a compare (val,val) => condition?
`boolean`	`isConditionalBranch()` Is the instruction a conditional intraprocedural branch?
`boolean`	`isConditionalCall()` Is the instruction a conditional call?
`boolean`	`isDirectBranch()` Is the instruction a direct intraprocedural branch?
`boolean`	`isDirectCalll()` Is the instruction a direct call?
`boolean`	`isDynamicLinkingPoint()` Could the instruction either directly or indirectly cause dynamic class loading?
`boolean`	`isExplicitLoad()` Is the instruction an explicit load of a finite set of values from a finite set of memory locations (load, load multiple, _not_ call)?
`boolean`	`isExplicitStore()` Is the instruction an explicit store of a finite set of values to a finite set of memory locations (store, store multiple, _not_ call)?
`private void`	`isForwardLinked()`
`boolean`	`isGCPoint()` Is the instruction a potential GC point?
`boolean`	`isImplicitLoad()` Should the instruction be treated as a load from some unknown location(s) for the purposes of scheduling and/or modeling the memory subsystem?
`boolean`	`isImplicitStore()` Should the instruction be treated as a store to some unknown location(s) for the purposes of scheduling and/or modeling the memory subsystem?
`boolean`	`isIndirectBranch()` Is the instruction an indirect intraprocedural branch?
`boolean`	`isIndirectCall()` Is the instruction an indirect call?
`private void`	`isLinked()`
`boolean`	`isMarkedAsPEI()` Has the instruction been explictly marked as a a PEI (Potentially Excepting Instruction)?
`boolean`	`isMove()` Does the instruction represent a simple move (the value is unchanged) from one "register" location to another "register" location?
`boolean`	`isNonPureCall()` Is the instruction a call but not a pure call (one kind of interprocedural branch)?
`private void`	`isNotLinked()`
`boolean`	`isPEI()` Is the instruction a PEI (Potentially Excepting Instruction)?
`boolean`	`isPureCall()` Is the instruction a pure call (one kind of interprocedural branch)?
`boolean`	`isRelease()` Is the instruction a release (monitorexit/unlock)?
`boolean`	`isReturn()` Is the instruction a return (interprocedural branch)?
`boolean`	`isThrow()` Is the instruction a throw of a Java exception?
`boolean`	`isTSPoint()` Is the instruction a potential thread switch point?
`boolean`	`isTwoWayBranch()` Is this instruction a branch that has that has only two possible successors?
`boolean`	`isUnconditionalBranch()` Is the instruction an unconditional intraprocedural branch?
`boolean`	`isUnconditionalCall()` Is the instruction an unconditional call?
`boolean`	`isYieldPoint()` Is the instruction a yield point?
`(package private) void`	`linkWithNext(Instruction other)` For IR internal use only; general clients should always use higer level mutation functions.
`void`	`markAsGCPoint()` NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!!
`void`	`markAsNonGCPoint()` NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!!
`void`	`markAsNonPEI()` Record that this instruction is not a PEI.
`void`	`markAsNonPEINonGCPoint()` NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!!
`void`	`markAsPEI()` NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!!
`boolean`	`mayBeVolatileFieldLoad()` Might this instruction be a load from a field that is declared to be volatile?
`Instruction`	`nextInstructionInCodeOrder()` Return the next instruction with respect to the current code linearization order.
`Operator`	`operator()` Return the instruction's operator.
`private Operand`	`outOfLineCopy(Operand op)`
`Instruction`	`prevInstructionInCodeOrder()` Return the previous instruction with respect to the current code linearization order.
`void`	`putOperand(int i, Operand op)` NOTE: It is incorrect to use putOperand with a constant argument outside of the automatically generated code in Operators.
`Instruction`	`remove()` Removal: Remove this from the instruction stream.
`void`	`replace(Instruction newInstr)` Replacement: Replace this with newInstr.
`void`	`replaceOperand(Operand oldOp, Operand newOp)` Replace all occurances of the first operand with the second.
`void`	`replaceRegister(Register r, Register n)` Replace all occurances of register r with register n
`void`	`replaceSimilarOperands(Operand oldOp, Operand newOp)` Replace any operands that are similar to the first operand with a copy of the second operand.
`void`	`resizeNumberOfOperands(int newSize)` Enlarge the number of operands in this instruction, if necessary.
`void`	`setBranchProbability(float takenProbability)` Record the probability (in the range 0.0 - 1.0) that this two-way branch instruction is taken (as opposed to falling through).
`void`	`setBytecodeIndex(int bci)` Set the `bytecode index` of the instruction.
`(package private) void`	`setNext(Instruction n)` For IR internal use only; general clients should always use higer level mutation functions.
`(package private) void`	`setPrev(Instruction p)` For IR internal use only; general clients should always use higer level mutation functions.
`boolean`	`similar(Instruction similarInstr)` Are two instructions similar, i.e. having the same operator and the same number of similar operands?
`String`	`toString()` Returns the string representation of this instruction (mainly intended for use when printing the IR).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - OI_INVALID
```
private static final byte OI_INVALID
```
    BITFIELD used to encode operatorInfo. NB: OI_INVALID must be default value!
    
    See Also:
    
    Constant Field Values
  - OI_PEI_VALID
```
private static final byte OI_PEI_VALID
```
    BITFIELD used to encode operatorInfo.
    
    See Also:
    
    Constant Field Values
  - OI_PEI
```
private static final byte OI_PEI
```
    BITFIELD used to encode operatorInfo.
    
    See Also:
    
    Constant Field Values
  - OI_GC_VALID
```
private static final byte OI_GC_VALID
```
    BITFIELD used to encode operatorInfo.
    
    See Also:
    
    Constant Field Values
  - OI_GC
```
private static final byte OI_GC
```
    BITFIELD used to encode operatorInfo.
    
    See Also:
    
    Constant Field Values
  - bcIndex
```
public int bcIndex
```
    The index of the bytecode that this instruction came from. In combination with the position, the bcIndex field uniquely identifies the source position of the bytecode that this instruction came from.
  - position
```
public InlineSequence position
```
    A description of the tree of inlined methods that contains the bytecode that this instruction came from.
    In combination with the bcIndex, the position field uniquely identifies the source position of the bytecode that this instruction came from.
    A single position operator can be shared by many instruction objects.
    
    See Also:
    
    InlineSequence, OptEncodedCallSiteTree
  - operator
```
private Operator operator
```
    The operator for this instruction.
    The same operator object can be shared by many instruction objects.
  - next
```
private Instruction next
```
    The next instruction in the intra-basic-block list of instructions, will be null if no such instruction exists.
  - prev
```
private Instruction prev
```
    The previous instruction in the intra-basic-block list of instructions, will be null if no such instruction exists.
  - operatorInfo
```
private byte operatorInfo
```
    Override and refine the operator-based trait (characteristic) information.
    
    See Also:
    
    Operator
  - ops
```
private Operand[] ops
```
    The operands of this instruction.
- Constructor Detail
  - Instruction
```
private Instruction(Operator op,
                    int size)
```
- Method Detail
  - create
```
public static Instruction create(Operator op,
                                 int size)
```
    INTERNAL IR USE ONLY: create a new instruction with the specified number of operands.
    For internal use only -- general clients MUST use the appropriate InstructionFormat class's create and mutate methods to create instruction objects!!!
    
    Parameters:
    
    op - operator
    
    size - number of operands
    
    Returns:
    
    the created instruction
  - copyWithoutLinks
```
public Instruction copyWithoutLinks()
```
    Create a copy of this instruction. The copy has the same operator and operands, but is not linked into an instruction list.
    
    Returns:
    
    the copy
  - toString
```
public String toString()
```
    Returns the string representation of this instruction (mainly intended for use when printing the IR).
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    string representation of this instruction.
  - nextInstructionInCodeOrder
```
public Instruction nextInstructionInCodeOrder()
```
    Return the next instruction with respect to the current code linearization order.
    
    Returns:
    
    the next instruction in the code order or null if no such instruction exists
  - prevInstructionInCodeOrder
```
public Instruction prevInstructionInCodeOrder()
```
    Return the previous instruction with respect to the current code linearization order.
    
    Returns:
    
    the previous instruction in the code order or null if no such instruction exists
  - hasPrev
```
public boolean hasPrev()
```
    Returns:
    
    has this instruction been linked with a previous instruction? ie will calls to insertBefore succeed?
  - getBasicBlock
```
public BasicBlock getBasicBlock()
```
    Gets the basic block that contains this instruction.
    Note: this instruction takes O(1) time for LABEL and BBEND instructions, but will take O(# of instrs in the block) for all other instructions. Therefore, although it can be used on any instruction, care must be taken when using it to avoid doing silly O(N^2) work for what could be done in O(N) work.
    
    Returns:
    
    basic block that contains the instruction
  - copyPosition
```
public void 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.
    
    Parameters:
    
    source - the instruction to copy the source position from
  - getBytecodeIndex
```
public int getBytecodeIndex()
```
    Get the bytecode index of the instruction.
    
    Returns:
    
    the bytecode index of the instruction
  - setBytecodeIndex
```
public void setBytecodeIndex(int bci)
```
    Set the bytecode index of the instruction.
    
    Parameters:
    
    bci - the new bytecode index
  - operator
```
public Operator operator()
```
    Return the instruction's operator.
    
    Returns:
    
    the operator
  - changeOperatorTo
```
public void changeOperatorTo(Operator newlySetOperator)
```
  - getOpcode
```
public char getOpcode()
```
    Return the opcode of the instruction's operator (a unique id suitable for use in switches); see Operator.opcode.
    
    Returns:
    
    the operator's opcode
  - getNumberOfOperands
```
public int getNumberOfOperands()
```
    Get the number of operands in this instruction.
    
    Returns:
    
    number of operands
  - getNumberOfOperandsVarUsesOrDefs
```
private int getNumberOfOperandsVarUsesOrDefs()
```
  - getNumberOfDefs
```
public int getNumberOfDefs()
```
    Returns the number of operands that are defs (either pure defs or combined def/uses).
    By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses. Note that this may change in the future.
    
    Returns:
    
    number of operands that are defs
  - getNumberOfPureDefs
```
public int getNumberOfPureDefs()
```
    Returns the number of operands that are pure defs.
    By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses. Note that this may change in the future.
    
    Returns:
    
    number of operands that are defs
  - getNumberOfPureUses
```
public int getNumberOfPureUses()
```
    Returns the number of operands that are pure uses.
    By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses. Note that this may change in the future.
    
    Returns:
    
    number of operands that are defs
  - getNumberOfUses
```
public int getNumberOfUses()
```
    Returns the number of operands that are uses (either combined def/uses or pure uses).
    By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses. Note that this may change in the future.
    
    Returns:
    
    how many operands are uses
  - replaceOperand
```
public void replaceOperand(Operand oldOp,
                           Operand newOp)
```
    Replace all occurances of the first operand with the second.
    
    Parameters:
    
    oldOp - The operand to replace
    
    newOp - The new one to replace it with
  - replaceSimilarOperands
```
public void replaceSimilarOperands(Operand oldOp,
                                   Operand newOp)
```
    Replace any operands that are similar to the first operand with a copy of the second operand.
    
    Parameters:
    
    oldOp - The operand whose similar operands should be replaced
    
    newOp - The new one to replace it with
  - replaceRegister
```
public void replaceRegister(Register r,
                            Register n)
```
    Replace all occurances of register r with register n
    
    Parameters:
    
    r - the old register
    
    n - the new register
  - hasMemoryOperand
```
public boolean hasMemoryOperand()
```
    Returns:
    
    true if this instruction holds any memory or stack location operands
  - getOperands
```
public Enumeration<Operand> getOperands()
```
    Enumerate all "leaf" operands of an instruction.
    NOTE: DOES NOT RETURN MEMORY OPERANDS, ONLY THEIR CONTAINED OPERANDS!!!!!
    
    Returns:
    
    an enumeration of the instruction's operands.
  - getMemoryOperands
```
public Enumeration<Operand> getMemoryOperands()
```
    Enumerate all memory operands of an instruction
    
    Returns:
    
    an enumeration of the instruction's operands.
  - getRootOperands
```
public Enumeration<Operand> getRootOperands()
```
    Enumerate all the root operands of an instruction (DOES NOT ENUMERATE CONTAINED OPERANDS OF MEMORY OPERANDS).
    
    Returns:
    
    an enumeration of the instruction's operands.
  - getDefs
```
public Enumeration<Operand> getDefs()
```
    Enumerate all defs (both pure defs and def/uses) of an instruction.
    
    Returns:
    
    an enumeration of the instruction's defs.
  - getPureDefs
```
public Enumeration<Operand> getPureDefs()
```
    Enumerate all the pure defs (ie not including def/uses) of an instruction.
    
    Returns:
    
    an enumeration of the instruction's pure defs.
  - getPureUses
```
public Enumeration<Operand> getPureUses()
```
    Enumerate all the pure uses (ie not including def/uses) of an instruction.
    
    Returns:
    
    an enumeration of the instruction's pure defs.
  - getDefUses
```
public Enumeration<Operand> getDefUses()
```
    Enumerate all the def/uses of an instruction.
    
    Returns:
    
    an enumeration of the instruction's def/uses.
  - getUses
```
public Enumeration<Operand> getUses()
```
    Enumerate all uses of an instruction (includes def/use).
    
    Returns:
    
    an enumeration of the instruction's uses.
  - getRootUses
```
public Enumeration<Operand> getRootUses()
```
    Enumerate all root uses of an instruction.
    
    Returns:
    
    an enumeration of the instruction's uses.
  - isMove
```
public boolean isMove()
```
    Does the instruction represent a simple move (the value is unchanged) from one "register" location to another "register" location?
    
    Returns:
    
    true if the instruction is a simple move or false if it is not.
  - isBranch
```
public boolean isBranch()
```
    Is the instruction an intraprocedural branch?
    
    Returns:
    
    true if the instruction is am intraprocedural branch or false if it is not.
  - isConditionalBranch
```
public boolean isConditionalBranch()
```
    Is the instruction a conditional intraprocedural branch?
    
    Returns:
    
    true if the instruction is a conditional intraprocedural branch or false if it is not.
  - isTwoWayBranch
```
public boolean isTwoWayBranch()
```
    Is this instruction a branch that has that has only two possible successors?
    
    Returns:
    
    true if the instruction is an interprocedural conditional branch with only two possible outcomes (taken or not taken).
  - isUnconditionalBranch
```
public boolean isUnconditionalBranch()
```
    Is the instruction an unconditional intraprocedural branch? We consider various forms of switches to be unconditional intraprocedural branches, even though they are multi-way branches and we may not no exactly which target will be taken. This turns out to be the right thing to do, since some arm of the switch will always be taken (unlike conditional branches).
    
    Returns:
    
    true if the instruction is an unconditional intraprocedural branch or false if it is not.
  - isDirectBranch
```
public boolean isDirectBranch()
```
    Is the instruction a direct intraprocedural branch? In the HIR and LIR we consider switches to be direct branches, because their targets are known precisely.
    
    Returns:
    
    true if the instruction is a direct intraprocedural branch or false if it is not.
  - isIndirectBranch
```
public boolean isIndirectBranch()
```
    Is the instruction an indirect intraprocedural branch?
    
    Returns:
    
    true if the instruction is an indirect interprocedural branch or false if it is not.
  - isCall
```
public boolean isCall()
```
    Is the instruction a call (one kind of interprocedural branch)?
    
    Returns:
    
    true if the instruction is a call or false if it is not.
  - isPureCall
```
public boolean isPureCall()
```
    Is the instruction a pure call (one kind of interprocedural branch)?
    
    Returns:
    
    true if the instruction is a pure call or false if it is not.
  - isNonPureCall
```
public boolean isNonPureCall()
```
    Is the instruction a call but not a pure call (one kind of interprocedural branch)?
    
    Returns:
    
    true if the instruction is a nonpure call or false if it is not.
  - isConditionalCall
```
public boolean isConditionalCall()
```
    Is the instruction a conditional call? We only allow conditional calls in the MIR, since they tend to only be directly implementable on some architecutres.
    
    Returns:
    
    true if the instruction is a conditional call or false if it is not.
  - isUnconditionalCall
```
public boolean isUnconditionalCall()
```
    Is the instruction an unconditional call? Really only an interesting question in the MIR, since it is by definition true for all HIR and LIR calls.
    
    Returns:
    
    true if the instruction is an unconditional call or false if it is not.
  - isDirectCalll
```
public boolean isDirectCalll()
```
    Is the instruction a direct call? Only interesting on the MIR. In the HIR and LIR we pretend that all calls are "direct" even though most of them aren't.
    
    Returns:
    
    true if the instruction is a direct call or false if it is not.
  - isIndirectCall
```
public boolean isIndirectCall()
```
    Is the instruction an indirect call? Only interesting on the MIR. In the HIR and LIR we pretend that all calls are "direct" even though most of them aren't.
    
    Returns:
    
    true if the instruction is an indirect call or false if it is not.
  - isExplicitLoad
```
public boolean isExplicitLoad()
```
    Is the instruction an explicit load of a finite set of values from a finite set of memory locations (load, load multiple, _not_ call)?
    
    Returns:
    
    true if the instruction is an explicit load or false if it is not.
  - isImplicitLoad
```
public boolean isImplicitLoad()
```
    Should the instruction be treated as a load from some unknown location(s) for the purposes of scheduling and/or modeling the memory subsystem?
    
    Returns:
    
    true if the instruction is an implicit load or false if it is not.
  - isExplicitStore
```
public boolean isExplicitStore()
```
    Is the instruction an explicit store of a finite set of values to a finite set of memory locations (store, store multiple, _not_ call)?
    
    Returns:
    
    true if the instruction is an explicit store or false if it is not.
  - isImplicitStore
```
public boolean isImplicitStore()
```
    Should the instruction be treated as a store to some unknown location(s) for the purposes of scheduling and/or modeling the memory subsystem?
    
    Returns:
    
    true if the instruction is an implicit store or false if it is not.
  - isThrow
```
public boolean isThrow()
```
    Is the instruction a throw of a Java exception?
    
    Returns:
    
    true if the instruction is a throw or false if it is not.
  - isPEI
```
public boolean isPEI()
```
    Is the instruction a PEI (Potentially Excepting Instruction)?
    
    Returns:
    
    true if the instruction is a PEI or false if it is not.
  - isMarkedAsPEI
```
public boolean isMarkedAsPEI()
```
    Has the instruction been explictly marked as a a PEI (Potentially Excepting Instruction)?
    
    Returns:
    
    true if the instruction is explicitly marked as a PEI or false if it is not.
  - isGCPoint
```
public boolean isGCPoint()
```
    Is the instruction a potential GC point?
    
    Returns:
    
    true if the instruction is a potential GC point or false if it is not.
  - isTSPoint
```
public boolean isTSPoint()
```
    Is the instruction a potential thread switch point?
    
    Returns:
    
    true if the instruction is a potential thread switch point or false if it is not.
  - isCompare
```
public boolean isCompare()
```
    Is the instruction a compare (val,val) => condition?
    
    Returns:
    
    true if the instruction is a compare or false if it is not.
  - isAllocation
```
public boolean isAllocation()
```
    Is the instruction an actual memory allocation instruction (NEW, NEWARRAY, etc)?
    
    Returns:
    
    true if the instruction is an allocation or false if it is not.
  - isReturn
```
public boolean isReturn()
```
    Is the instruction a return (interprocedural branch)?
    
    Returns:
    
    true if the instruction is a return or false if it is not.
  - isAcquire
```
public boolean isAcquire()
```
    Is the instruction an acquire (monitorenter/lock)?
    
    Returns:
    
    true if the instruction is an acquire or false if it is not.
  - isRelease
```
public boolean isRelease()
```
    Is the instruction a release (monitorexit/unlock)?
    
    Returns:
    
    true if the instruction is a release or false if it is not.
  - isDynamicLinkingPoint
```
public boolean isDynamicLinkingPoint()
```
    Could the instruction either directly or indirectly cause dynamic class loading?
    
    Returns:
    
    true if the instruction is a dynamic linking point or false if it is not.
  - isYieldPoint
```
public boolean isYieldPoint()
```
    Is the instruction a yield point?
    
    Returns:
    
    true if the instruction is a yield point or false if it is not.
  - markAsNonPEI
```
public void markAsNonPEI()
```
    Record that this instruction is not a PEI. Leave GCPoint status (if any) unchanged.
  - getMIR_START_opcode
```
private char getMIR_START_opcode()
```
  - markAsPEI
```
public void markAsPEI()
```
    NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!! Record that this instruction is a PEI. Note that marking as a PEI implies marking as GCpoint.
  - markAsNonGCPoint
```
public void markAsNonGCPoint()
```
    NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!! Record that this instruction does not represent a potential GC point. Leave exception state (if any) unchanged.
  - markAsGCPoint
```
public void markAsGCPoint()
```
    NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!! Record that this instruction is a potential GC point. Leave PEI status (if any) unchanged.
  - markAsNonPEINonGCPoint
```
public void markAsNonPEINonGCPoint()
```
    NOTE: ONLY FOR USE ON MIR INSTRUCTIONS!!!! Mark this instruction as being neither an exception or GC point.
  - getBranchProbability
```
public float getBranchProbability()
```
    Return the probability (in the range 0.0 - 1.0) that this two-way branch instruction is taken (as opposed to falling through).
    
    Returns:
    
    The probability that the branch is taken.
  - setBranchProbability
```
public void setBranchProbability(float takenProbability)
```
    Record the probability (in the range 0.0 - 1.0) that this two-way branch instruction is taken (as opposed to falling through).
    
    Parameters:
    
    takenProbability - The probability that the branch is taken.
  - flipBranchProbability
```
public void flipBranchProbability()
```
    Invert the probabilty of this branch being taken. This method should be called on a branch instruction when its condition is reversed using flipCode().
  - getBranchTarget
```
public BasicBlock getBranchTarget()
```
    Returns the basic block jumped to by this BRANCH instruction. TODO: Not all types of branches supported yet.
    
    Returns:
    
    the target of this branch instruction
  - getBranchTargets
```
public Enumeration<BasicBlock> getBranchTargets()
```
    Return an enumeration of the basic blocks that are targets of this branch instruction.
    
    Returns:
    
    the targets of this branch instruction
  - isBbFirst
```
public boolean isBbFirst()
```
    Return true if this instruction is the first instruction in a basic block. By convention (construction) every basic block starts with a label instruction and a label instruction only appears at the start of a basic block
    
    Returns:
    
    true if the instruction is the first instruction in its basic block or false if it is not.
  - isBbLast
```
public boolean isBbLast()
```
    Return true if this instruction is the last instruction in a basic block. By convention (construction) every basic block ends with a BBEND instruction and a BBEND instruction only appears at the end of a basic block
    
    Returns:
    
    true if the instruction is the last instruction in its basic block or false if it is not.
  - isBbInside
```
public boolean isBbInside()
```
    Mainly intended for assertion checking; returns true if the instruction is expected to appear on the "inside" of a basic block, false otherwise.
    
    Returns:
    
    true if the instruction is expected to appear on the inside (not first or last) of its basic block or false if it is expected to be a first/last instruction.
  - insertAfter
```
public void insertAfter(Instruction newInstr)
```
    Insertion: Insert newInstr immediately after this in the instruction stream. Can't insert after a BBEND instruction, since it must be the last instruction in its basic block.
    
    Parameters:
    
    newInstr - the instruction to insert, must not be in an instruction list already.
  - insertBefore
```
public void insertBefore(Instruction newInstr)
```
    Insertion: Insert newInstr immediately before this in the instruction stream. Can't insert before a LABEL instruction, since it must be the first instruction in its basic block.
    
    Parameters:
    
    newInstr - the instruction to insert, must not be in an instruction list already.
  - replace
```
public void replace(Instruction newInstr)
```
    Replacement: Replace this with newInstr. We could allow replacement of first & last instrs in the basic block, but it would be a fair amount of work to update everything, and probably isn't useful, so we'll simply disallow it for now.
    
    Parameters:
    
    newInstr - the replacement instruction must not be in an instruction list already and must not be a LABEL or BBEND instruction.
  - remove
```
public Instruction remove()
```
    Removal: Remove this from the instruction stream. We currently forbid the removal of LABEL instructions to avoid problems updating branch instructions that reference the label. We also outlaw removal of BBEND instructions.
    NOTE: We allow the removal of branch instructions, but don't update the CFG data structure.....right now we just assume the caller knows what they are doing and takes care of it.
    NB: execution of this method nulls out the prev & next fields of this
    
    Returns:
    
    the previous instruction in the instruction stream
  - isLinked
```
private void isLinked()
```
  - isBackwardLinked
```
private void isBackwardLinked()
```
  - isForwardLinked
```
private void isForwardLinked()
```
  - isNotLinked
```
private void isNotLinked()
```
  - getOperand
```
public Operand getOperand(int i)
```
    NOTE: It is incorrect to use getOperand with a constant argument outside of the automatically generated code in Operators. The only approved direct use of getOperand is in a loop over some subset of an instructions operands (all of them, all uses, all defs).
    
    Parameters:
    
    i - which operand to return
    
    Returns:
    
    the ith operand
  - getClearOperand
```
public Operand getClearOperand(int i)
```
    NOTE: It is incorrect to use getClearOperand with a constant argument outside of the automatically generated code in Operators. The only approved direct use of getOperand is in a loop over some subset of an instructions operands (all of them, all uses, all defs).
    
    Parameters:
    
    i - which operand to return
    
    Returns:
    
    the ith operand detatching it from the instruction
  - putOperand
```
public void putOperand(int i,
                       Operand op)
```
    NOTE: It is incorrect to use putOperand with a constant argument outside of the automatically generated code in Operators. The only approved direct use of getOperand is in a loop over some subset of an instruction's operands (all of them, all uses, all defs).
    
    Parameters:
    
    i - which operand to set
    
    op - the operand to set it to
  - outOfLineCopy
```
private Operand outOfLineCopy(Operand op)
```
  - resizeNumberOfOperands
```
public void resizeNumberOfOperands(int newSize)
```
    Enlarge the number of operands in this instruction, if necessary. Only meant to be used by InstructionFormat classes.
    
    Parameters:
    
    newSize - the new minimum number of operands.
  - getNext
```
Instruction getNext()
```
    For IR internal use only; general clients should use nextInstructionInCodeOrder().
    
    Returns:
    
    the contents of next
  - setNext
```
void setNext(Instruction n)
```
    For IR internal use only; general clients should always use higer level mutation functions. Set the next field of the instruction.
    
    Parameters:
    
    n - the new value for next
  - getPrev
```
Instruction getPrev()
```
    For IR internal use only; General clients should use prevInstructionInCodeOrder().
    
    Returns:
    
    the contents of prev
  - setPrev
```
void setPrev(Instruction p)
```
    For IR internal use only; general clients should always use higer level mutation functions. Set the prev field of the instruction.
    
    Parameters:
    
    p - the new value for prev
  - clearLinks
```
void clearLinks()
```
    For IR internal use only; general clients should always use higer level mutation functions. Clear the prev and next fields of the instruction.
  - similar
```
public boolean similar(Instruction similarInstr)
```
    Are two instructions similar, i.e. having the same operator and the same number of similar operands?
    
    Parameters:
    
    similarInstr - instruction to compare against
    
    Returns:
    
    true if they are similar
  - linkWithNext
```
void linkWithNext(Instruction other)
```
    For IR internal use only; general clients should always use higer level mutation functions. Link this and other together by setting this's next field to point to other and other's prev field to point to this.
    
    Parameters:
    
    other - the instruction to link with.
  - BURS_backdoor_linkWithNext
```
public void BURS_backdoor_linkWithNext(Instruction other)
```
    Allow BURS a back door into linkWithNext. This method should only be called within BURS.
    
    Parameters:
    
    other - the next instruction
  - mayBeVolatileFieldLoad
```
public boolean mayBeVolatileFieldLoad()
```
    Might this instruction be a load from a field that is declared to be volatile?
    
    Returns:
    
    true if the instruction might be a load from a volatile field or false if it cannot be a load from a volatile field

Class Instruction

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

OI_INVALID

OI_PEI_VALID

OI_PEI

OI_GC_VALID

OI_GC

bcIndex

position

operator

next

prev

operatorInfo

ops

Constructor Detail

Instruction

Method Detail

create

copyWithoutLinks

toString

nextInstructionInCodeOrder

prevInstructionInCodeOrder

hasPrev

getBasicBlock

copyPosition

getBytecodeIndex

setBytecodeIndex

operator

changeOperatorTo

getOpcode

getNumberOfOperands

getNumberOfOperandsVarUsesOrDefs

getNumberOfDefs

getNumberOfPureDefs

getNumberOfPureUses

getNumberOfUses

replaceOperand

replaceSimilarOperands

replaceRegister

hasMemoryOperand

getOperands

getMemoryOperands

getRootOperands

getDefs

getPureDefs

getPureUses

getDefUses

getUses

getRootUses

isMove

isBranch

isConditionalBranch

isTwoWayBranch

isUnconditionalBranch

isDirectBranch

isIndirectBranch

isCall

isPureCall

isNonPureCall

isConditionalCall

isUnconditionalCall

isDirectCalll

isIndirectCall

isExplicitLoad

isImplicitLoad

isExplicitStore

isImplicitStore

isThrow

isPEI

isMarkedAsPEI

isGCPoint

isTSPoint

isCompare

isAllocation

isReturn