BURS_Helpers (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.opt.ir.IRTools
- - org.jikesrvm.compilers.opt.ir.GenericPhysicalRegisterTools
  - - org.jikesrvm.compilers.opt.lir2mir.BURS_Common_Helpers
    - - org.jikesrvm.compilers.opt.lir2mir.BURS_MemOp_Helpers
      - org.jikesrvm.compilers.opt.lir2mir.ia32.BURS_Helpers

Direct Known Subclasses:

BURS_STATE, BURS_STATE
```
public abstract class BURS_Helpers
extends BURS_MemOp_Helpers
```
Contains IA32-specific helper functions for BURS.

Field Summary

Fields
Modifier and Type	Field and Description
`private ConditionOperand`	`cc` When emitting certain rules this holds the condition code state to be consumed by a parent rule
`private static Offset`	`doubleAbsMask` Mask to abs an XMM registers
`private static Offset`	`doubleSignMask` Mask to flip sign bits in XMM registers
`private static Offset`	`floatAbsMask` Mask to abs an XMM registers
`private static Offset`	`floatSignMask` Mask to flip sign bits in XMM registers
`private static double`	`L2E` Constant log2(e), supported as an x87 constant
`private static double`	`L2T` Constant log2(10), supported as an x87 constant
`private static double`	`LG2` Constant log10(2), supported as an x87 constant
`private static double`	`LN2` Constant ln(2), supported as an x87 constant

Fields inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_MemOp_Helpers
B, B_S, DW, DW_S, PARAGRAPH, QW, QW_S, W, W_S

Fields inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_Common_Helpers
burs, INFINITE, regpool

Constructor Summary

Constructors
Constructor and Description

BURS_Helpers(BURS burs)

Constructors
Constructor and Description
`BURS_Helpers(BURS burs)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private Operand`	`asReg(Instruction s, Operator movop, Operand op)` Emits code to move the operand into a register operand if it isn't one already.
`protected void`	`ATTEMPT_IFCMP(MemoryOperand mo, Operand oldValue, Operand newValue, ConditionOperand cond, BranchOperand target, BranchProfileOperand bp)` This routine expands the compound pattern IFCMP(ATTEMPT, ZERO) into an atomic compare/exchange followed by a branch on success/failure of the attempted atomic compare/exchange.
`protected void`	`ATTEMPT_LONG(RegisterOperand result, MemoryOperand mo, Operand oldValue, Operand newValue)` This routine expands an ATTEMPT instruction into an atomic compare exchange.
`protected void`	`ATTEMPT(RegisterOperand result, MemoryOperand mo, Operand oldValue, Operand newValue)` This routine expands an ATTEMPT instruction into an atomic compare exchange.
`protected static ConditionOperand`	`BIT_TEST(int x, ConditionOperand cond)` Convert the given comparison with a boolean (int) value into a condition suitable for the carry flag
`protected void`	`BOOLEAN_CMP_DOUBLE(Instruction s, RegisterOperand res, ConditionOperand cond, Operand val1, Operand val2)` Expansion of BOOLEAN_CMP_DOUBLE
`protected void`	`BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, ConditionOperand cond)` Expansion of a special case of BOOLEAN_CMP_INT when the condition registers have already been set by the previous ALU op.
`protected void`	`BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Expansion of BOOLEAN_CMP_INT
`protected void`	`BOOLEAN_CMP_LONG(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond)` Expansion of BOOLEAN_CMP_LONG
`protected void`	`CALL(Instruction s, Operand address)` Expansion of CALL.
`protected void`	`CMOV_FMOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate a floating point move portion of a conditional move.
`protected void`	`CMOV_MOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate an integer move portion of a conditional move.
`protected static boolean`	`CMP_TO_TEST(ConditionOperand op)` Can the given condition for a compare be converted to a test?
`protected IA32ConditionOperand`	`COND(ConditionOperand op)`
`protected ConditionOperand`	`consumeCOND()` Acquire remembered condition code in parent
`protected void`	`EMIT_Commutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` Create the MIR instruction given by operator from the Binary LIR operands
`protected void`	`EMIT_Compare(Instruction s, ConditionOperand cond, Operand val1, Operand val2)` Gives the MIR condition operator appropriate for the given condition
`protected void`	`EMIT_Lea(Instruction s, RegisterOperand result, MemoryOperand mo)` Create the MIR LEA instruction performing a few simplifications if possible
`protected void`	`EMIT_LongBinary(Operator operator1, Operator operator2, Instruction s, Operand result, Operand value1, Operand value2, boolean commutative)` Creates the MIR instruction given by the operators from the Binary LIR operands
`protected void`	`EMIT_LongUnary(Instruction s, Operand result, Operand value1, boolean negOrNot)` Creates the MIR instruction for LONG_NEG or LONG_NOT
`protected void`	`EMIT_NonCommutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` Create the MIR instruction given by operator from the Binary LIR operands
`protected void`	`EMIT_Unary(Operator operator, Instruction s, Operand result, Operand value)` Create the MIR instruction given by operator from the Binary LIR operands
`protected static Operand`	`follow(Operand use)` Follow a chain of Move operations filtering back to a def
`protected void`	`FP_MOV_OP_MOV(Instruction s, Operator op, Operand result, Operand val1, Operand val2)` Expansion of FP_ADD_ACC, FP_MUL_ACC, FP_SUB_ACC, and FP_DIV_ACC.
`protected void`	`FP_REM(Instruction s, Operand val1, Operand val2)` Expansion of FP_REM
`protected void`	`FPR_2INT(Instruction s, RegisterOperand result, Operand value)` Expansion of FLOAT_2INT and DOUBLE_2INT, using the FIST instruction.
`protected void`	`FPR2GPR_64(Instruction s)` Emits code to move 64 bits from FPRs to GPRs
`protected void`	`GET_EXCEPTION_OBJECT(Instruction s)` Emit code to get a caught exception object into a register
`protected void`	`GET_TIME_BASE(Instruction s, RegisterOperand result)` Expansion of RDTSC (called GET_TIME_BASE for consistency with PPC)
`protected Operator`	`get387_FPC(Instruction s)`
`private boolean`	`getCMP_needsSwap(ConditionOperand cond)`
`protected Register`	`getEAX()`
`protected Register`	`getEBP()`
`protected Register`	`getEBX()`
`protected Register`	`getECX()`
`protected Register`	`getEDI()`
`protected Register`	`getEDX()`
`protected Register`	`getESI()`
`protected Register`	`getESP()`
`protected Register`	`getFPR(int n)`
`protected Register`	`getST0()`
`protected void`	`GPR2FPR_64(Instruction s)` Emits code to move 64 bits from GPRs to FPRs.
`protected void`	`IFCMP(Instruction s, RegisterOperand guardResult, Operand val1, Operand val2, ConditionOperand cond)` Generate a compare and branch sequence.
`protected void`	`INT_2LONG(Instruction s, RegisterOperand result, Operand value, boolean signExtend)` Expansion of INT_2LONG
`protected void`	`INT_DIVIDES(Instruction s, RegisterOperand result, Operand val1, Operand val2, boolean isDiv, boolean signed)` Expansion of INT_DIV, SIGNED_DIV_64_32, UNSIGNED_DIV_64_32 and INT_REM
`protected void`	`INT_TO_LONG_MUL(Instruction s, RegisterOperand result, Operand value1, Operand value2, boolean signed)` Expansion of LONG_MULs whose operands are ints
`protected static boolean`	`IS_MATERIALIZE_ZERO(Instruction s)`
`protected static int`	`is387_FPC(Instruction s, int trueCost)` Is the given instruction's constant operand a x87 floating point constant
`protected void`	`LCMP_CMOV(Instruction s, RegisterOperand result, Operand val1, Operand val2, ConditionOperand cond, Operand trueValue, Operand falseValue)` Generate a long compare and cmov
`protected byte`	`LEA_SHIFT(Operand op)`
`protected static int`	`LEA_SHIFT(Operand op, int trueCost)` Can an IV be the scale in a LEA instruction?
`protected static int`	`LEA_SHIFT(Operand op, int trueCost, int falseCost)` Can an IV be the scale in a LEA instruction?
`(package private) static MemoryOperand`	`loadFromJTOC(Offset offset, byte size)` Create memory operand to load from a given jtoc offset
`protected void`	`LONG_CMP(Instruction s, RegisterOperand res, Operand val1, Operand val2)` Expansion of LONG_CMP: compare to values and set result to -1, 0, 1 for <, =, >, respectively
`protected void`	`LONG_DIVIDES(Instruction s, RegisterOperand result, Operand val1, Operand val2, boolean isDiv, boolean signed)` Expansion of LONG_DIV and LONG_REM
`protected void`	`LONG_MUL(Instruction s, RegisterOperand result, Operand value1, Operand value2)` Expansion of LONG_MUL
`protected void`	`LONG_SHL(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_SHL
`protected void`	`LONG_SHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_SHR
`protected void`	`LONG_USHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f)` Expansion of LONG_USHR
`protected void`	`LOWTABLESWITCH(Instruction s)` Expansion of LOWTABLESWITCH.
`protected Operand`	`MO_CONV(byte size)` Create a slot on the stack in memory for a conversion
`protected Operand`	`myFP0()`
`protected Operand`	`myFP1()`
`protected void`	`OSR(BURS burs, Instruction s)` special case handling OSR instructions expand long type variables to two integers
`protected void`	`PROLOGUE(Instruction s)` Expand a prologue by expanding out longs into pairs of ints
`protected void`	`pushCOND(ConditionOperand c)` Remember a condition code in a child node
`protected void`	`RESOLVE(Instruction s)` Expansion of RESOLVE.
`protected void`	`SET_EXCEPTION_OBJECT(Instruction s)` Emit code to move a value in a register to the stack location where a caught exception object is expected to be.
`protected MemoryOperand`	`setSize(MemoryOperand mo, int size)` Set the size field of the given memory operand and return it
`protected static boolean`	`SIMILAR_REGISTERS(Operand... ops)`
`protected void`	`SSE2_ABS(boolean single, Instruction s, Operand result, Operand value)`
`protected static Operator`	`SSE2_CMP_OP(ConditionOperand cond, boolean single)`
`protected void`	`SSE2_CONV(Operator op, Instruction s, Operand result, Operand value)` Expansion of SSE2 conversions double <-> float
`protected void`	`SSE2_COP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` BURS expansion of a commutative SSE2 operation.
`protected void`	`SSE2_FCMP_FCMOV(Instruction s, RegisterOperand result, Operand lhsCmp, Operand rhsCmp, ConditionOperand cond, Operand trueValue, Operand falseValue)`
`protected void`	`SSE2_FPCONSTANT(Instruction s)` Expansion of SSE2 floating point constant loads
`protected void`	`SSE2_FPR2GPR_32(Instruction s)` Emits code to move 32 bits from FPRs to GPRs.
`protected void`	`SSE2_FPR2GPR_64(Instruction s)` Emits code to move 64 bits from SSE2 FPRs to GPRs
`protected void`	`SSE2_GPR2FPR_32(Instruction s)` Emits code to move 32 bits from GPRs to FPRs.
`protected void`	`SSE2_GPR2FPR_64(Instruction s)` Emits code to move 64 bits from GPRs to SSE2 FPRs
`protected void`	`SSE2_IFCMP(Operator op, Instruction s, Operand val1, Operand val2)` Expansion of SSE2 comparison operations
`protected static boolean`	`SSE2_IS_GT_OR_GE(ConditionOperand cond)`
`protected static boolean`	`SSE2_IS_LT_OR_LE(ConditionOperand cond)`
`protected Operator`	`SSE2_MOVE(Operand o)` Returns the appropriate move operator based on the type of operand.
`protected void`	`SSE2_NCOP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2)` BURS expansion of a non commutative SSE2 operation.
`protected void`	`SSE2_NEG(boolean single, Instruction s, Operand result, Operand value)` Expansion of SSE2 negation ops.
`protected byte`	`SSE2_SIZE(Operand o)` Returns the size based on the type of operand.
`protected void`	`SSE2_X87_FROMLONG(Instruction s)` Performs a long -> double/float conversion using x87 and marshalls back to XMMs.
`protected void`	`SSE2_X87_REM(Instruction s)` Performs a long -> double/float conversion using x87 and marshalls between to XMMs.
`protected void`	`STORE_LONG_FOR_CONV(Operand op)` Creates a 64bit slot on the stack in memory for a conversion and stores the given long.
`protected void`	`SYSCALL(Instruction s, Operand address)` Expansion of SYSCALL.
`protected void`	`threeValueFPCmp(Instruction s)` Expansion for [DF]CMP[GL] compare to values and set result to -1, 0, 1 for <, =, > respectively
`protected void`	`TRAP_IF_IMM(Instruction s, boolean longConstant)` Expansion of TRAP_IF, with an int constant as the second value.

Methods inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_MemOp_Helpers
ADDRESS_EQUAL, ADDRESS_EQUAL, ARRAY_ADDRESS_EQUAL, ARRAY_ADDRESS_EQUAL, augmentAddress, combineAddresses, consumeAddress, consumeMO, MO_AL, MO_AL, MO_AS, MO_AS, MO_B, MO_BD, MO_BI, MO_BID, MO_BIS, MO_D, MO_L, MO_L, MO_MC, MO_S, MO_S, MO, MO, MO, pushAddress, pushMO

Methods inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_Common_Helpers
AC, AV, EMIT, EQ_GT_GE, EQ_LT_LE, EQ_NE, FITS, FITS, getIR, IC, isONE, isONE, isZERO, isZERO, IV, LC, LV, MINUSONE, ONE, P, PL, PLL, PLLL, PLLLL, PLLLLLL, PLLLLLLL, PLLLRL, PLLLRLL, PLLLRLLL, PLLR, PLLRL, PLLRLL, PLLRLLL, PLLRLLR, PLR, PLRL, PLRLL, PLRLLRL, PLRR, PR, PRL, PRLL, PRLLL, PRLLLL, PRLLR, PRLLRLLL, PRLR, PRLRL, PRR, PRRL, PRRR, R, V, VL, VLL, VLLL, VLLLL, VLLLLLLLR, VLLLLLLR, VLLLLLR, VLLLLR, VLLLR, VLLLRLLLR, VLLLRLLR, VLLLRLR, VLLLRR, VLLR, VLLRLLLR, VLLRLLR, VLLRLLRR, VLLRLR, VLLRR, VLR, VLRL, VLRLL, VLRLLRR, VLRLR, VLRR, VLRRR, VR, VRL, VRLL, VRLLLLR, VRLLLR, VRLLR, VRLLRLLLR, VRLLRLLR, VRLLRR, VRLR, VRLRLR, VRLRR, VRR, VRRL, VRRLR, VRRR, ZERO

Methods inherited from class org.jikesrvm.compilers.opt.ir.GenericPhysicalRegisterTools
A, I

Methods inherited from class org.jikesrvm.compilers.opt.ir.IRTools
A, AC, AC, CPOS, CR, D, DC, defDoublesAsUse, definedIn, F, FC, getCondMoveOp, getDefaultOperand, getLoadOp, getLoadOp, getMoveOp, getStoreOp, getStoreOp, I, IC, insertInstructionsAfter, L, LC, makeBlockOnEdge, mayBeVolatileFieldLoad, moveInstruction, moveIntoRegister, moveIntoRegister, nonPEIGC, offsetOperand, TG, usedIn, useDoublesAsDef

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

Field Detail
- LG2
```
private static final double LG2
```
  Constant log10(2), supported as an x87 constant
- LN2
```
private static final double LN2
```
  Constant ln(2), supported as an x87 constant
- L2E
```
private static final double L2E
```
  Constant log2(e), supported as an x87 constant
- L2T
```
private static final double L2T
```
  Constant log2(10), supported as an x87 constant
- floatSignMask
```
private static final Offset floatSignMask
```
  Mask to flip sign bits in XMM registers
- doubleSignMask
```
private static final Offset doubleSignMask
```
  Mask to flip sign bits in XMM registers
- floatAbsMask
```
private static final Offset floatAbsMask
```
  Mask to abs an XMM registers
- doubleAbsMask
```
private static final Offset doubleAbsMask
```
  Mask to abs an XMM registers
- cc
```
private ConditionOperand cc
```
  When emitting certain rules this holds the condition code state to be consumed by a parent rule

Constructor Detail
- BURS_Helpers
```
public BURS_Helpers(BURS burs)
```

Method Detail

EMIT_Commutative

protected void EMIT_Commutative(Operator operator,
                                Instruction s,
                                Operand result,
                                Operand val1,
                                Operand val2)

Create the MIR instruction given by operator from the Binary LIR operands

Parameters:: operator - the MIR operator; s - the instruction being replaced; result - the destination register/memory; val1 - the first operand; val2 - the second operand

EMIT_NonCommutative

protected void EMIT_NonCommutative(Operator operator,
                                   Instruction s,
                                   Operand result,
                                   Operand val1,
                                   Operand val2)

Create the MIR instruction given by operator from the Binary LIR operands

Parameters:: operator - the MIR operator; s - the instruction being replaced; result - the destination register/memory; val1 - the first operand; val2 - the second operand

EMIT_Unary

protected void EMIT_Unary(Operator operator,
                          Instruction s,
                          Operand result,
                          Operand value)

Create the MIR instruction given by operator from the Binary LIR operands

Parameters:: operator - the MIR operator; s - the instruction being replaced; result - the destination register/memory; value - the first operand

EMIT_Lea

protected void EMIT_Lea(Instruction s,
                        RegisterOperand result,
                        MemoryOperand mo)

Create the MIR LEA instruction performing a few simplifications if possible

Parameters:: s - the instruction being replaced; result - the destination register; mo - the memory operand

BIT_TEST
```
protected static ConditionOperand BIT_TEST(int x,
                                           ConditionOperand cond)
