ConditionOperand (Jikes RVM API)

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

```
public final class ConditionOperand
extends Operand
```
Encodes the condition codes for branches.

See Also:

Operand

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`BIT_TEST` Would is bit b set in a?
`static int`	`BORROW_FROM_RSUB` Would b-a produce a borrow?
`static int`	`BORROW_FROM_SUB` Would a-b produce a borrow?
`static int`	`CARRY_FROM_ADD` Would a+b produce a carry?
`static int`	`CMPG_GREATER` Branch if > or unordered - >FU
`static int`	`CMPG_GREATER_EQUAL` Brach if >= or unordered - >=FU
`static int`	`CMPG_LESS` Branch if < - <F
`static int`	`CMPG_LESS_EQUAL` Branch if <= - <=F
`static int`	`CMPL_EQUAL` Branch if == (equivalent to CMPG_EQUAL) - ==F
`static int`	`CMPL_GREATER` Branch if > - >F
`static int`	`CMPL_GREATER_EQUAL` Branch if >= - >=F
`static int`	`CMPL_LESS` Branch if < or unordered - <FU
`static int`	`CMPL_LESS_EQUAL` Branch if <= or unordered - <=FU
`static int`	`CMPL_NOT_EQUAL` Branch if !
`static int`	`EQUAL` Integer equal ==
`static int`	`FALSE` Evaluation result is false
`static int`	`GREATER` Signed integer >
`static int`	`GREATER_EQUAL` Signed integer >=
`static int`	`HIGHER` Unsigned integer > - >U
`static int`	`HIGHER_EQUAL` Unsigned integer >= - >=U
`static int`	`LESS` Signed integer <
`static int`	`LESS_EQUAL` Signed integer <=
`static int`	`LOWER` Unsigned integer < - <U
`static int`	`LOWER_EQUAL` Unsigned integer <= - <=U
`static int`	`NO_BIT_TEST` Would is bit b not set in a?
`static int`	`NO_BORROW_FROM_RSUB` Would b-a not produce a borrow?
`static int`	`NO_BORROW_FROM_SUB` Would a-b not produce a borrow?
`static int`	`NO_CARRY_FROM_ADD` Would a+b not produce a carry?
`static int`	`NO_OVERFLOW_FROM_ADD` Would a+b not cause an overflow?
`static int`	`NO_OVERFLOW_FROM_MUL` Would a*b not cause an overflow?
`static int`	`NO_OVERFLOW_FROM_RSUB` Would b-a not cause an overflow?
`static int`	`NO_OVERFLOW_FROM_SUB` Would a-b not cause an overflow?
`static int`	`NO_RBIT_TEST` Would is bit a not set in b?
`static int`	`NOT_EQUAL` Integer not equal !
`static int`	`OVERFLOW_FROM_ADD` Would a+b cause an overflow?
`static int`	`OVERFLOW_FROM_MUL` Would a*b cause an overflow?
`static int`	`OVERFLOW_FROM_RSUB` Would b-a cause an overflow?
`static int`	`OVERFLOW_FROM_SUB` Would a-b cause an overflow?
`static int`	`RBIT_TEST` Would is bit a set in b?
`static int`	`TRUE` Evaluation result is true
`static int`	`UNKNOWN` Evaluation result is unknown
`int`	`value` Value of this operand.

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

Constructor Summary

Constructors
Modifier Constructor and Description

private ConditionOperand(int code)

