Operator (Jikes RVM API)

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

Direct Known Subclasses:

ArchOperator, ArchOperator
```
public abstract class Operator
extends Object
```
An Operator represents the operator of an Instruction. For each operator in the IR, we create exactly one Operator instance to represent it. These instances are all stored in static fields of Operators. Since only one instance is created for each semantic operator, they can be compared using ==.

See Also:

Operators, Instruction

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`acquire` operator is an acquire (monitorenter/lock) HIR only
`protected static int`	`alloc` an explicit memory allocation
`protected static int`	`branch` operator is an intraprocedural branch of some form
`protected static int`	`call` operator is some kind of call (interprocedural branch)
`protected static int`	`commutative` operator is commutative
`protected static int`	`compare` operator is some kind of compare (val,val)-> cond
`protected static int`	`conditional` modifer for branches/calls
`protected static int`	`dynLink` operator either directly or indirectly may casue dynamic linking
`protected static int`	`ethrow` is an exception throw
`byte`	`format` Encoding of the operator's InstructionFormat.
`protected static int`	`fpPop` operator pops floating-point stack after performing defs
`protected static int`	`fpPush` operator pushs floating-point stack before performing defs
`protected static int`	`immedPEI` an immediate PEI (null_check, int_zero_check, but _not_ call);
`int`	`implicitDefs` Physical registers that are implicitly defined by the operator.
`int`	`implicitUses` Physical registers that are implicitly used by the operator.
`protected static int`	`indirect` modifier for branches/calls, mostly on MIR
`protected static int`	`load` an explicit load of a value from memory
`protected static int`	`memAsLoad` operator is modeled as a load by memory system, mostly on MIR
`protected static int`	`memAsStore` operator is modeled as a store by memory system, mostly on MIR
`protected static int`	`move` operator is a simple move operation from one "register" to another
`static int`	`none` operator has no interesting traits
`private int`	`numberDefs` How many operands of the operator are (pure) defs?
`private int`	`numberDefUses` How many operands of the operator are both defs and uses?
`private int`	`numberUses` How many operands of the operator are pure uses?
`(package private) char`	`opcode` The operators opcode.
`protected static int`	`release` operator is a relase (monitorexit/unlock) HIR only
`protected static int`	`ret` a return instruction (interprocedural branch)
`protected static int`	`store` an explicit store of a value to memory
`private int`	`traits` encoding of operator traits (characteristics)
`protected static int`	`tsp` operator is a potential thread switch point for some reason other than being a call/immedPEI
`static int`	`varDefs` operator has a variable number of defs
`static int`	`varUses` operator has a variable number of uses
`protected static int`	`yieldPoint` operator is a yield point

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Operator(char opcode, byte format, int traits, int numDefs, int numDefUses, int numUses, int iDefs, int iUses)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`getNumberOfDefs()` Returns the number of operands that are defs (either pure defs or combined def/uses).
`int`	`getNumberOfDefUses()` Returns the number of operands that are defs and uses.
`int`	`getNumberOfFixedPureDefs()` Returns the number of operands that are pure defs and are not in the variable-length part of the operand list.
`int`	`getNumberOfFixedPureUses()` Returns the number of operands that are pure uses and are not in the variable-length part of the operand list.
`int`	`getNumberOfFixedUses()` Returns the number of operands that are uses (either combined use/defs or pure uses) and are not in the variable-length part of the operand list.
`int`	`getNumberOfImplicitDefs()` Returns the number of physical registers that are implicitly defined by this operator.
`int`	`getNumberOfImplicitUses()` Returns the number of physical registers that are implicitly used by this operator.
`int`	`getNumberOfPureDefs()` Returns the number of operands that are defs.
`int`	`getNumberOfPureFixedUses()` Returns the number of operands that are pure uses and are not in the variable-length part of the operand list.
`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()`
`boolean`	`hasVarDefs()` Can the operator have a variable number of uses?
`boolean`	`hasVarUses()` Can the operator have a variable number of uses?
`boolean`	`hasVarUsesOrDefs()` Can the operator have a variable number of uses or defs?
`abstract int`	`instTemplate()`
`boolean`	`isAcquire()` Is the operator an acquire (monitorenter/lock)?
`boolean`	`isAdviseESP()`
`boolean`	`isAllocation()` Is the operator an actual memory allocation instruction (NEW, NEWARRAY, etc)?
`boolean`	`isBranch()` Is the operator an intraprocedural branch?
`boolean`	`isCall()` Is the operator a call (one kind of interprocedural branch)?
`boolean`	`isCallSaveVolatile()`
`boolean`	`isCommutative()` Is the operator commutative?
`boolean`	`isCompare()` Is the operator a compare (val,val) => condition?
`boolean`	`isConditionalBranch()` Is the operator a conditional intraprocedural branch?
`boolean`	`isConditionalCall()` Is the operator a conditional call?
`boolean`	`isDirectBranch()` Is the operator a direct intraprocedural branch?
`boolean`	`isDirectCall()` Is the operator a direct call?
`boolean`	`isDynamicLinkingPoint()` Could the operator either directly or indirectly cause dynamic class loading?
`boolean`	`isExplicitLoad()` Is the operator 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 operator an explicit store of a finite set of values to a finite set of memory locations (store, store multiple, _not_ call)?
`boolean`	`isFClear()`
`boolean`	`isFNInit()`
`boolean`	`isFpPop()` Does the operator pop the floating-point stack?
`boolean`	`isFpPush()` Does the operator push on the floating-point stack?
`boolean`	`isGCPoint()` Is the operator a potential GC point?
`boolean`	`isImplicitLoad()` Should the operator 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 operator 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 operator an indirect intraprocedural branch?
`boolean`	`isIndirectCall()` Is the operator an indirect call?
`boolean`	`isMove()` Does the operator represent a simple move (the value is unchanged) from one "register" location to another "register" location?
`boolean`	`isPEI()` Is the operator a PEI (Potentially Excepting Instruction)?
`boolean`	`isRelease()` Is the operator a release (monitorexit/unlock)?
`boolean`	`isReturn()` Is the operator a return (interprocedural branch)?
`boolean`	`isThrow()` Is the operator a throw of a Java exception?
`boolean`	`isTSPoint()` is the operator a potential thread switch point?
`boolean`	`isUnconditionalBranch()` Is the operator an unconditional intraprocedural branch?
`boolean`	`isUnconditionalCall()` Is the operator an unconditional call?
`boolean`	`isYieldPoint()` Is the operator a yield point?
`static Operator`	`lookupOpcode(int opcode)`
`String`	`toString()` Returns the string representation of this operator.

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