```
Convert the given comparison with a boolean (int) value into a condition suitable for the carry flag

Parameters:

x - the value 1 (true) or 0 (false)

cond - either equal or not equal

Returns:

lower or higher equal

follow
```
protected static Operand follow(Operand use)
```
Follow a chain of Move operations filtering back to a def

Parameters:

use - the place to start from

Returns:

the operand at the start of the chain

pushCOND
```
protected final void pushCOND(ConditionOperand c)
```
Remember a condition code in a child node

Parameters:

c - condition code to record

consumeCOND
```
protected final ConditionOperand consumeCOND()
```
Acquire remembered condition code in parent

Returns:

condition code

LEA_SHIFT
```
protected static int LEA_SHIFT(Operand op,
                               int trueCost)
```
Can an IV be the scale in a LEA instruction?

Parameters:

op - operand to examine

trueCost - the cost if this can be part of an LEA

Returns:

trueCost or INFINITE

LEA_SHIFT
```
protected static int LEA_SHIFT(Operand op,
                               int trueCost,
                               int falseCost)
```
Can an IV be the scale in a LEA instruction?

Parameters:

op - operand to examine

trueCost - the cost if this can be part of an LEA

falseCost - the cost if this can't be part of an LEA

Returns:

trueCost or falseCost

LEA_SHIFT

protected final byte LEA_SHIFT(Operand op)

is387_FPC
```
protected static int is387_FPC(Instruction s,
                               int trueCost)