Constructors
Modifier	Constructor and Description
`private`	`ConditionOperand(int code)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static ConditionOperand`	`BIT_TEST()` Create the condition code operand for BIT_TEST
`private static boolean`	`bit_test(int x, int y)` Is bit y of x set?
`static ConditionOperand`	`BORROW_FROM_SUB()` Create the condition code operand for BORROW_FROM_SUB
`private static boolean`	`borrow_from_sub(int x, int y)` Would `x - y` produce a borrow?
`boolean`	`branchIfUnordered()` Will this floating point compare branch if the results are unordered?
`static ConditionOperand`	`CARRY_FROM_ADD()` Create the condition code operand for CARRY_FROM_ADD
`private static boolean`	`carry_from_add(int x, int y)` Would `x + y` produce a carry?
`static ConditionOperand`	`CMPG_LESS()` Create the condition code operand for CMPG_LESS
`static ConditionOperand`	`CMPL_EQUAL()` Create the condition code operand for CMPL_EQUAL
`static ConditionOperand`	`CMPL_GREATER_EQUAL()` Create the condition code operand for CMPL_GREATER_EQUAL
`static ConditionOperand`	`CMPL_GREATER()` Create the condition code operand for CMPL_GREATER
`static ConditionOperand`	`CMPL_NOT_EQUAL()` Create the condition code operand for CMPL_NOT_EQUAL
`Operand`	`copy()` Return a new operand that is semantically equivalent to `this`.
`static ConditionOperand`	`EQUAL()` Create the condition code operand for EQUAL
`int`	`evaluate(Address v1, Address v2)` Given two Addresses, evaluate the condition on them.
`int`	`evaluate(double v1, double v2)` Given two doubles, evaluate the condition on them.
`int`	`evaluate(float v1, float v2)` Given two floats, evaluate the condition on them.
`int`	`evaluate(int v1, int v2)` Given two ints, evaluate the condition on them.
`int`	`evaluate(long v1, long v2)` Given two longs, evaluate the condition on them.
`int`	`evaluate(Operand v1, Operand v2)` Given two operands, evaluate the condition on them.
`ConditionOperand`	`flipCode()` Flip the direction of the condition.
`ConditionOperand`	`flipOperands()` Change the condition code to allow the order of the operands to be flipped. i.e.
`static ConditionOperand`	`GREATER_EQUAL()` Create the condition code operand for GREATER_EQUAL
`static ConditionOperand`	`GREATER()` Create the condition code operand for GREATER
`static ConditionOperand`	`HIGHER_EQUAL()` Create the condition code operand for HIGHER_EQUAL
`private static boolean`	`higher_equal(int x, int y)` Is x higher equal (unsigned >=) than y?
`static ConditionOperand`	`HIGHER()` Create the condition code operand for HIGHER
`private static boolean`	`higher(int x, int y)` Is x higher (unsigned >) than y?
`boolean`	`isBIT_TEST()` Is the condition code a flag operation following a bit test?
`boolean`	`isEQUAL()` Is the condition code EQUAL?
`boolean`	`isFLAG_OPERATION_FROM_ADD()` Is the condition code a flag operation following an add?
`boolean`	`isFLAG_OPERATION_FROM_RSUB()` Is the condition code a flag operation following a reversed subtract?
`boolean`	`isFLAG_OPERATION_FROM_SUB()` Is the condition code a flag operation following a subtract?
`boolean`	`isFLAG_OPERATION()` Is the condition code a flag operation?
`boolean`	`isFLOATINGPOINT()` Is the condition code a floating point compare?
`boolean`	`isGREATER_EQUAL()` Is the condition code GREATER_EQUAL?
`boolean`	`isGREATER()` Is the condition code GREATER?
`boolean`	`isHIGHER_EQUAL()` Is the condition code HIGHER_EQUAL?
`boolean`	`isHIGHER()` Is the condition code HIGHER?
`boolean`	`isLESS_EQUAL()` Is the condition code LESS EQUAL?
`boolean`	`isLESS()` Is the condition code LESS?
`boolean`	`isLOWER_EQUAL()` Is the condition code LOWER_EQUAL?
`boolean`	`isLOWER()` Is the condition code LOWER?
`boolean`	`isNOT_EQUAL()` Is the condition code NOT_EQUAL?
`boolean`	`isRBIT_TEST()` Is the condition code a flag operation following a reversed bit test?
`boolean`	`isUNSIGNED()` Is the condition code an unsigned comparison?
`static ConditionOperand`	`LESS_EQUAL()` Create the condition code operand for LESS_EQUAL
`static ConditionOperand`	`LESS()` Create the condition code operand for LESS
`static ConditionOperand`	`LOWER_EQUAL()` Create the condition code operand for LOWER_EQUAL
`private static boolean`	`lower_equal(int x, int y)` Is x lower equal (unsigned <=) than y?
`static ConditionOperand`	`LOWER()` Create the condition code operand for LOWER
`private static boolean`	`lower(int x, int y)` Is x lower (unsigned <) than y?
`static ConditionOperand`	`NOT_EQUAL()` Create the condition code operand for NOT_EQUAL
`static ConditionOperand`	`OVERFLOW_FROM_ADD()` Create the condition code operand for OVERFLOW_FROM_ADD
`private static boolean`	`overflow_from_add(int x, int y)` Would `x + y` overflow a register?
`static ConditionOperand`	`OVERFLOW_FROM_MUL()` Create the condition code operand for OVERFLOW_FROM_ADD
`private static boolean`	`overflow_from_mul(int x, int y)` Would `x * y` overflow a register?
`static ConditionOperand`	`OVERFLOW_FROM_SUB()` Create the condition code operand for OVERFLOW_FROM_SUB
`private static boolean`	`overflow_from_sub(int x, int y)` Would `x - y` overflow a register?
`boolean`	`similar(Operand op)` Are two operands semantically equivalent?
`String`	`toString()` Returns the string representation of this operand.
`void`	`translateCMPG()` Convert this integer compare to a floating point cmpg compare.
`void`	`translateCMPL()` Convert this integer compare to a floating point cmpl compare.
`ConditionOperand`	`translateUNSIGNED()` Convert this floating point compare to the equivalent unsigned integer compare.

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, getType, isAddress, isAddressConstant, isBlock, isBranch, isClassConstant, isConstant, isDefinitelyNull, isDouble, isDoubleConstant, isFloat, isFloatConstant, isInt, isIntConstant, isIntLike, isLocation, isLong, isLongConstant, isMemory, isMethod, isMovableObjectConstant, isNullConstant, isObjectConstant, isRef, 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
  - EQUAL
