RegisterOperand (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.opt.ir.operand.Operand
- - org.jikesrvm.compilers.opt.ir.operand.RegisterOperand

```
public final class RegisterOperand
extends Operand
```
A symbolic or physical register. A wrapper around an Register that may contain program-point specific information about the value denoted by the Register.
TODO: This class is due for a refactor into subclasses to split out the symbolic & physical registers and to create special behavior for symbolic registers used as phi operands and as validation (guard) operands.

See Also:

Operand

Field Summary

Fields
Modifier and Type	Field and Description
`private static byte`	`BOUNDS_CHECK` Guard operand that originates from a bounds-check
`private boolean`	`convertedFromRef` Converted from a reference?
`private static int`	`DECLARED_TYPE` The type has been declared as obtained from a getfield, getstatic, putfield, putstatic, array load
`private static byte`	`EXTANT` is this an extant object?
`private byte`	`flags` Type of a RegisterOperand can be in one of three states: a- declared: the type obtained from a getfield,getstatic,putfield,putstatic,array load b- precise: obtained from a NEW.
`private byte`	`flags2` Some bits used to characterize guards.
`private Operand`	`guard` The guard associated with a RegisterOperand.
`private RegisterOperand`	`nextInDefUseList` Used to maintain def and use lists.
`private static byte`	`NON_VOLATILE` is this a non-volatile physical register?
`private static byte`	`NOT_TAKEN` guard operand that represents a not taken branch
`private static byte`	`NULL_CHECK` Guard operand that originates from a null-check
`private static byte`	`PARAMETER` the register operand is for a parameter
`private static int`	`POSITIVE` Is the contents of the int-like register always positive?
`private static int`	`PRECISE_TYPE` We know precisely the type as it was create by a NEW
`private Register`	`register` Register object that this operand uses.
`private static byte`	`TAKEN` guard operand that represents a taken branch
`private TypeReference`	`type` Inferred data type of the contents of the register.

Fields inherited from class org.jikesrvm.compilers.opt.ir.operand.Operand
instruction

Constructor Summary

Constructors
Constructor and Description
`RegisterOperand(Register reg, TypeReference typ)` Constructs a new register operand with the given register and data type.
`RegisterOperand(Register reg, TypeReference typ, byte inFlags, boolean isPrecise, boolean isDeclared)` Constructs a new register operand with the given register, data type and flags.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addFlags(byte inFlag)` Merges two sets of register flags.
`void`	`clearBoundsCheck()`
`void`	`clearDeclaredType()`
`void`	`clearExtant()`
`void`	`clearFlags()`
`void`	`clearNonVolatile()`
`void`	`clearNotTaken()` Clear this from being a guard operand from a not taken branch
`void`	`clearNullCheck()`
`void`	`clearParameter()`
`void`	`clearPreciseType()`
`void`	`clearTaken()` Clear this from being a guard operand from a taken branch
`boolean`	`convertedFromRef()`
`Operand`	`copy()` Returns a copy of this register operand as an operand
`RegisterOperand`	`copyD2D()`
`RegisterOperand`	`copyD2U()`
`RegisterOperand`	`copyRO()` Returns a copy of this register operand as a register operand.
`void`	`copyTypeFrom(RegisterOperand rhs)` Copy type information from the given operand into this one including flag information on whether this is a precise type or not
`RegisterOperand`	`copyU2D()`
`RegisterOperand`	`copyU2U()`
`void`	`flagAsConvertedFromRef()`
`byte`	`getFlags()`
`Operand`	`getGuard()`
`RegisterOperand`	`getNext()`
`Register`	`getRegister()`
`TypeReference`	`getType()` Return the `TypeReference` of the value represented by the operand.
`boolean`	`hasLessConservativeFlags(RegisterOperand other)`
`boolean`	`isAddress()` Does the operand represent a value of the address data type?
`boolean`	`isBoundsCheck()`
`boolean`	`isDeclaredOrPreciseType()`
`boolean`	`isDeclaredType()`
`boolean`	`isDefinitelyNull()` Does the operand definitely represent `null`?
`boolean`	`isDouble()` Does the operand represent a value of the double data type?
`boolean`	`isExtant()` Is this register known to contain either NULL or an object whose class was fully loaded before the current method was called?
`boolean`	`isFloat()` Does the operand represent a value of the float data type?
`boolean`	`isInt()` Does the operand represent a value of the int data type?
`boolean`	`isIntLike()` Does the operand represent a value of an int-like data type?
`boolean`	`isLong()` Does the operand represent a value of the long data type?
`boolean`	`isNonVolatile()`
`boolean`	`isNotTaken()`
`boolean`	`isNullCheck()`
`boolean`	`isParameter()`
`boolean`	`isPositiveInt()`
`boolean`	`isPreciseType()`
`boolean`	`isRef()` Does the operand represent a value of the reference data type?
`boolean`	`isTaken()`
`void`	`meetInheritableFlags(RegisterOperand other)` Currently all flags are "meetable", so mask flags together.
`void`	`refine(TypeReference t)` Refine the type of the register to t if t is a more precise type than the register currently holds
`boolean`	`sameRegisterPropertiesAs(RegisterOperand other)` Note: This method is currently used only by test cases.
`boolean`	`sameRegisterPropertiesAsExceptForGuardWhichIsSimilar(RegisterOperand other)` Note: This method is currently used only by test cases.
`void`	`setBoundsCheck()`
`void`	`setDeclaredType()`
`void`	`setExtant()` Sets this register as holding an extant object (or NULL) (ie, an object whose class was fully loaded before the current method was called).
`void`	`setGuard(Operand guard)`
`void`	`setInheritableFlags(RegisterOperand src)` Currently all flags are inheritable, so copy all flags from src.
`void`	`setNext(RegisterOperand next)` Sets the next register operand in the def/use list.
`void`	`setNonVolatile()`
`void`	`setNotTaken()` Set this a guard operand from a not taken branch
`void`	`setNullCheck()`
`void`	`setParameter()`
`void`	`setPositiveInt()`
`void`	`setPreciseType()`
`void`	`setPreciseType(TypeReference t)` Set the `TypeReference` of the value represented by the operand and make the type precise.
`void`	`setRegister(Register register)`
`void`	`setTaken()` Set this a guard operand from a taken branch
`void`	`setType(TypeReference t)` Set the `TypeReference` of the value represented by the operand.
`boolean`	`similar(Operand op)` Are two operands semantically equivalent?
`String`	`toString()`
`private void`	`verifyPreciseType()`

Methods inherited from class org.jikesrvm.compilers.opt.ir.operand.Operand
asAddressConstant, asBlock, asBranch, asClassConstant, asCondition, asDoubleConstant, asFloatConstant, asIntConstant, asLocation, asLongConstant, asMemory, asMethod, asNullConstant, asObjectConstant, asRegister, asStackLocation, asStringConstant, asTIBConstant, asType, conservativelyApproximates, getIndexInInstruction, isAddressConstant, isBlock, isBranch, isClassConstant, isConstant, isDoubleConstant, isFloatConstant, isIntConstant, isLocation, isLongConstant, isMemory, isMethod, isMovableObjectConstant, isNullConstant, isObjectConstant, isRegister, isStackLocation, isStringConstant, isTIBConstant, isTrueGuard, isType, meet

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

- Field Detail
  - convertedFromRef
```
private boolean convertedFromRef
```
    Converted from a reference?
  - register
```
private Register register
```
    Register object that this operand uses.
  - type
```
private TypeReference type
```
    Inferred data type of the contents of the register.
  - nextInDefUseList
```
private RegisterOperand nextInDefUseList
```
    Used to maintain def and use lists.
  - guard
```
private Operand guard
```
    The guard associated with a RegisterOperand.
    Used in the construction of the high-level intermediate representation.
  - flags
```
private byte flags
```
    Type of a RegisterOperand can be in one of three states:
    1. a- declared: the type obtained from a getfield,getstatic,putfield,putstatic,array load
    2. b- precise: obtained from a NEW.
    3. c- computed: (default) computed from propagating types.
    If the register is holding an int-like type it can be holding just positive values. For calling conventions registers can be for parameters or volatile/non-volatile. The value in the register can also be extant - that is a definite non-null value (e.g. this pointer).
  - DECLARED_TYPE
```
private static final int DECLARED_TYPE
```
    The type has been declared as obtained from a getfield, getstatic, putfield, putstatic, array load
    
    See Also:
    
    Constant Field Values
  - PRECISE_TYPE
```
private static final int PRECISE_TYPE
```
    We know precisely the type as it was create by a NEW
    
    See Also:
    
    Constant Field Values
  - POSITIVE
```
private static final int POSITIVE
```
    Is the contents of the int-like register always positive?
    
    See Also:
    
    Constant Field Values
  - PARAMETER
```
private static final byte PARAMETER
```
    the register operand is for a parameter
    
    See Also:
    
    Constant Field Values
  - NON_VOLATILE
```
private static final byte NON_VOLATILE
```
    is this a non-volatile physical register?
    
    See Also:
    
    Constant Field Values
  - EXTANT
```
private static final byte EXTANT
```
    is this an extant object?
    
    See Also:
    
    Constant Field Values
  - flags2
```
private byte flags2
```
    Some bits used to characterize guards. TODO: Maybe declare a new type GuardOperand extends RegisterOperand, and save this state there?
  - TAKEN
```
private static final byte TAKEN
```
    guard operand that represents a taken branch
    
    See Also:
    
    Constant Field Values
  - NOT_TAKEN
```
private static final byte NOT_TAKEN
```
    guard operand that represents a not taken branch
    
    See Also:
    
    Constant Field Values
  - BOUNDS_CHECK
```
private static final byte BOUNDS_CHECK
```
    Guard operand that originates from a bounds-check
    
    See Also:
    
    Constant Field Values
  - NULL_CHECK
```
private static final byte NULL_CHECK
```
    Guard operand that originates from a null-check
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RegisterOperand
```
public RegisterOperand(Register reg,
                       TypeReference typ)
```
    Constructs a new register operand with the given register and data type.
    
    Parameters:
    
    reg - register object
    
    typ - data type
  - RegisterOperand
```
public RegisterOperand(Register reg,
                       TypeReference typ,
                       byte inFlags,
                       boolean isPrecise,
                       boolean isDeclared)
```
    Constructs a new register operand with the given register, data type and flags.
    
    Parameters:
    
    reg - register object
    
    typ - data type
    
    inFlags - to set for this register
    
    isPrecise - is this a precise type
    
    isDeclared - is this a declared type
- Method Detail
  - copy
```
public Operand copy()
```
    Returns a copy of this register operand as an operand
    
    Specified by:
    
    copy in class Operand
    
    Returns:
    
    a copy of this
  - copyRO
```
public RegisterOperand copyRO()
```
    Returns a copy of this register operand as a register operand.
    NOTE: preserves the flags, guards and def/use lists.
    
    Returns:
    
    a copy of this register operand
  - copyU2U
```
public RegisterOperand copyU2U()
```
    Returns:
    
    a copy of this use register operand as another use reg operand.
  - copyD2U
```
public RegisterOperand copyD2U()
```
    Returns:
    
    a copy of this def register operand as a use.
  - copyU2D
```
public RegisterOperand copyU2D()
```
    Returns:
    
    a copy of this use register operand as a def.
  - copyD2D
```
public RegisterOperand copyD2D()
```
    Returns:
    
    a copy of this def register operand as a def.
  - similar
```
public boolean similar(Operand op)
```
    Description copied from class: Operand
    
    Are two operands semantically equivalent?
    
    Specified by:
    
    similar in class Operand
    
    Parameters:
    
    op - operand to compare against
    
    Returns:
    
    whether the given operand is a register operand and has the same register object.
  - copyTypeFrom
```
public void copyTypeFrom(RegisterOperand rhs)
```
    Copy type information from the given operand into this one including flag information on whether this is a precise type or not
    
    Parameters:
    
    rhs - the type to copy information from
  - isIntLike
```
public boolean isIntLike()
```
    Description copied from class: Operand
    
    Does the operand represent a value of an int-like data type?
    
    Overrides:
    
    isIntLike in class Operand
    
    Returns:
    
    true if the data type of this is int-like as defined by TypeReference.isIntLikeType() or false if it is not.
  - isInt
```
public boolean isInt()
```
    Description copied from class: Operand
    
    Does the operand represent a value of the int data type?
    
    Overrides:
    
    isInt in class Operand
    
    Returns:
    
    true if the data type of this is an int as defined by TypeReference.isIntType() or false if it is not.
  - isLong
```
public boolean isLong()
```
    Description copied from class: Operand
    
    Does the operand represent a value of the long data type?
    
    Overrides:
    
    isLong in class Operand
    
    Returns:
    
    true if the data type of this is a long as defined by TypeReference.isLongType() or false if it is not.
  - isFloat
```
public boolean isFloat()
```
    Description copied from class: Operand
    
    Does the operand represent a value of the float data type?
    
    Overrides:
    
    isFloat in class Operand
    
    Returns:
    
    true if the data type of this is a float as defined by TypeReference.isFloatType() or false if it is not.
  - isDouble
```
public boolean isDouble()
```
    Description copied from class: Operand
    
    Does the operand represent a value of the double data type?
    
    Overrides:
    
    isDouble in class Operand
    
    Returns:
    
    true if the data type of this is a double as defined by TypeReference.isDoubleType() or false if it is not.
  - isRef
```
public boolean isRef()
```
    Description copied from class: Operand
    
    Does the operand represent a value of the reference data type?
    
    Overrides:
    
    isRef in class Operand
    
    Returns:
    
    true if the data type of this is a reference as defined by TypeReference.isReferenceType() or false if it is not.
  - isAddress
```
public boolean isAddress()
```
    Description copied from class: Operand
    
    Does the operand represent a value of the address data type?
    
    Overrides:
    
    isAddress in class Operand
    
    Returns:
    
    true if the data type of this is an address as defined by TypeReference.isAddressType() or false if it is not.
  - isDefinitelyNull
```
public boolean isDefinitelyNull()
```
    Description copied from class: Operand
    
    Does the operand definitely represent null?
    
    Overrides:
    
    isDefinitelyNull in class Operand
    
    Returns:
    
    true if the operand definitely represents null or false if it does not.
  - isParameter
```
public boolean isParameter()
```
  - setParameter
```
public void setParameter()
```
  - clearParameter
```
public void clearParameter()
```
  - isNonVolatile
```
public boolean isNonVolatile()
```
  - setNonVolatile
```
public void setNonVolatile()
```
  - clearNonVolatile
```
public void clearNonVolatile()
```
  - isExtant
```
public boolean isExtant()
```
    Is this register known to contain either NULL or an object whose class was fully loaded before the current method was called? This fact is used to determine whether we can optimize away inline guards based on pre-existence based inlining.
    
    Returns:
    
    true if this register is extant (see above)
  - setExtant
```
public void setExtant()
```
    Sets this register as holding an extant object (or NULL) (ie, an object whose class was fully loaded before the current method was called). This fact is used to determine whether we can optimize away inline guards based on pre-existence based inlining.
  - clearExtant
```
public void clearExtant()
```
  - isDeclaredType
```
public boolean isDeclaredType()
```
  - setDeclaredType
```
public void setDeclaredType()
```
  - clearDeclaredType
```
public void clearDeclaredType()
```
  - verifyPreciseType
```
private void verifyPreciseType()
```
  - isPreciseType
```
public boolean isPreciseType()
```
  - setPreciseType
```
public void setPreciseType()
```
  - clearPreciseType
```
public void clearPreciseType()
```
  - isDeclaredOrPreciseType
```
public boolean isDeclaredOrPreciseType()
```
  - isPositiveInt
```
public boolean isPositiveInt()
```
  - setPositiveInt
```
public void setPositiveInt()
```
  - getFlags
```
public byte getFlags()
```
    Returns:
    
    a byte encoding register flags
  - clearFlags
```
public void clearFlags()
```
  - addFlags
```
public void addFlags(byte inFlag)
```
    Merges two sets of register flags.
    
    Parameters:
    
    inFlag - the flags to merge to this register's flags
  - setInheritableFlags
```
public void setInheritableFlags(RegisterOperand src)
```
    Currently all flags are inheritable, so copy all flags from src.
    
    Parameters:
    
    src - the operand to copy the flags from
  - meetInheritableFlags
```
public void meetInheritableFlags(RegisterOperand other)
```
    Currently all flags are "meetable", so mask flags together.
    
    Parameters:
    
    other - the operand to use for computing the meet
  - hasLessConservativeFlags
```
public boolean hasLessConservativeFlags(RegisterOperand other)
```
    Parameters:
    
    other - operand to compare with
    
    Returns:
    
    true if we have any bits set (flag true) that other doesn't. It's ok for other to have bits set true that we have set to false.
  - isTaken
```
public boolean isTaken()
```
    Returns:
    
    true if this is a guard operand from a taken branch
  - setTaken
```
public void setTaken()
```
    Set this a guard operand from a taken branch
  - clearTaken
```
public void clearTaken()
```
    Clear this from being a guard operand from a taken branch
  - isNotTaken
```
public boolean isNotTaken()
```
    Returns:
    
    true if this is a guard operand from a not taken branch
  - setNotTaken
```
public void setNotTaken()
```
    Set this a guard operand from a not taken branch
  - clearNotTaken
```
public void clearNotTaken()
```
    Clear this from being a guard operand from a not taken branch
  - isBoundsCheck
```
public boolean isBoundsCheck()
```
  - setBoundsCheck
```
public void setBoundsCheck()
```
  - clearBoundsCheck
```
public void clearBoundsCheck()
```
  - isNullCheck
```
public boolean isNullCheck()
```
  - setNullCheck
```
public void setNullCheck()
```
  - clearNullCheck
```
public void clearNullCheck()
```
  - setNext
```
public void setNext(RegisterOperand next)
```
    Sets the next register operand in the def/use list.
    
    Parameters:
    
    next - next register operand in the list
  - getNext
```
public RegisterOperand getNext()
```
    Returns:
    
    the next operand in the def/use list
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - setRegister
```
public void setRegister(Register register)
```
  - getRegister
```
public Register getRegister()
```
  - setType
```
public void setType(TypeReference t)
```
    Set the TypeReference of the value represented by the operand.
    
    Parameters:
    
    t - the inferred data type of the contents of the register
  - setPreciseType
```
public void setPreciseType(TypeReference t)
```
    Set the TypeReference of the value represented by the operand and make the type precise.
    
    Parameters:
    
    t - the inferred data type of the contents of the register
  - getType
```
public TypeReference getType()
```
    Return the TypeReference of the value represented by the operand.
    
    Overrides:
    
    getType in class Operand
    
    Returns:
    
    the inferred data type of the contents of the register
  - flagAsConvertedFromRef
```
public void flagAsConvertedFromRef()
```
  - convertedFromRef
```
public boolean convertedFromRef()
```
  - refine
```
public void refine(TypeReference t)
```
    Refine the type of the register to t if t is a more precise type than the register currently holds
    
    Parameters:
    
    t - type to try to refine to
  - sameRegisterPropertiesAs
```
public boolean sameRegisterPropertiesAs(RegisterOperand other)
```
    Note: This method is currently used only by test cases.
    Does this operand have the same properties as the given Operand? This method checks only the properties specific to RegisterOperand.
    
    Parameters:
    
    other - the operand to compare with
    
    Returns:
    
    whether the given RegisterOperand could be seen as a copy of this one
  - sameRegisterPropertiesAsExceptForGuardWhichIsSimilar
```
public boolean sameRegisterPropertiesAsExceptForGuardWhichIsSimilar(RegisterOperand other)
```
    Note: This method is currently used only by test cases.
    Does this operand have the same properties as the given Operand? This method checks only the properties specific to RegisterOperand. For guards, similarity of operands is sufficient.
    
    Parameters:
    
    other - the operand to compare with
    
    Returns:
    
    whether the given RegisterOperand could be seen as a copy of this one
  - getGuard
```
public Operand getGuard()
```
  - setGuard
```
public void setGuard(Operand guard)
```

Class RegisterOperand

Field Summary

Fields inherited from class org.jikesrvm.compilers.opt.ir.operand.Operand

Constructor Summary

Method Summary

Methods inherited from class org.jikesrvm.compilers.opt.ir.operand.Operand

Methods inherited from class java.lang.Object

Field Detail

convertedFromRef

register

type

nextInDefUseList

guard

flags

DECLARED_TYPE

PRECISE_TYPE

POSITIVE

PARAMETER

NON_VOLATILE

EXTANT

flags2

TAKEN

NOT_TAKEN

BOUNDS_CHECK

NULL_CHECK

Constructor Detail

RegisterOperand

RegisterOperand

Method Detail

copy

copyRO

copyU2U

copyD2U

copyU2D

copyD2D

similar

copyTypeFrom

isIntLike

isInt

isLong

isFloat

isDouble

isRef

isAddress

isDefinitelyNull

isParameter

setParameter

clearParameter

isNonVolatile

setNonVolatile

clearNonVolatile

isExtant

setExtant

clearExtant

isDeclaredType

setDeclaredType

clearDeclaredType

verifyPreciseType

isPreciseType

setPreciseType

clearPreciseType

isDeclaredOrPreciseType

isPositiveInt

setPositiveInt

getFlags

clearFlags

addFlags

setInheritableFlags

meetInheritableFlags

hasLessConservativeFlags

isTaken

setTaken

clearTaken

isNotTaken

setNotTaken

clearNotTaken

isBoundsCheck

setBoundsCheck

clearBoundsCheck

isNullCheck