```
Is the given instruction's constant operand a x87 floating point constant

Parameters:

s - the instruction to examine

trueCost - the cost if this is a valid constant

Returns:

trueCost or INFINITE depending on the given constant

get387_FPC

protected final Operator get387_FPC(Instruction s)

CMP_TO_TEST
```
protected static boolean CMP_TO_TEST(ConditionOperand op)
```
Can the given condition for a compare be converted to a test?

Parameters:

op - a condition

Returns:

true if and only if the condition for the compare can be reduced to a test

COND

protected final IA32ConditionOperand COND(ConditionOperand op)

getEAX
```
protected final Register getEAX()
```

getECX
```
protected final Register getECX()
```

getEDX
```
protected final Register getEDX()
```

getEBX
```
protected final Register getEBX()
```

getESP
```
protected final Register getESP()
```

getEBP
```
protected final Register getEBP()
```

getESI
```
protected final Register getESI()
```

getEDI
```
protected final Register getEDI()
```

getFPR

protected final Register getFPR(int n)

myFP0
```
protected final Operand myFP0()
```

myFP1
```
protected final Operand myFP1()
```

getST0
```
protected final Register getST0()
```

asReg
```
private Operand asReg(Instruction s,
                      Operator movop,
                      Operand op)
```
Emits code to move the operand into a register operand if it isn't one already.

Parameters:

movop - the Operator that needs to be used for the move

op - the operand to move

s - instruction to get source position information

Returns:

a new operand if a move was inserted, the old operand otherwise

setSize
```
protected final MemoryOperand setSize(MemoryOperand mo,
                                      int size)