```
public static final int EQUAL
```
    Integer equal ==
    
    See Also:
    
    Constant Field Values
  - NOT_EQUAL
```
public static final int NOT_EQUAL
```
    Integer not equal !=
    
    See Also:
    
    Constant Field Values
  - LESS
```
public static final int LESS
```
    Signed integer <
    
    See Also:
    
    Constant Field Values
  - GREATER_EQUAL
```
public static final int GREATER_EQUAL
```
    Signed integer >=
    
    See Also:
    
    Constant Field Values
  - GREATER
```
public static final int GREATER
```
    Signed integer >
    
    See Also:
    
    Constant Field Values
  - LESS_EQUAL
```
public static final int LESS_EQUAL
```
    Signed integer <=
    
    See Also:
    
    Constant Field Values
  - HIGHER
```
public static final int HIGHER
```
    Unsigned integer > - >U
    
    See Also:
    
    Constant Field Values
  - LOWER
```
public static final int LOWER
```
    Unsigned integer < - <U
    
    See Also:
    
    Constant Field Values
  - HIGHER_EQUAL
```
public static final int HIGHER_EQUAL
```
    Unsigned integer >= - >=U
    
    See Also:
    
    Constant Field Values
  - LOWER_EQUAL
```
public static final int LOWER_EQUAL
```
    Unsigned integer <= - <=U
    
    See Also:
    
    Constant Field Values
  - CMPL_EQUAL
```
public static final int CMPL_EQUAL
```
    Branch if == (equivalent to CMPG_EQUAL) - ==F
    
    See Also:
    
    Constant Field Values
  - CMPL_GREATER
```
public static final int CMPL_GREATER
```
    Branch if > - >F
    
    See Also:
    
    Constant Field Values
  - CMPG_LESS
```
public static final int CMPG_LESS
```
    Branch if < - <F
    
    See Also:
    
    Constant Field Values
  - CMPL_GREATER_EQUAL
```
public static final int CMPL_GREATER_EQUAL
```
    Branch if >= - >=F
    
    See Also:
    
    Constant Field Values
  - CMPG_LESS_EQUAL
```
public static final int CMPG_LESS_EQUAL
```
    Branch if <= - <=F
    
    See Also:
    
    Constant Field Values
  - CMPL_NOT_EQUAL