- Field Detail
  - none
```
public static final int none
```
    operator has no interesting traits
    
    See Also:
    
    Constant Field Values
  - move
```
protected static final int move
```
    operator is a simple move operation from one "register" to another
    
    See Also:
    
    Constant Field Values
  - branch
```
protected static final int branch
```
    operator is an intraprocedural branch of some form
    
    See Also:
    
    Constant Field Values
  - call
```
protected static final int call
```
    operator is some kind of call (interprocedural branch)
    
    See Also:
    
    Constant Field Values
  - conditional
```
protected static final int conditional
```
    modifer for branches/calls
    
    See Also:
    
    Constant Field Values
  - indirect
```
protected static final int indirect
```
    modifier for branches/calls, mostly on MIR
    
    See Also:
    
    Constant Field Values
  - load
```
protected static final int load
```
    an explicit load of a value from memory
    
    See Also:
    
    Constant Field Values
  - memAsLoad
```
protected static final int memAsLoad
```
    operator is modeled as a load by memory system, mostly on MIR
    
    See Also:
    
    Constant Field Values
  - store
```
protected static final int store
```
    an explicit store of a value to memory
    
    See Also:
    
    Constant Field Values
  - memAsStore
```
protected static final int memAsStore
```
    operator is modeled as a store by memory system, mostly on MIR
    
    See Also:
    
    Constant Field Values
  - ethrow
```
protected static final int ethrow
```
    is an exception throw
    
    See Also:
    
    Constant Field Values
  - immedPEI
```
protected static final int immedPEI
```
    an immediate PEI (null_check, int_zero_check, but _not_ call);
    
    See Also:
    
    Constant Field Values
  - compare
```
protected static final int compare
```
    operator is some kind of compare (val,val)-> cond
    
    See Also:
    
    Constant Field Values
  - alloc