```
Set the size field of the given memory operand and return it

Parameters:

mo - memory operand size to set

size - the new size

Returns:

mo

MO_CONV
```
protected final Operand MO_CONV(byte size)
```
Create a slot on the stack in memory for a conversion

Parameters:

size - for memory operand

Returns:

memory operand of slot in stack

STORE_LONG_FOR_CONV
```
protected final void STORE_LONG_FOR_CONV(Operand op)
```
Creates a 64bit slot on the stack in memory for a conversion and stores the given long.

Parameters:

op - an operand representing a long

loadFromJTOC
```
static MemoryOperand loadFromJTOC(Offset offset,
                                  byte size)
```
Create memory operand to load from a given jtoc offset

Parameters:

offset - location in JTOC

size - of value in JTOC

Returns:

created memory operand

GET_EXCEPTION_OBJECT
```
protected final void GET_EXCEPTION_OBJECT(Instruction s)
```
Emit code to get a caught exception object into a register

Parameters:

s - the instruction to expand

SET_EXCEPTION_OBJECT
```
protected final void SET_EXCEPTION_OBJECT(Instruction s)
```
Emit code to move a value in a register to the stack location where a caught exception object is expected to be.

Parameters:

s - the instruction to expand

INT_2LONG

protected final void INT_2LONG(Instruction s,
                               RegisterOperand result,
                               Operand value,
                               boolean signExtend)

Expansion of INT_2LONG

Parameters:: s - the instruction to expand; result - the result operand; value - the second operand; signExtend - should the value be sign or zero extended?

FPR_2INT
```
protected final void FPR_2INT(Instruction s,
                              RegisterOperand result,
                              Operand value)