```
public static final int CMPL_NOT_EQUAL
```
    Branch if != (equivalent to CMPG_NOT_EQUAL) - !=FU
    
    See Also:
    
    Constant Field Values
  - CMPL_LESS
```
public static final int CMPL_LESS
```
    Branch if < or unordered - <FU
    
    See Also:
    
    Constant Field Values
  - CMPG_GREATER_EQUAL
```
public static final int CMPG_GREATER_EQUAL
```
    Brach if >= or unordered - >=FU
    
    See Also:
    
    Constant Field Values
  - CMPG_GREATER
```
public static final int CMPG_GREATER
```
    Branch if > or unordered - >FU
    
    See Also:
    
    Constant Field Values
  - CMPL_LESS_EQUAL
```
public static final int CMPL_LESS_EQUAL
```
    Branch if <= or unordered - <=FU
    
    See Also:
    
    Constant Field Values
  - CARRY_FROM_ADD
```
public static final int CARRY_FROM_ADD
```
    Would a+b produce a carry?
    
    See Also:
    
    Constant Field Values
  - NO_CARRY_FROM_ADD
```
public static final int NO_CARRY_FROM_ADD
```
    Would a+b not produce a carry?
    
    See Also:
    
    Constant Field Values
  - OVERFLOW_FROM_ADD
```
public static final int OVERFLOW_FROM_ADD
```
    Would a+b cause an overflow?
    
    See Also:
    
    Constant Field Values
  - NO_OVERFLOW_FROM_ADD
```
public static final int NO_OVERFLOW_FROM_ADD
```
    Would a+b not cause an overflow?
    
    See Also:
    
    Constant Field Values
  - BORROW_FROM_SUB
```
public static final int BORROW_FROM_SUB
```
    Would a-b produce a borrow?
    
    See Also:
    
    Constant Field Values
  - NO_BORROW_FROM_SUB
```
public static final int NO_BORROW_FROM_SUB
```
    Would a-b not produce a borrow?
    
    See Also:
    
    Constant Field Values
  - BORROW_FROM_RSUB
```
public static final int BORROW_FROM_RSUB
```
    Would b-a produce a borrow?
    
    See Also:
    
    Constant Field Values
  - NO_BORROW_FROM_RSUB
```
public static final int NO_BORROW_FROM_RSUB
```
    Would b-a not produce a borrow?
    
    See Also:
    
    Constant Field Values
  - OVERFLOW_FROM_SUB
```
public static final int OVERFLOW_FROM_SUB
```
    Would a-b cause an overflow?
    
    See Also:
    
    Constant Field Values
  - NO_OVERFLOW_FROM_SUB
```
public static final int NO_OVERFLOW_FROM_SUB
```
    Would a-b not cause an overflow?
    
    See Also:
    
    Constant Field Values
  - OVERFLOW_FROM_RSUB
```
public static final int OVERFLOW_FROM_RSUB
```
    Would b-a cause an overflow?
    
    See Also:
    
    Constant Field Values
  - NO_OVERFLOW_FROM_RSUB
```
public static final int NO_OVERFLOW_FROM_RSUB
```
    Would b-a not cause an overflow?
    
    See Also:
    
    Constant Field Values
  - BIT_TEST
```
public static final int BIT_TEST
```
    Would is bit b set in a?
    
    See Also:
    
    Constant Field Values
  - NO_BIT_TEST
```
public static final int NO_BIT_TEST
```
    Would is bit b not set in a?
    
    See Also:
    
    Constant Field Values
  - RBIT_TEST
```
public static final int RBIT_TEST
```
    Would is bit a set in b?
    
    See Also:
    
    Constant Field Values
  - NO_RBIT_TEST
```
public static final int NO_RBIT_TEST
```
    Would is bit a not set in b?
    
    See Also:
    
    Constant Field Values
  - OVERFLOW_FROM_MUL
```
public static final int OVERFLOW_FROM_MUL
```
    Would a*b cause an overflow?
    
    See Also:
    
    Constant Field Values
  - NO_OVERFLOW_FROM_MUL
```
public static final int NO_OVERFLOW_FROM_MUL
```
    Would a*b not cause an overflow?
    
    See Also:
    
    Constant Field Values
  - FALSE