```
protected static final int alloc
```
    an explicit memory allocation
    
    See Also:
    
    Constant Field Values
  - ret
```
protected static final int ret
```
    a return instruction (interprocedural branch)
    
    See Also:
    
    Constant Field Values
  - varUses
```
public static final int varUses
```
    operator has a variable number of uses
    
    See Also:
    
    Constant Field Values
  - varDefs
```
public static final int varDefs
```
    operator has a variable number of defs
    
    See Also:
    
    Constant Field Values
  - tsp
```
protected static final int tsp
```
    operator is a potential thread switch point for some reason other than being a call/immedPEI
    
    See Also:
    
    Constant Field Values
  - acquire
```
protected static final int acquire
```
    operator is an acquire (monitorenter/lock) HIR only
    
    See Also:
    
    Constant Field Values
  - release
```
protected static final int release
```
    operator is a relase (monitorexit/unlock) HIR only
    
    See Also:
    
    Constant Field Values
  - dynLink
```
protected static final int dynLink
```
    operator either directly or indirectly may casue dynamic linking
    
    See Also:
    
    Constant Field Values
  - yieldPoint
```
protected static final int yieldPoint
```
    operator is a yield point
    
    See Also:
    
    Constant Field Values
  - fpPop
```
protected static final int fpPop
```
    operator pops floating-point stack after performing defs
    
    See Also:
    
    Constant Field Values
  - fpPush
```
protected static final int fpPush
```
    operator pushs floating-point stack before performing defs
    
    See Also:
    
    Constant Field Values
  - commutative
```
protected static final int commutative
```
    operator is commutative
    
    See Also:
    
    Constant Field Values
  - opcode
```
final char opcode
```
    The operators opcode. This value serves as a unique id suitable for use in switches
  - format
```
public final byte format
```
    Encoding of the operator's InstructionFormat. This field is only meant to be directly referenced from the mechanically generated InstructionFormat classes defined in the instructionFormats package. Instruction contains an explanation of the role of InstructionFormats in the IR.
  - traits
```
private final int traits
```
    encoding of operator traits (characteristics)
  - numberDefs
```
private final int numberDefs
```
    How many operands of the operator are (pure) defs?
  - numberDefUses
```
private final int numberDefUses
```
    How many operands of the operator are both defs and uses? Only non-zero on IA32, 390.
  - numberUses
```
private final int numberUses
```
    How many operands of the operator are pure uses? Only contains a valid value for non-variableLength operators
  - implicitDefs
```
public final int implicitDefs
```
    Physical registers that are implicitly defined by the operator.
  - implicitUses
```
public final int implicitUses
```
    Physical registers that are implicitly used by the operator.
- Constructor Detail
  - Operator
```
protected Operator(char opcode,
                   byte format,
                   int traits,
                   int numDefs,
                   int numDefUses,
                   int numUses,
                   int iDefs,
                   int iUses)
```
- Method Detail
  - lookupOpcode
```
public static Operator lookupOpcode(int opcode)
```
  - getOpcode
```
public final char getOpcode()
```
  - toString
```
public String toString()
```
    Returns the string representation of this operator.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the name of the operator
  - getNumberOfPureDefs
```
public int getNumberOfPureDefs()
```
    Returns the number of operands that are 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.
    
    Returns:
    
    number of operands that are pure defs
  - getNumberOfFixedPureDefs
```
public int getNumberOfFixedPureDefs()
```
    Returns the number of operands that are pure defs and are not in the variable-length part of the operand list. By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses.
    
    Returns:
    
    how many non-variable operands are pure defs
  - getNumberOfFixedPureUses
```
public int getNumberOfFixedPureUses()
```
    Returns the number of operands that are pure uses and are not in the variable-length part of the operand list. By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses.
    
    Returns:
    
    how many non-variable operands are pure uses
  - getNumberOfDefUses
```
public int getNumberOfDefUses()
```
    Returns the number of operands that are defs and 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.
    
    Returns:
    
    number of operands that are combined defs and uses
  - 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.
    
    Returns:
    
    number of operands that are pure uses
  - 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.
    
    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.
    
    Returns:
    
    how many operands are uses
  - getNumberOfPureFixedUses