```
Expansion of FLOAT_2INT and DOUBLE_2INT, using the FIST instruction. This expansion does some boolean logic and conditional moves in order to avoid changing the floating-point rounding mode or inserting branches. Other expansions are possible, and may be better?

Parameters:

s - the instruction to expand

result - the result operand

value - the second operand

FPR2GPR_64
```
protected final void FPR2GPR_64(Instruction s)
```
Emits code to move 64 bits from FPRs to GPRs

Parameters:

s - instruction to modify for the move

GPR2FPR_64
```
protected final void GPR2FPR_64(Instruction s)
```
Emits code to move 64 bits from GPRs to FPRs.

Parameters:

s - instruction to modify for the move

SSE2_MOVE
```
protected final Operator SSE2_MOVE(Operand o)
```
Returns the appropriate move operator based on the type of operand.

Parameters:

o - an operand

Returns:

correct move operator

SSE2_SIZE
```
protected final byte SSE2_SIZE(Operand o)
```
Returns the size based on the type of operand.

Parameters:

o - an operand

Returns:

size in bytes

SSE2_X87_FROMLONG
```
protected final void SSE2_X87_FROMLONG(Instruction s)
```
Performs a long -> double/float conversion using x87 and marshalls back to XMMs.

Parameters:

s - instruction to modify for the conversion

SSE2_X87_REM
```
protected final void SSE2_X87_REM(Instruction s)
```
Performs a long -> double/float conversion using x87 and marshalls between to XMMs.

Parameters:

s - instruction to modify for the conversion

SSE2_FPR2GPR_64
```
protected final void SSE2_FPR2GPR_64(Instruction s)
```
Emits code to move 64 bits from SSE2 FPRs to GPRs

Parameters:

s - instruction to modify for the move

SSE2_GPR2FPR_64
```
protected final void SSE2_GPR2FPR_64(Instruction s)
```
Emits code to move 64 bits from GPRs to SSE2 FPRs

Parameters:

s - instruction to modify for the move

SSE2_FPR2GPR_32
```
protected final void SSE2_FPR2GPR_32(Instruction s)
```
Emits code to move 32 bits from FPRs to GPRs.

Parameters:

s - instruction to modify for the move

SSE2_GPR2FPR_32
```
protected final void SSE2_GPR2FPR_32(Instruction s)
```
Emits code to move 32 bits from GPRs to FPRs.

Parameters:

s - instruction to modify for the move

SSE2_COP

protected void SSE2_COP(Operator operator,
                        Instruction s,
                        Operand result,
                        Operand val1,
                        Operand val2)

BURS expansion of a commutative SSE2 operation.

Parameters:: operator - the operator; s - the instruction in question; result - the instruction's result operand; val1 - the instruction's first value operand; val2 - the instruction's second value operand

SSE2_NCOP

protected void SSE2_NCOP(Operator operator,
                         Instruction s,
                         Operand result,
                         Operand val1,
                         Operand val2)

BURS expansion of a non commutative SSE2 operation.

Parameters:: operator - the operator; s - the instruction in question; result - the instruction's result operand; val1 - the instruction's first value operand; val2 - the instruction's second value operand

SSE2_NEG

protected final void SSE2_NEG(boolean single,
                              Instruction s,
                              Operand result,
                              Operand value)

Expansion of SSE2 negation ops.

Parameters:: single - true if 32 bit value (float), false for 64 bit (double); s - the instruction in question; result - the instruction's result operand; value - the instruction's value operand

SSE2_CONV

protected final void SSE2_CONV(Operator op,
                               Instruction s,
                               Operand result,
                               Operand value)

Expansion of SSE2 conversions double <-> float

Parameters:: op - the operator; s - the instruction in question; result - the instruction's result operand; value - the instruction's value operand

SSE2_IFCMP

protected final void SSE2_IFCMP(Operator op,
                                Instruction s,
                                Operand val1,
                                Operand val2)

Expansion of SSE2 comparison operations

Parameters:: op - the operator; s - the instruction in question; val1 - the instruction's first value operand; val2 - the instruction's second value operand

SSE2_CMP_OP

protected static Operator SSE2_CMP_OP(ConditionOperand cond,
                                      boolean single)

SSE2_FCMP_FCMOV

protected final void SSE2_FCMP_FCMOV(Instruction s,
                                     RegisterOperand result,
                                     Operand lhsCmp,
                                     Operand rhsCmp,
                                     ConditionOperand cond,
                                     Operand trueValue,
                                     Operand falseValue)

IS_MATERIALIZE_ZERO

protected static boolean IS_MATERIALIZE_ZERO(Instruction s)

SIMILAR_REGISTERS

protected static boolean SIMILAR_REGISTERS(Operand... ops)

SSE2_IS_GT_OR_GE

protected static boolean SSE2_IS_GT_OR_GE(ConditionOperand cond)

SSE2_IS_LT_OR_LE

protected static boolean SSE2_IS_LT_OR_LE(ConditionOperand cond)

SSE2_ABS

protected final void SSE2_ABS(boolean single,
                              Instruction s,
                              Operand result,
                              Operand value)

SSE2_FPCONSTANT
```
protected final void SSE2_FPCONSTANT(Instruction s)
```
Expansion of SSE2 floating point constant loads

Parameters:

s - the instruction to mutate

INT_DIVIDES

protected final void INT_DIVIDES(Instruction s,
                                 RegisterOperand result,
                                 Operand val1,
                                 Operand val2,
                                 boolean isDiv,
                                 boolean signed)

Expansion of INT_DIV, SIGNED_DIV_64_32, UNSIGNED_DIV_64_32 and INT_REM

Parameters:: s - the instruction to expand; result - the result operand; val1 - the first operand; val2 - the second operand; isDiv - true for division, false for reminder; signed - true for signed, false for unsigned

EMIT_LongBinary

protected final void EMIT_LongBinary(Operator operator1,
                                     Operator operator2,
                                     Instruction s,
                                     Operand result,
                                     Operand value1,
                                     Operand value2,
                                     boolean commutative)

Creates the MIR instruction given by the operators from the Binary LIR operands

Parameters:: operator1 - the 1st MIR operator; operator2 - the 2nd MIR operator; s - the instruction being replaced; result - the destination register/memory; value1 - the first operand; value2 - the second operand; commutative - is the operation commutative?

LONG_MUL

protected final void LONG_MUL(Instruction s,
                              RegisterOperand result,
                              Operand value1,
                              Operand value2)

Expansion of LONG_MUL

Parameters:: s - the instruction to expand; result - the result operand; value1 - the first operand; value2 - the second operand

INT_TO_LONG_MUL

protected final void INT_TO_LONG_MUL(Instruction s,
                                     RegisterOperand result,
                                     Operand value1,
                                     Operand value2,
                                     boolean signed)

Expansion of LONG_MULs whose operands are ints

Parameters:: s - the instruction to expand; result - the result operand; value1 - the first operand; value2 - the second operand; signed - signed or unsigned multiplication?

LONG_DIVIDES

protected final void LONG_DIVIDES(Instruction s,
                                  RegisterOperand result,
                                  Operand val1,
                                  Operand val2,
                                  boolean isDiv,
                                  boolean signed)

Expansion of LONG_DIV and LONG_REM

Parameters:: s - the instruction to expand; result - the result operand; val1 - the first operand; val2 - the second operand; isDiv - true for div, false for rem; signed - true for signed division, false for unsigned

EMIT_LongUnary

protected final void EMIT_LongUnary(Instruction s,
                                    Operand result,
                                    Operand value1,
                                    boolean negOrNot)

Creates the MIR instruction for LONG_NEG or LONG_NOT

Parameters:: s - the instruction being replaced; result - the destination register/memory; value1 - the operand; negOrNot - true for neg

LONG_SHL

protected final void LONG_SHL(Instruction s,
                              Operand result,
                              Operand val1,
                              Operand val2,
                              boolean maskWith3f)

Expansion of LONG_SHL

Parameters:: s - the instruction to expand; result - the result operand; val1 - the shifted operand; val2 - the shift amount operand; maskWith3f - should the shift operand by masked with 0x3f? This is default behaviour on Intel but it differs from how we combine shift operands in HIR

LONG_SHR

protected final void LONG_SHR(Instruction s,
                              Operand result,
                              Operand val1,
                              Operand val2,
                              boolean maskWith3f)

Expansion of LONG_SHR

Parameters:: s - the instruction to expand; result - the result operand; val1 - the shifted operand; val2 - the shift amount operand; maskWith3f - should the shift operand by masked with 0x3f? This is default behaviour on Intel but it differs from how we combine shift operands in HIR

LONG_USHR

protected final void LONG_USHR(Instruction s,
                               Operand result,
                               Operand val1,
                               Operand val2,
                               boolean maskWith3f)

Expansion of LONG_USHR

Parameters:: s - the instruction to expand; result - the result operand; val1 - the shifted operand; val2 - the shift amount operand; maskWith3f - should the shift operand by masked with 0x3f? This is default behaviour on Intel but it differs from how we combine shift operands in HIR

GET_TIME_BASE

protected final void GET_TIME_BASE(Instruction s,
                                   RegisterOperand result)

Expansion of RDTSC (called GET_TIME_BASE for consistency with PPC)

Parameters:: s - the instruction to expand; result - the result/first operand

LONG_CMP

protected final void LONG_CMP(Instruction s,
                              RegisterOperand res,
                              Operand val1,
                              Operand val2)

Expansion of LONG_CMP: compare to values and set result to -1, 0, 1 for <, =, >, respectively

Parameters:: s - the compare instruction; res - the result/first operand; val1 - the first value; val2 - the second value

FP_MOV_OP_MOV

protected final void FP_MOV_OP_MOV(Instruction s,
                                   Operator op,
                                   Operand result,
                                   Operand val1,
                                   Operand val2)

Expansion of FP_ADD_ACC, FP_MUL_ACC, FP_SUB_ACC, and FP_DIV_ACC. Moves first value into fp0, accumulates second value into fp0 using op, moves fp0 into result.

Parameters:: s - the instruction to expand; op - the floating point op to use; result - the result operand; val1 - the first operand; val2 - the second operand

FP_REM

protected final void FP_REM(Instruction s,
                            Operand val1,
                            Operand val2)

Expansion of FP_REM

Parameters:: s - the instruction to expand; val1 - the first operand; val2 - the second operand

threeValueFPCmp
```
protected final void threeValueFPCmp(Instruction s)
```
Expansion for [DF]CMP[GL] compare to values and set result to -1, 0, 1 for <, =, > respectively

Parameters:

s - the compare instruction

getCMP_needsSwap
```
private boolean getCMP_needsSwap(ConditionOperand cond)
```
Parameters:

cond - a condition operand

Returns:

whether the given condition operand need its operands flipping as its non-commutative

EMIT_Compare

protected void EMIT_Compare(Instruction s,
                            ConditionOperand cond,
                            Operand val1,
                            Operand val2)

Gives the MIR condition operator appropriate for the given condition

Parameters:: s - the comparison instruction; cond - the condition; val1 - first operand for the compare; val2 - second operand for the compare

BOOLEAN_CMP_INT

protected final void BOOLEAN_CMP_INT(Instruction s,
                                     RegisterOperand res,
                                     Operand val1,
                                     Operand val2,
                                     ConditionOperand cond)

Expansion of BOOLEAN_CMP_INT

Parameters:: s - the instruction to copy position info from; res - the result operand; val1 - the first value; val2 - the second value; cond - the condition operand

BOOLEAN_CMP_INT

protected final void BOOLEAN_CMP_INT(Instruction s,
                                     RegisterOperand res,
                                     ConditionOperand cond)

Expansion of a special case of BOOLEAN_CMP_INT when the condition registers have already been set by the previous ALU op.

Parameters:: s - the instruction to copy position info from; res - the result operand; cond - the condition operand

BOOLEAN_CMP_DOUBLE

protected final void BOOLEAN_CMP_DOUBLE(Instruction s,
                                        RegisterOperand res,
                                        ConditionOperand cond,
                                        Operand val1,
                                        Operand val2)

Expansion of BOOLEAN_CMP_DOUBLE

Parameters:: s - the instruction to copy position info from; res - the result operand; val1 - the first value; val2 - the second value; cond - the condition operand

BOOLEAN_CMP_LONG

protected final void BOOLEAN_CMP_LONG(Instruction s,
                                      RegisterOperand res,
                                      Operand val1,
                                      Operand val2,
                                      ConditionOperand cond)

Expansion of BOOLEAN_CMP_LONG

Parameters:: s - the instruction to copy position info from; res - the result operand; val1 - the first value; val2 - the second value; cond - the condition operand

LCMP_CMOV

protected final void LCMP_CMOV(Instruction s,
                               RegisterOperand result,
                               Operand val1,
                               Operand val2,
                               ConditionOperand cond,
                               Operand trueValue,
                               Operand falseValue)

Generate a long compare and cmov

Parameters:: s - the instruction to copy position info from; result - the result of the conditional move; val1 - the first value; val2 - the second value; cond - the condition operand; trueValue - the value to move to result if cond is true; falseValue - the value to move to result if cond is not true

IFCMP

protected final void IFCMP(Instruction s,
                           RegisterOperand guardResult,
                           Operand val1,
                           Operand val2,
                           ConditionOperand cond)

Generate a compare and branch sequence. Used in the expansion of trees where INT_IFCMP is a root

Parameters:: s - the ifcmp instruction; guardResult - the guard result of the ifcmp; val1 - the first value operand; val2 - the second value operand; cond - the condition operand

CMOV_MOV

protected final void CMOV_MOV(Instruction s,
                              RegisterOperand result,
                              ConditionOperand cond,
                              Operand trueValue,
                              Operand falseValue)

Generate an integer move portion of a conditional move.

Parameters:: s - the instruction to copy position info from; result - the result of the conditional move; cond - the condition operand; trueValue - the value to move to result if cond is true; falseValue - the value to move to result if cond is not true

CMOV_FMOV

protected final void CMOV_FMOV(Instruction s,
                               RegisterOperand result,
                               ConditionOperand cond,
                               Operand trueValue,
                               Operand falseValue)

Generate a floating point move portion of a conditional move.

Parameters:: s - the instruction to copy position info from; result - the result of the conditional move; cond - the condition operand; trueValue - the value to move to result if cond is true; falseValue - the value to move to result if cond is not true

PROLOGUE
```
protected final void PROLOGUE(Instruction s)
```
Expand a prologue by expanding out longs into pairs of ints

Parameters:

s - the prologue instruction

CALL
```
protected final void CALL(Instruction s,
                          Operand address)