```
public static final int FALSE
```
    Evaluation result is false
    
    See Also:
    
    Constant Field Values
  - TRUE
```
public static final int TRUE
```
    Evaluation result is true
    
    See Also:
    
    Constant Field Values
  - UNKNOWN
```
public static final int UNKNOWN
```
    Evaluation result is unknown
    
    See Also:
    
    Constant Field Values
  - value
```
public int value
```
    Value of this operand.
- Constructor Detail
  - ConditionOperand
```
private ConditionOperand(int code)
```
    Parameters:
    
    code - the condition code
- Method Detail
  - EQUAL
```
public static ConditionOperand EQUAL()
```
    Create the condition code operand for EQUAL
    
    Returns:
    
    a new condition code operand
  - NOT_EQUAL
```
public static ConditionOperand NOT_EQUAL()
```
    Create the condition code operand for NOT_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - LESS
```
public static ConditionOperand LESS()
```
    Create the condition code operand for LESS
    
    Returns:
    
    a newly created condition code operand
  - GREATER_EQUAL
```
public static ConditionOperand GREATER_EQUAL()
```
    Create the condition code operand for GREATER_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - GREATER
```
public static ConditionOperand GREATER()
```
    Create the condition code operand for GREATER
    
    Returns:
    
    a newly created condition code operand
  - LESS_EQUAL
```
public static ConditionOperand LESS_EQUAL()
```
    Create the condition code operand for LESS_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - HIGHER
```
public static ConditionOperand HIGHER()
```
    Create the condition code operand for HIGHER
    
    Returns:
    
    a newly created condition code operand
  - LOWER
```
public static ConditionOperand LOWER()
```
    Create the condition code operand for LOWER
    
    Returns:
    
    a newly created condition code operand
  - HIGHER_EQUAL
```
public static ConditionOperand HIGHER_EQUAL()
```
    Create the condition code operand for HIGHER_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - LOWER_EQUAL
```
public static ConditionOperand LOWER_EQUAL()
```
    Create the condition code operand for LOWER_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - CMPL_EQUAL
```
public static ConditionOperand CMPL_EQUAL()
```
    Create the condition code operand for CMPL_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - CMPL_NOT_EQUAL
```
public static ConditionOperand CMPL_NOT_EQUAL()
```
    Create the condition code operand for CMPL_NOT_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - CMPL_GREATER
```
public static ConditionOperand CMPL_GREATER()
```
    Create the condition code operand for CMPL_GREATER
    
    Returns:
    
    a newly created condition code operand
  - CMPL_GREATER_EQUAL
```
public static ConditionOperand CMPL_GREATER_EQUAL()
```
    Create the condition code operand for CMPL_GREATER_EQUAL
    
    Returns:
    
    a newly created condition code operand
  - CMPG_LESS
```
public static ConditionOperand CMPG_LESS()
```
    Create the condition code operand for CMPG_LESS
    
    Returns:
    
    a newly created condition code operand
  - CARRY_FROM_ADD
```
public static ConditionOperand CARRY_FROM_ADD()
```
    Create the condition code operand for CARRY_FROM_ADD
    
    Returns:
    
    a newly created condition code operand
  - OVERFLOW_FROM_ADD
```
public static ConditionOperand OVERFLOW_FROM_ADD()
```
    Create the condition code operand for OVERFLOW_FROM_ADD
    
    Returns:
    
    a newly created condition code operand
  - BORROW_FROM_SUB
```
public static ConditionOperand BORROW_FROM_SUB()
```
    Create the condition code operand for BORROW_FROM_SUB
    
    Returns:
    
    a newly created condition code operand
  - OVERFLOW_FROM_SUB
```
public static ConditionOperand OVERFLOW_FROM_SUB()
```
    Create the condition code operand for OVERFLOW_FROM_SUB
    
    Returns:
    
    a newly created condition code operand
  - BIT_TEST
```
public static ConditionOperand BIT_TEST()
```
    Create the condition code operand for BIT_TEST
    
    Returns:
    
    a newly created condition code operand
  - OVERFLOW_FROM_MUL