```
public int getNumberOfPureFixedUses()
```
    Returns the number of operands that are pure uses and are not in the variable-length part of the operand list. By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses.
    
    Returns:
    
    how many non-variable operands are pure uses
  - getNumberOfFixedUses
```
public int getNumberOfFixedUses()
```
    Returns the number of operands that are uses (either combined use/defs or pure uses) and are not in the variable-length part of the operand list. By convention, operands are ordered in instructions such that all defs are first, followed by all combined defs/uses, followed by all pure uses.
    
    Returns:
    
    number of non-variable operands are uses
  - getNumberOfImplicitDefs
```
public int getNumberOfImplicitDefs()
```
    Returns the number of physical registers that are implicitly defined by this operator.
    
    Returns:
    
    number of implicit defs
  - getNumberOfImplicitUses
```
public int getNumberOfImplicitUses()
```
    Returns the number of physical registers that are implicitly used by this operator.
    
    Returns:
    
    number of implicit uses
  - isMove
```
public boolean isMove()
```
    Does the operator represent a simple move (the value is unchanged) from one "register" location to another "register" location?
    
    Returns:
    
    true if the operator is a simple move or false if it is not.
  - isBranch
```
public boolean isBranch()
```
    Is the operator an intraprocedural branch?
    
    Returns:
    
    true if the operator is am intraprocedural branch or false if it is not.
  - isConditionalBranch
```
public boolean isConditionalBranch()
```
    Is the operator a conditional intraprocedural branch?
    
    Returns:
    
    true if the operator is a conditoonal intraprocedural branch or false if it is not.
  - isUnconditionalBranch
```
public boolean isUnconditionalBranch()
```
    Is the operator 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 operator is an unconditional intraprocedural branch or false if it is not.
  - isDirectBranch
```
public boolean isDirectBranch()
```
    Is the operator 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 operator is a direct intraprocedural branch or false if it is not.
  - isIndirectBranch
```
public boolean isIndirectBranch()
```
    Is the operator an indirect intraprocedural branch?
    
    Returns:
    
    true if the operator is an indirect interprocedural branch or false if it is not.
  - isCall
```
public boolean isCall()
```
    Is the operator a call (one kind of interprocedural branch)?
    
    Returns:
    
    true if the operator is a call or false if it is not.
  - isConditionalCall
```
public boolean isConditionalCall()
```
    Is the operator 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 operator is a conditional call or false if it is not.
  - isUnconditionalCall
```
public boolean isUnconditionalCall()
```
    Is the operator 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 operator is an unconditional call or false if it is not.
  - isDirectCall
```
public boolean isDirectCall()
```
    Is the operator 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 operator is a direct call or false if it is not.
  - isIndirectCall
```
public boolean isIndirectCall()
```
    Is the operator 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 operator is an indirect call or false if it is not.
  - isExplicitLoad
```
public boolean isExplicitLoad()
```
    Is the operator 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 operator is an explicit load or false if it is not.
  - isImplicitLoad
```
public boolean isImplicitLoad()
```
    Should the operator 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 operator is an implicit load or false if it is not.
  - isExplicitStore
```
public boolean isExplicitStore()
```
    Is the operator 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 operator is an explicit store or false if it is not.
  - isImplicitStore
```
public boolean isImplicitStore()
```
    Should the operator 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 operator is an implicit store or false if it is not.
  - isThrow
```
public boolean isThrow()
```
    Is the operator a throw of a Java exception?
    
    Returns:
    
    true if the operator is a throw or false if it is not.
  - isPEI
```
public boolean isPEI()
```
    Is the operator a PEI (Potentially Excepting Instruction)?
    
    Returns:
    
    true if the operator is a PEI or false if it is not.
  - isGCPoint
```
public boolean isGCPoint()
```
    Is the operator a potential GC point?
    
    Returns:
    
    true if the operator is a potential GC point or false if it is not.
  - isTSPoint
```
public boolean isTSPoint()
```
    is the operator a potential thread switch point?
    
    Returns:
    
    true if the operator is a potential threadswitch point or false if it is not.
  - isCompare
```
public boolean isCompare()
```
    Is the operator a compare (val,val) => condition?
    
    Returns:
    
    true if the operator is a compare or false if it is not.
  - isAllocation