```
Expansion of CALL. Expand longs registers into pairs of int registers.

Parameters:

s - the instruction to expand

address - the operand containing the target address

SYSCALL
```
protected final void SYSCALL(Instruction s,
                             Operand address)
```
Expansion of SYSCALL. Expand longs registers into pairs of int registers.

Parameters:

s - the instruction to expand

address - the operand containing the target address

LOWTABLESWITCH
```
protected final void LOWTABLESWITCH(Instruction s)
```
Expansion of LOWTABLESWITCH.

Parameters:

s - the instruction to expand

RESOLVE
```
protected final void RESOLVE(Instruction s)
```
Expansion of RESOLVE. Dynamic link point. Build up MIR instructions for Resolve.

Parameters:

s - the instruction to expand

TRAP_IF_IMM
```
protected final void TRAP_IF_IMM(Instruction s,
                                 boolean longConstant)
```
Expansion of TRAP_IF, with an int constant as the second value.

Parameters:

s - the instruction to expand

longConstant - is the argument a long constant?

ATTEMPT
```
protected final void ATTEMPT(RegisterOperand result,
                             MemoryOperand mo,
                             Operand oldValue,
                             Operand newValue)
```
This routine expands an ATTEMPT instruction into an atomic compare exchange. The atomic compare and exchange will place at mo the value of newValue if the value of mo is oldValue. The result register is set to 0/1 depending on whether the valye was replaced or not.

Parameters:

result - the register operand that is set to 0/1 as a result of the attempt

mo - the address at which to attempt the exchange

oldValue - the old value at the address mo

newValue - the new value at the address mo

ATTEMPT_LONG
```
protected final void ATTEMPT_LONG(RegisterOperand result,
                                  MemoryOperand mo,
                                  Operand oldValue,
                                  Operand newValue)