```
public static ConditionOperand OVERFLOW_FROM_MUL()
```
    Create the condition code operand for OVERFLOW_FROM_ADD
    
    Returns:
    
    a newly created condition code operand
  - higher
```
private static boolean higher(int x,
                              int y)
```
    Is x higher (unsigned >) than y?
    
    Parameters:
    
    x - first value for comparison
    
    y - second value for comparison
    
    Returns:
    
    true if x is higher (unsigned >) than y, false otherwise
  - lower
```
private static boolean lower(int x,
                             int y)
```
    Is x lower (unsigned <) than y?
    
    Parameters:
    
    x - first value for comparison
    
    y - second value for comparison
    
    Returns:
    
    true if x is lower (unsigned <) than y, false otherwise
  - higher_equal
```
private static boolean higher_equal(int x,
                                    int y)
```
    Is x higher equal (unsigned >=) than y?
    
    Parameters:
    
    x - first value for comparison
    
    y - second value for comparison
    
    Returns:
    
    true if x is higher equal (unsigned >=) than y, false otherwise
  - lower_equal
```
private static boolean lower_equal(int x,
                                   int y)
```
    Is x lower equal (unsigned <=) than y?
    
    Parameters:
    
    x - first value for comparison
    
    y - second value for comparison
    
    Returns:
    
    true if x is lower equal (unsigned <=) than y, false otherwise
  - carry_from_add
```
private static boolean carry_from_add(int x,
                                      int y)
```
    Would x + y produce a carry?
    
    Parameters:
    
    x - first summand
    
    y - second summand
    
    Returns:
    
    true if the addition would produce a carry, false otherwise
  - borrow_from_sub
```
private static boolean borrow_from_sub(int x,
                                       int y)
```
    Would x - y produce a borrow?
    
    Parameters:
    
    x - minuend
    
    y - subtrahend
    
    Returns:
    
    true if the subtraction would produce a borrow, false otherwise
  - overflow_from_add
```
private static boolean overflow_from_add(int x,
                                         int y)
```
    Would x + y overflow a register?
    
    Parameters:
    
    x - first summand
    
    y - second summand
    
    Returns:
    
    true if the addition would overflow, false otherwise
  - overflow_from_sub
```
private static boolean overflow_from_sub(int x,
                                         int y)
```
    Would x - y overflow a register?
    
    Parameters:
    
    x - minuend
    
    y - subtrahend
    
    Returns:
    
    true if the subtraction would overflow, false otherwise
  - overflow_from_mul
```
private static boolean overflow_from_mul(int x,
                                         int y)
```
    Would x * y overflow a register?
    
    Parameters:
    
    x - first factor
    
    y - second factor
    
    Returns:
    
    true if the multiplication would overflow, false otherwise
  - bit_test
```
private static boolean bit_test(int x,
                                int y)
```
    Is bit y of x set?
    
    Parameters:
    
    x - the number to check
    
    y - the bit position (0 is least significant bit)
    
    Returns:
    
    whether bit position y of x is set (LSB is 0)
  - isEQUAL
```
public boolean isEQUAL()
```
    Is the condition code EQUAL?
    
    Returns:
    
    true if it is or false if it is not
  - isNOT_EQUAL
```
public boolean isNOT_EQUAL()
```
    Is the condition code NOT_EQUAL?
    
    Returns:
    
    true if it is or false if it is not
  - isLESS_EQUAL
```
public boolean isLESS_EQUAL()
```
    Is the condition code LESS EQUAL?
    
    Returns:
    
    true if it is or false if it is not
  - isGREATER_EQUAL
```
public boolean isGREATER_EQUAL()
```
    Is the condition code GREATER_EQUAL?
    
    Returns:
    
    true if it is or false if it is not
  - isGREATER
```
public boolean isGREATER()
```
    Is the condition code GREATER?
    
    Returns:
    
    true if it is or false if it is not
  - isLESS
```
public boolean isLESS()
```
    Is the condition code LESS?
    
    Returns:
    
    true if it is or false if it is not
  - isHIGHER