```
public boolean isAllocation()
```
    Is the operator an actual memory allocation instruction (NEW, NEWARRAY, etc)?
    
    Returns:
    
    true if the operator is an allocation or false if it is not.
  - isReturn
```
public boolean isReturn()
```
    Is the operator a return (interprocedural branch)?
    
    Returns:
    
    true if the operator is a return or false if it is not.
  - hasVarUses
```
public boolean hasVarUses()
```
    Can the operator have a variable number of uses?
    
    Returns:
    
    true if the operator has a variable number of uses or false if it does not.
  - hasVarDefs
```
public boolean hasVarDefs()
```
    Can the operator have a variable number of uses?
    
    Returns:
    
    true if the operator has a variable number of uses or false if it does not.
  - hasVarUsesOrDefs
```
public boolean hasVarUsesOrDefs()
```
    Can the operator have a variable number of uses or defs?
    
    Returns:
    
    true if the operator has a variable number of uses or defs or false if it does not.
  - isAcquire
```
public boolean isAcquire()
```
    Is the operator an acquire (monitorenter/lock)?
    
    Returns:
    
    true if the operator is an acquire or false if it is not.
  - isRelease
```
public boolean isRelease()
```
    Is the operator a release (monitorexit/unlock)?
    
    Returns:
    
    true if the operator is a release or false if it is not.
  - isDynamicLinkingPoint
```
public boolean isDynamicLinkingPoint()
```
    Could the operator either directly or indirectly cause dynamic class loading?
    
    Returns:
    
    true if the operator is a dynamic linking point or false if it is not.
  - isYieldPoint
```
public boolean isYieldPoint()
```
    Is the operator a yield point?
    
    Returns:
    
    true if the operator is a yield point or false if it is not.
  - isFpPop
```
public boolean isFpPop()
```
    Does the operator pop the floating-point stack?
    
    Returns:
    
    true if the operator pops the floating-point stack. or false if not.
  - isFpPush
```
public boolean isFpPush()
```
    Does the operator push on the floating-point stack?
    
    Returns:
    
    true if the operator pushes on the floating-point stack. or false if not.
  - isCommutative
```
public boolean isCommutative()
```
    Is the operator commutative?
    
    Returns:
    
    true if the operator is commutative. or false if not.
  - isCallSaveVolatile
```
public boolean isCallSaveVolatile()
```
    Returns:
    
    whether this is a operator a call to a routine that will save volatile registers
  - isAdviseESP
```
public boolean isAdviseESP()
```
    Returns:
    
    is this the IA32 ADVISE_ESP operator?
  - isFNInit
```
public boolean isFNInit()
```
    Returns:
    
    is this the IA32 FNINIT operator?
  - isFClear
```
public boolean isFClear()
```
    Returns:
    
    is this the IA32 FCLEAR operator?
  - instTemplate
```
public abstract int instTemplate()
```
    Returns:
    
    Instruction template used by the assembler to generate binary code. Only valid on MIR operators.

Class Operator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

none

move

branch

call

conditional

indirect

load

memAsLoad

store

memAsStore

ethrow

immedPEI

compare

alloc

ret

varUses

varDefs

tsp

acquire

release

dynLink

yieldPoint

fpPop

fpPush

commutative

opcode

format

traits

numberDefs

numberDefUses

numberUses

implicitDefs

implicitUses

Constructor Detail

Operator

Method Detail

lookupOpcode

getOpcode

toString

getNumberOfPureDefs

getNumberOfFixedPureDefs

getNumberOfFixedPureUses

getNumberOfDefUses

getNumberOfPureUses

getNumberOfDefs

getNumberOfUses

getNumberOfPureFixedUses

getNumberOfFixedUses

getNumberOfImplicitDefs

getNumberOfImplicitUses

isMove

isBranch

isConditionalBranch

isUnconditionalBranch

isDirectBranch

isIndirectBranch

isCall

isConditionalCall

isUnconditionalCall

isDirectCall

isIndirectCall

isExplicitLoad

isImplicitLoad

isExplicitStore

isImplicitStore

isThrow

isPEI

isGCPoint

isTSPoint

isCompare

isAllocation

isReturn

hasVarUses

hasVarDefs