```
This routine expands an ATTEMPT instruction into an atomic compare exchange. The atomic compare and exchange will place at mo the value of newValue if the value of mo is oldValue. The result register is set to 0/1 depending on whether the valye was replaced or not.

Parameters:

result - the register operand that is set to 0/1 as a result of the attempt

mo - the address at which to attempt the exchange

oldValue - the old value to check for at the address mo

newValue - the new value to place at the address mo

ATTEMPT_IFCMP

protected final void ATTEMPT_IFCMP(MemoryOperand mo,
                                   Operand oldValue,
                                   Operand newValue,
                                   ConditionOperand cond,
                                   BranchOperand target,
                                   BranchProfileOperand bp)

This routine expands the compound pattern IFCMP(ATTEMPT, ZERO) into an atomic compare/exchange followed by a branch on success/failure of the attempted atomic compare/exchange.

Parameters:: mo - the address at which to attempt the exchange; oldValue - the old value at the address mo; newValue - the new value at the address mo; cond - the condition to branch on; target - the branch target; bp - the branch profile information

OSR
```
protected void OSR(BURS burs,
                   Instruction s)
```
special case handling OSR instructions expand long type variables to two integers

Parameters:

burs - the burs instance

s - an OSRPoint instruction

Class BURS_Helpers

Field Summary

Fields inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_MemOp_Helpers

Fields inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_Common_Helpers

Constructor Summary

Method Summary

Methods inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_MemOp_Helpers

Methods inherited from class org.jikesrvm.compilers.opt.lir2mir.BURS_Common_Helpers

Methods inherited from class org.jikesrvm.compilers.opt.ir.GenericPhysicalRegisterTools

Methods inherited from class org.jikesrvm.compilers.opt.ir.IRTools

Methods inherited from class java.lang.Object

Field Detail

LG2

LN2

L2E

L2T

floatSignMask

doubleSignMask

floatAbsMask

doubleAbsMask

cc

Constructor Detail

BURS_Helpers

Method Detail

EMIT_Commutative

EMIT_NonCommutative

EMIT_Unary

EMIT_Lea

BIT_TEST

follow

pushCOND

consumeCOND

LEA_SHIFT

LEA_SHIFT

LEA_SHIFT

is387_FPC

get387_FPC

CMP_TO_TEST

COND

getEAX

getECX

getEDX

getEBX

getESP

getEBP

getESI

getEDI

getFPR

myFP0

myFP1

getST0

asReg

setSize

MO_CONV

STORE_LONG_FOR_CONV

loadFromJTOC

GET_EXCEPTION_OBJECT

SET_EXCEPTION_OBJECT

INT_2LONG

FPR_2INT

FPR2GPR_64

GPR2FPR_64

SSE2_MOVE

SSE2_SIZE

SSE2_X87_FROMLONG

SSE2_X87_REM

SSE2_FPR2GPR_64

SSE2_GPR2FPR_64

SSE2_FPR2GPR_32

SSE2_GPR2FPR_32

SSE2_COP

SSE2_NCOP

SSE2_NEG

SSE2_CONV

SSE2_IFCMP

SSE2_CMP_OP

SSE2_FCMP_FCMOV

IS_MATERIALIZE_ZERO

SIMILAR_REGISTERS

SSE2_IS_GT_OR_GE