```
public boolean isHIGHER()
```
    Is the condition code HIGHER?
    
    Returns:
    
    true if it is or false if it is not
  - isLOWER
```
public boolean isLOWER()
```
    Is the condition code LOWER?
    
    Returns:
    
    true if it is or false if it is not
  - isHIGHER_EQUAL
```
public boolean isHIGHER_EQUAL()
```
    Is the condition code HIGHER_EQUAL?
    
    Returns:
    
    true if it is or false if it is not
  - isLOWER_EQUAL
```
public boolean isLOWER_EQUAL()
```
    Is the condition code LOWER_EQUAL?
    
    Returns:
    
    true if it is or false if it is not
  - isUNSIGNED
```
public boolean isUNSIGNED()
```
    Is the condition code an unsigned comparison?
    
    Returns:
    
    true if it is or false if it is not
  - isFLAG_OPERATION
```
public boolean isFLAG_OPERATION()
```
    Is the condition code a flag operation?
    
    Returns:
    
    true if it is or false if it is not
  - isFLAG_OPERATION_FROM_ADD
```
public boolean isFLAG_OPERATION_FROM_ADD()
```
    Is the condition code a flag operation following an add?
    
    Returns:
    
    true if it is or false if it is not
  - isFLAG_OPERATION_FROM_SUB
```
public boolean isFLAG_OPERATION_FROM_SUB()
```
    Is the condition code a flag operation following a subtract?
    
    Returns:
    
    true if it is or false if it is not
  - isFLAG_OPERATION_FROM_RSUB
```
public boolean isFLAG_OPERATION_FROM_RSUB()
```
    Is the condition code a flag operation following a reversed subtract?
    
    Returns:
    
    true if it is or false if it is not
  - isBIT_TEST
```
public boolean isBIT_TEST()
```
    Is the condition code a flag operation following a bit test?
    
    Returns:
    
    true if it is or false if it is not
  - isRBIT_TEST
```
public boolean isRBIT_TEST()
```
    Is the condition code a flag operation following a reversed bit test?
    
    Returns:
    
    true if it is or false if it is not
  - isFLOATINGPOINT
```
public boolean isFLOATINGPOINT()
```
    Is the condition code a floating point compare?
    
    Returns:
    
    true if it is or false if it is not
  - branchIfUnordered
```
public boolean branchIfUnordered()
```
    Will this floating point compare branch if the results are unordered?
    
    Returns:
    
    true if it is or false if it is not
  - translateCMPL
```
public void translateCMPL()
```
    Convert this integer compare to a floating point cmpl compare. Used during BC2IR.
  - translateCMPG
```
public void translateCMPG()
```
    Convert this integer compare to a floating point cmpg compare. Used during BC2IR.
  - translateUNSIGNED
```
public ConditionOperand translateUNSIGNED()
```
    Convert this floating point compare to the equivalent unsigned integer compare. Used during IA-32 BURS.
    NB this doesn't respect ordered/unordered operation, so it should only be used when it's safe to.
    
    Returns:
    
    this
  - copy
```
public Operand copy()
```
    Description copied from class: Operand
    
    Return a new operand that is semantically equivalent to this.
    
    Specified by:
    
    copy in class Operand
    
    Returns:
    
    a copy of this
  - similar
```
public boolean similar(Operand op)
```
    Description copied from class: Operand
    
    Are two operands semantically equivalent?
    
    Specified by:
    
    similar in class Operand
    
    Parameters:
    
    op - other operand
    
    Returns:
    
    true if this and op are semantically equivalent or false if they are not.
  - evaluate
```
public int evaluate(Operand v1,
                    Operand v2)
```
    Given two operands, evaluate the condition on them.
    
    Parameters:
    
    v1 - first operand to condition
    
    v2 - second operand to condition
    
    Returns:
    
    TRUE if (v1 cond v2) or FALSE if !(v1 cond v2) or UNKNOWN
  - evaluate
```
public int evaluate(int v1,
                    int v2)
```
    Given two ints, evaluate the condition on them.
    
    Parameters:
    
    v1 - first operand to condition
    
    v2 - second operand to condition
    
    Returns:
    
    TRUE if (v1 cond v2) or FALSE if !(v1 cond v2) or UNKNOWN
  - evaluate
```
public int evaluate(long v1,
                    long v2)
```
    Given two longs, evaluate the condition on them.
    
    Parameters:
    
    v1 - first operand to condition
    
    v2 - second operand to condition
    
    Returns:
    
    TRUE if (v1 cond v2) or FALSE if !(v1 cond v2) or UNKNOWN
  - evaluate
```
public int evaluate(float v1,
                    float v2)
```
    Given two floats, evaluate the condition on them.
    
    Parameters:
    
    v1 - first operand to condition
    
    v2 - second operand to condition
    
    Returns:
    
    true if (v1 cond v2) or false otherwise
  - evaluate
```
public int evaluate(double v1,
                    double v2)
```
    Given two doubles, evaluate the condition on them.
    
    Parameters:
    
    v1 - first operand to condition
    
    v2 - second operand to condition
    
    Returns:
    
    true if (v1 cond v2) or false otherwise
  - evaluate
```
public int evaluate(Address v1,
                    Address v2)
```
    Given two Addresses, evaluate the condition on them.
    
    Parameters:
    
    v1 - first operand to condition
    
    v2 - second operand to condition
    
    Returns:
    
    TRUE if (v1 cond v2) or FALSE if !(v1 cond v2) or UNKNOWN
  - flipCode
```
public ConditionOperand flipCode()
```
    Flip the direction of the condition. Typical use is if you want to change the direction of a branch. i.e. to transform: if (condition) goto A goto B A: into: if (!condition) goto B A: Note that this is not the same as calling flipOperands().
    
    Returns:
    
    this
  - flipOperands
```
public ConditionOperand flipOperands()
```
    Change the condition code to allow the order of the operands to be flipped. i.e. So that: if x < y then goto A becomes: if y > x then goto A Note that this is not the same as calling flipCode().
    
    Returns:
    
    this
  - toString
```
public String toString()
```
    Returns the string representation of this operand. Postfix meanings:
    - U - unsigned comparison
    - F - floating point compare that doesn't branch when operands are unordered
    - FU - floating point compare that does branch when operands are unordered
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation of this operand.

Class ConditionOperand

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

EQUAL

NOT_EQUAL

LESS

GREATER_EQUAL

GREATER

LESS_EQUAL

HIGHER

LOWER

HIGHER_EQUAL

LOWER_EQUAL

CMPL_EQUAL

CMPL_GREATER

CMPG_LESS

CMPL_GREATER_EQUAL

CMPG_LESS_EQUAL

CMPL_NOT_EQUAL

CMPL_LESS

CMPG_GREATER_EQUAL

CMPG_GREATER

CMPL_LESS_EQUAL

CARRY_FROM_ADD

NO_CARRY_FROM_ADD

OVERFLOW_FROM_ADD

NO_OVERFLOW_FROM_ADD

BORROW_FROM_SUB

NO_BORROW_FROM_SUB

BORROW_FROM_RSUB

NO_BORROW_FROM_RSUB

OVERFLOW_FROM_SUB

NO_OVERFLOW_FROM_SUB

OVERFLOW_FROM_RSUB

NO_OVERFLOW_FROM_RSUB

BIT_TEST

NO_BIT_TEST

RBIT_TEST

NO_RBIT_TEST

OVERFLOW_FROM_MUL

NO_OVERFLOW_FROM_MUL

FALSE

TRUE

UNKNOWN

value

Constructor Detail

ConditionOperand

Method Detail

EQUAL

NOT_EQUAL

LESS

GREATER_EQUAL

GREATER

LESS_EQUAL

HIGHER

LOWER

HIGHER_EQUAL

LOWER_EQUAL

CMPL_EQUAL

CMPL_NOT_EQUAL

CMPL_GREATER

CMPL_GREATER_EQUAL

CMPG_LESS

CARRY_FROM_ADD

OVERFLOW_FROM_ADD

BORROW_FROM_SUB

OVERFLOW_FROM_SUB

BIT_TEST

OVERFLOW_FROM_MUL

higher

lower

higher_equal

lower_equal

carry_from_add

borrow_from_sub