BC2IR (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.opt.bc2ir.BC2IR

```
public final class BC2IR
extends Object
```
This class translates from bytecode to HIR.
The only public entry point is BC2IR.generateHIR. generateHIR is passed an argument GenerationContext. The context is assumed to be "empty" but "initialized." Invoking generateHIR on a context results in it being "filled in" with the HIR for the method (and for any inlined methods) as specified by the state of the context.
The basic idea is to abstractly interpret the bytecode stream, translating it into a register-based IR along the way. At each program point BC2IR has an abstract stack and an abstract local variable array. Based on this, and on the bytecode, it can generate instructions. It also does a number of forward flow-sensitive dataflow analyses and optimistic optimizations in the process. There's lots of details in John Whaley's master thesis from MIT. However, one needs to be careful because this code has substantial diverged from the system described in his thesis. Some optimizations/features described in Johns's thesis are not implemented here. Some optimizations/features implemented here are not described in John's thesis. In particular this code takes a different approach to JSRs (inlining them), and has more advanced and effective implementation of the inlining transformation.

See Also:

IRGenOptions, GenerationContext, ConvertBCtoHIR

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class BC2IR.DummyStackSlot
Dummy stack slot

Nested Classes
Modifier and Type	Class and Description
`private static class`	`BC2IR.DummyStackSlot` Dummy stack slot

Field Summary

Fields
Modifier and Type	Field and Description
`private Operand[]`	`_localState` Current state of local variables.
`private int`	`bciAdjustment` OSR field: TODO rework this mechanism!
`private BytecodeStream`	`bcodes` Bytecodes for the method being generated.
`private BBSet`	`blocks` The set of BasicBlockLEs we are generating
`private BasicBlockLE`	`currentBBLE` Current BBLE.
`private Operand`	`currentGuard`
`(package private) static boolean`	`DBG_SELECTED`
`private static boolean`	`DBG_SELECTIVE` Debugging with method_to_print.
`static BC2IR.DummyStackSlot`	`DUMMY` Dummy slot.
`private boolean`	`endOfBasicBlock` Does basic block end here?
`private boolean`	`fallThrough` Do we fall through to the next basic block?
`private GenerationContext`	`gc` The generation context.
`private boolean`	`inlinedSomething` Was something inlined?
`private int`	`instrIndex` Bytecode index of current instruction.
`private Instruction`	`lastInstr` Last instruction generated (for ELIM_COPY_LOCALS)
`private Instruction`	`lastOsrBarrier` osr barrier needs type information of locals and stacks, it has to be created before a _callHelper.
`private boolean`	`osrGuardedInline`
`private int`	`param1` OSR: used for PSEUDO_InvokeStatic to recover the type info
`private int`	`param2` OSR: used for PSEUDO_InvokeStatic to recover the type info
`private int`	`runoff` Index of next basic block.
`private OperandStack`	`stack` Current simulated stack state.

Constructor Summary

Constructors
Modifier Constructor and Description

private BC2IR(GenerationContext context)
Construct the BC2IR object for the generation context.

Constructors
Modifier	Constructor and Description
`private`	`BC2IR(GenerationContext context)` Construct the BC2IR object for the generation context.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Instruction`	`_aloadHelper(Operator operator, Operand ref, Operand index, TypeReference type)`
`private Instruction`	`_binaryDualHelper(Operator operator, Operand op1, Operand op2, TypeReference type)`
`Instruction`	`_binaryHelper(Operator operator, Operand op1, Operand op2, TypeReference type)`
`private Instruction`	`_callHelper(MethodReference meth, MethodOperand methOp)` Pop method parameters off the expression stack.
`private Instruction`	`_createOsrBarrier()`
`private Instruction`	`_gotoHelper(int offset)`
`private Instruction`	`_guardedBinaryDualHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)`
`private Instruction`	`_guardedBinaryHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)`
`private Instruction`	`_intIfCmpHelper(ConditionOperand cond)`
`private Instruction`	`_intIfHelper(ConditionOperand cond)`
`private Instruction`	`_jsrHelper(int offset)`
`private Operand`	`_loadLocalForOSR(Operand op)` make a temporary register, and create a move instruction
`private Instruction`	`_moveDualHelper(Operator operator, Operand val, TypeReference type)`
`(package private) Instruction`	`_moveHelper(Operator operator, Operand val, TypeReference type)`
`static Instruction`	`_osrHelper(Instruction barrier, GenerationContext gc)` Creates an OSR point instruction with its dependent OsrBarrier which provides type and variable information.
`private Operand`	`_prepareDoubleConstant(Operand op)` special process for long/double constants
`private Operand`	`_prepareLongConstant(Operand op)` special process for long/double constants
`private Instruction`	`_refIfCmpHelper(ConditionOperand cond)`
`private Instruction`	`_refIfNullHelper(ConditionOperand cond)`
`private Instruction`	`_retHelper(int var)`
`private void`	`_returnHelper(Operator operator, Operand val)`
`(package private) Instruction`	`_unaryDualHelper(Operator operator, Operand val, TypeReference type)`
`(package private) Instruction`	`_unaryHelper(Operator operator, Operand val, TypeReference type)`
`void`	`appendInstruction(Instruction s)` Append an instruction to the current basic block.
`private void`	`assertIsAssignable(TypeReference parentType, TypeReference childType)` Assert that the given child type is a subclass of the given parent type.
`void`	`assertIsType(Operand op, TypeReference type)` Assert that the given operand is of the given type, or of a subclass of the given type.
`void`	`clearCurrentGuard()`
`static Operand`	`copyGuardFromOperand(Operand op)`
`private boolean`	`couldCauseClassLoading(TypeReference typeRef)`
`private void`	`db(String val)` Print a debug string to the sysWrite stream
`private Instruction`	`do_aload(int index)` Simulates a load from a given local variable of a reference.
`private Instruction`	`do_astore(int index)` Simulates a store into a given local variable of an object ref.
`boolean`	`do_BoundsCheck(Operand ref, Operand index)` Generates a boundscheck instruction for the given operand and index.
`private boolean`	`do_CheckStore(Operand ref, Operand elem, TypeReference elemType)` Generate a storecheck for the given array and elem
`private Instruction`	`do_dload(int index)` Simulates a load from a given local variable of a double.
`private Instruction`	`do_fload(int index)` Simulates a load from a given local variable of a float.
`private Instruction`	`do_iinc(int index, int amount)` Simulates the incrementing of a given int local variable.
`private Instruction`	`do_iload(int index)` Simulates a load from a given local variable of an int.
`private boolean`	`do_IntZeroCheck(Operand div)` Generates a check for 0 for the given operand
`private Instruction`	`do_lload(int index)` Simulates a load from a given local variable of a long.
`private boolean`	`do_LongZeroCheck(Operand div)` Generates a checks for 0 for the given operand
`boolean`	`do_NullCheck(Operand ref)` Generates a null-check instruction for the given operand.
`private Instruction`	`do_store(int index, Operand op1)` Simulates a store into a given local variable of an int/long/double/float
`private void`	`finish(GenerationContext context)`
`Instruction`	`generateAnewarray(TypeReference arrayTypeRef, TypeReference elementTypeRef)`
`private void`	`generateFrom(int fromIndex)` Generate instructions for a basic block.
`private void`	`generateHIR()` Main generation loop.
`static void`	`generateHIR(GenerationContext context)` Generate HIR as specified by the argument GenerationContext.
`private BranchOperand`	`generateTarget(int offset)`
`TypeReference`	`getArrayTypeOf(Operand op)` Returns the data type of the given operand, assuming that the operand is an array reference.
`Operand`	`getConstantOperand(int index)` Fetch the value of the next operand, a constant, from the bytecode stream.
`Operand`	`getCurrentGuard()`
`private Operand`	`getLocal(int i)` Gets the specified local variable.
`private Operand`	`getLocalDual(int i)` Gets the specified local variable (long, double).
`private BasicBlockLE`	`getOrCreateBlock(int target)` Gets or creates a block at the specified target.
`private BasicBlockLE`	`getOrCreateBlock(int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals)` Get or create a block at the specified target.
`private TypeReference`	`getRefTypeOf(Operand op)` Returns the data type of the given operand, assuming that the operand is a reference.
`static boolean`	`hasGuard(RegisterOperand rop)`
`static boolean`	`hasLessConservativeGuard(RegisterOperand rop1, RegisterOperand rop2)`
`static boolean`	`isNonNull(Operand op)`
`private LocationOperand`	`makeInstanceFieldRef(FieldReference f)`
`private LocationOperand`	`makeStaticFieldRef(FieldReference f)` Make a field reference operand referring to the given field with the given type.
`private TypeOperand`	`makeTypeOperand(RVMType type)` Make a type operand that refers to the given type.
`private TypeOperand`	`makeTypeOperand(TypeReference type)` Make a type operand that refers to the given type.
`void`	`markGuardlessNonNull(RegisterOperand rop)`
`private boolean`	`maybeInlineMethod(InlineDecision inlDec, Instruction callSite)` Attempt to inline a method.
`(package private) Operand`	`pop()` Pops an operand from the stack.
`(package private) Operand`	`pop(TypeReference type)` Pops an operand of the given type from the stack.
`Operand`	`popAddress()` Pops an address operand from the stack.
`(package private) Operand`	`popDouble()` Pops a double operand from the stack.
`(package private) void`	`popDummy()` Pops a dummy operand from the stack.
`(package private) Operand`	`popFloat()` Pops a float operand from the stack.
`Operand`	`popInt()` Pops an int operand from the stack.
`(package private) Operand`	`popLong()` Pops a long operand from the stack.
`Operand`	`popRef()` Pops a ref operand from the stack.
`private Operand`	`popShiftInt(boolean longShift)` Pop an int from the stack to be used in a shift.
`private String`	`printBlocks()`
`void`	`push(Operand r)` Push a single width operand (int, float, ref, ...) on the simulated stack.
`(package private) void`	`push(Operand r, TypeReference type)` Push an operand of the specified type on the simulated stack.
`private Instruction`	`pushCopy(Operand op1)` Pushes a copy of the given operand onto simulated stack.
`(package private) void`	`pushDual(Operand r)` Push a double width operand (long, double) on the simulated stack.
`private BasicBlock`	`rectifyStateWithArithmeticExceptionHandler()`
`private BasicBlock`	`rectifyStateWithArithmeticExceptionHandler(boolean linkToExitIfUncaught)`
`private BasicBlock`	`rectifyStateWithArrayBoundsExceptionHandler()`
`private BasicBlock`	`rectifyStateWithArrayBoundsExceptionHandler(boolean linkToExitIfUncaught)`
`private BasicBlock`	`rectifyStateWithArrayStoreExceptionHandler()`
`private BasicBlock`	`rectifyStateWithArrayStoreExceptionHandler(boolean linkToExitIfUncaught)`
`private BasicBlock`	`rectifyStateWithErrorHandler()`
`private BasicBlock`	`rectifyStateWithErrorHandler(boolean linkToExitIfUncaught)`
`BasicBlock`	`rectifyStateWithExceptionHandler(TypeReference exceptionType)`
`private BasicBlock`	`rectifyStateWithExceptionHandler(TypeReference exceptionType, boolean linkToExitIfUncaught)`
`void`	`rectifyStateWithExceptionHandlers()`
`private void`	`rectifyStateWithExceptionHandlers(boolean linkToExitIfUncaught)`
`private BasicBlock`	`rectifyStateWithNullPtrExceptionHandler()`
`private BasicBlock`	`rectifyStateWithNullPtrExceptionHandler(boolean linkToExitIfUncaught)`
`private void`	`replaceLocalsOnStack(int index, TypeReference type)` Replaces copies of local `<#index,type>` with newly-generated temporaries, and generates the necessary move instructions.
`private void`	`setCurrentGuard(Operand guard)`
`static void`	`setGuardForRegOp(RegisterOperand rop, Operand guard)`
`private void`	`setLocal(int i, Operand op)` Set the specified local variable
`private void`	`setLocalDual(int i, Operand op)` Set the specified local variable
`private InlineDecision`	`shouldInline(Instruction call, boolean isExtant, int realBCI)` Should we inline a call site?
`private void`	`start(GenerationContext context)`

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

- Field Detail
  - DUMMY
```
public static final BC2IR.DummyStackSlot DUMMY
```
    Dummy slot. Used to deal with the fact the longs/doubles take two words of stack space/local space to represent. This field needs to be accessed by several of the IR classes, but is not intended to be referenced by general client code.
  - gc
```
private GenerationContext gc
```
    The generation context.
  - bcodes
```
private BytecodeStream bcodes
```
    Bytecodes for the method being generated.
  - blocks
```
private BBSet blocks
```
    The set of BasicBlockLEs we are generating
  - instrIndex
```
private int instrIndex
```
    Bytecode index of current instruction.
  - osrGuardedInline
```
private boolean osrGuardedInline
```
  - bciAdjustment
```
private int bciAdjustment
```
    OSR field: TODO rework this mechanism! adjustment of bcIndex of instructions because of specialized bytecode.
  - lastInstr
```
private Instruction lastInstr
```
    Last instruction generated (for ELIM_COPY_LOCALS)
  - endOfBasicBlock
```
private boolean endOfBasicBlock
```
    Does basic block end here?
  - fallThrough
```
private boolean fallThrough
```
    Do we fall through to the next basic block?
  - currentBBLE
```
private BasicBlockLE currentBBLE
```
    Current BBLE.
  - stack
```
private OperandStack stack
```
    Current simulated stack state.
  - _localState
```
private Operand[] _localState
```
    Current state of local variables.
  - runoff
```
private int runoff
```
    Index of next basic block.
  - currentGuard
```
private Operand currentGuard
```
  - inlinedSomething
```
private boolean inlinedSomething
```
    Was something inlined?
  - param1
```
private int param1
```
    OSR: used for PSEUDO_InvokeStatic to recover the type info
  - param2
```
private int param2
```
    OSR: used for PSEUDO_InvokeStatic to recover the type info
  - lastOsrBarrier
```
private Instruction lastOsrBarrier
```
    osr barrier needs type information of locals and stacks, it has to be created before a _callHelper. only when the call site is going to be inlined, the instruction is inserted before the call site.
  - DBG_SELECTIVE
```
private static final boolean DBG_SELECTIVE
```
    Debugging with method_to_print. Switch following 2 to both be non-final. Set DBG_SELECTIVE to true. DBG_SELECTED will then be true when the method matches. You must also uncomment the assignment to DBG_SELECTIVE in start(GenerationContext).
    
    See Also:
    
    Constant Field Values
  - DBG_SELECTED
```
static final boolean DBG_SELECTED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - BC2IR
```
private BC2IR(GenerationContext context)
```
    Construct the BC2IR object for the generation context. After the constructor completes, we're ready to start generating HIR from bytecode 0 of context.method.
    
    Parameters:
    
    context - the context to generate HIR into
- Method Detail
  - generateHIR
```
public static void generateHIR(GenerationContext context)
```
    Generate HIR as specified by the argument GenerationContext. As a result of calling this method, the cfg field of the generation context is populated with basic blocks and instructions. Additionally, other fields of the generation context will be modified to summarize what happened during IR generation.
    This is the only external entry point to BC2IR.
    Note: most clients should be calling methods in ConvertBCtoHIR or in Inliner rather than invoking BC2IR.generateHIR directly.
    
    Parameters:
    
    context - the generation context
  - start
```
private void start(GenerationContext context)
```
  - finish
```
private void finish(GenerationContext context)
```
  - generateHIR
```
private void generateHIR()
```
    Main generation loop.
  - generateAnewarray
```
public Instruction generateAnewarray(TypeReference arrayTypeRef,
                                     TypeReference elementTypeRef)
```
  - generateFrom
```
private void generateFrom(int fromIndex)
```
    Generate instructions for a basic block. May discover other basic blocks that need to be generated along the way.
    
    Parameters:
    
    fromIndex - bytecode index to start from
  - _unaryHelper
```
Instruction _unaryHelper(Operator operator,
                         Operand val,
                         TypeReference type)
```
  - _unaryDualHelper
```
Instruction _unaryDualHelper(Operator operator,
                             Operand val,
                             TypeReference type)
```
  - _binaryHelper
```
public Instruction _binaryHelper(Operator operator,
                                 Operand op1,
                                 Operand op2,
                                 TypeReference type)
```
  - _guardedBinaryHelper
```
private Instruction _guardedBinaryHelper(Operator operator,
                                         Operand op1,
                                         Operand op2,
                                         Operand guard,
                                         TypeReference type)
```
  - _binaryDualHelper
```
private Instruction _binaryDualHelper(Operator operator,
                                      Operand op1,
                                      Operand op2,
                                      TypeReference type)
```
  - _guardedBinaryDualHelper
```
private Instruction _guardedBinaryDualHelper(Operator operator,
                                             Operand op1,
                                             Operand op2,
                                             Operand guard,
                                             TypeReference type)
```
  - _moveHelper
```
Instruction _moveHelper(Operator operator,
                        Operand val,
                        TypeReference type)
```
  - _moveDualHelper
```
private Instruction _moveDualHelper(Operator operator,
                                    Operand val,
                                    TypeReference type)
```
  - _aloadHelper
```
public Instruction _aloadHelper(Operator operator,
                                Operand ref,
                                Operand index,
                                TypeReference type)
```
  - _callHelper
```
private Instruction _callHelper(MethodReference meth,
                                MethodOperand methOp)
```
    Pop method parameters off the expression stack. If a non-void return, then create a result operand and push it on the stack. Create the call instruction and initialize all its operands.
    
    Parameters:
    
    meth - the method to call
    
    methOp - data about the method
    
    Returns:
    
    the newly created call instruction
  - _returnHelper
```
private void _returnHelper(Operator operator,
                           Operand val)
```
  - appendInstruction
```
public void appendInstruction(Instruction s)
```
    Append an instruction to the current basic block.
    
    Parameters:
    
    s - instruction to append
  - makeStaticFieldRef
```
private LocationOperand makeStaticFieldRef(FieldReference f)
```
    Make a field reference operand referring to the given field with the given type.
    
    Parameters:
    
    f - desired field
    
    Returns:
    
    a new location operand
  - makeInstanceFieldRef
```
private LocationOperand makeInstanceFieldRef(FieldReference f)
```
  - makeTypeOperand
```
private TypeOperand makeTypeOperand(TypeReference type)
```
    Make a type operand that refers to the given type.
    
    Parameters:
    
    type - desired type
    
    Returns:
    
    a new type operand
  - makeTypeOperand
```
private TypeOperand makeTypeOperand(RVMType type)
```
    Make a type operand that refers to the given type.
    
    Parameters:
    
    type - desired type
    
    Returns:
    
    a new type operand
  - couldCauseClassLoading
```
private boolean couldCauseClassLoading(TypeReference typeRef)
```
  - getConstantOperand
```
public Operand getConstantOperand(int index)
```
    Fetch the value of the next operand, a constant, from the bytecode stream.
    
    Parameters:
    
    index - constant pool index
    
    Returns:
    
    the value of a literal constant from the bytecode stream, encoding as a constant IR operand
  - do_iload
```
private Instruction do_iload(int index)
```
    Simulates a load from a given local variable of an int.
    
    Parameters:
    
    index - local variable number
    
    Returns:
    
    null if no instruction is necessary, a move instruction otherwise
  - do_fload
```
private Instruction do_fload(int index)
```
    Simulates a load from a given local variable of a float.
    
    Parameters:
    
    index - local variable number
    
    Returns:
    
    null if no instruction is necessary, a move instruction otherwise
  - do_aload
```
private Instruction do_aload(int index)
```
    Simulates a load from a given local variable of a reference.
    
    Parameters:
    
    index - local variable number
    
    Returns:
    
    null if no instruction is necessary, a move instruction otherwise
  - do_lload
```
private Instruction do_lload(int index)
```
    Simulates a load from a given local variable of a long.
    
    Parameters:
    
    index - local variable number
    
    Returns:
    
    null if no instruction is necessary, a move instruction otherwise
  - do_dload
```
private Instruction do_dload(int index)
```
    Simulates a load from a given local variable of a double.
    
    Parameters:
    
    index - local variable number
    
    Returns:
    
    null if no instruction is necessary, a move instruction otherwise
  - do_iinc
```
private Instruction do_iinc(int index,
                            int amount)
```
    Simulates the incrementing of a given int local variable.
    
    Parameters:
    
    index - local variable number
    
    amount - amount to increment by
    
    Returns:
    
    the generated instruction, never null
  - do_store
```
private Instruction do_store(int index,
                             Operand op1)
```
    Simulates a store into a given local variable of an int/long/double/float
    
    Parameters:
    
    index - local variable number
    
    op1 - the value to store
    
    Returns:
    
    null if no instruction is necessary, the generated instruction otherwise
  - do_astore
```
private Instruction do_astore(int index)
```
    Simulates a store into a given local variable of an object ref.
    
    Parameters:
    
    index - local variable number
    
    Returns:
    
    null if no instruction is necessary, the generated instruction otherwise
  - push
```
public void push(Operand r)
```
    Push a single width operand (int, float, ref, ...) on the simulated stack.
    
    Parameters:
    
    r - operand to push
  - pushDual
```
void pushDual(Operand r)
```
    Push a double width operand (long, double) on the simulated stack.
    
    Parameters:
    
    r - operand to push
  - push
```
void push(Operand r,
          TypeReference type)
```
    Push an operand of the specified type on the simulated stack.
    
    Parameters:
    
    r - operand to push
    
    type - data type of operand
  - pushCopy
```
private Instruction pushCopy(Operand op1)
```
    Pushes a copy of the given operand onto simulated stack.
    
    Parameters:
    
    op1 - operand to push
    
    Returns:
    
    always null
  - pop
```
Operand pop()
```
    Pops an operand from the stack. No type checking is performed.
    
    Returns:
    
    the popped operand
  - popInt
```
public Operand popInt()
```
    Pops an int operand from the stack.
    
    Returns:
    
    the popped operand
  - popFloat
```
Operand popFloat()
```
    Pops a float operand from the stack.
    
    Returns:
    
    the popped operand
  - popRef
```
public Operand popRef()
```
    Pops a ref operand from the stack.
    
    Returns:
    
    the popped operand
  - popAddress
```
public Operand popAddress()
```
    Pops an address operand from the stack.
    
    Returns:
    
    the popped operand
  - popLong
```
Operand popLong()
```
    Pops a long operand from the stack.
    
    Returns:
    
    the popped operand
  - popDouble
```
Operand popDouble()
```
    Pops a double operand from the stack.
    
    Returns:
    
    the popped operand
  - popDummy
```
void popDummy()
```
    Pops a dummy operand from the stack.
  - pop
```
Operand pop(TypeReference type)
```
    Pops an operand of the given type from the stack.
    
    Parameters:
    
    type - the expected type of the operand
    
    Returns:
    
    the popped operand
  - popShiftInt
```
private Operand popShiftInt(boolean longShift)
```
    Pop an int from the stack to be used in a shift. A shift only uses the bottom 5 or 6 bits of an int so the upper bits must be masked to conform with the semantics of xx_SHx. NB the opt compiler shift operators allow that (x << 16) << 16 == x << 32, which isn't true in the bytecode
    
    Parameters:
    
    longShift - is this a shift of a long
    
    Returns:
    
    the operand containing the amount to shift by
  - _jsrHelper
```
private Instruction _jsrHelper(int offset)
```
  - _retHelper
```
private Instruction _retHelper(int var)
```
  - getArrayTypeOf
```
public TypeReference getArrayTypeOf(Operand op)
```
    Returns the data type of the given operand, assuming that the operand is an array reference. (and not a null constant.)
    
    Parameters:
    
    op - operand to get type of
    
    Returns:
    
    operand's data type
  - getRefTypeOf
```
private TypeReference getRefTypeOf(Operand op)
```
    Returns the data type of the given operand, assuming that the operand is a reference. (and not a null constant.)
    
    Parameters:
    
    op - operand to get type of
    
    Returns:
    
    operand's data type
  - assertIsType
```
public void assertIsType(Operand op,
                         TypeReference type)
```
    Assert that the given operand is of the given type, or of a subclass of the given type.
    
    Parameters:
    
    op - operand to check
    
    type - expected type of operand
  - assertIsAssignable
```
private void assertIsAssignable(TypeReference parentType,
                                TypeReference childType)
```
    Assert that the given child type is a subclass of the given parent type.
    
    Parameters:
    
    parentType - parent type
    
    childType - child type
  - db
```
private void db(String val)
```
    Print a debug string to the sysWrite stream
    
    Parameters:
    
    val - string to print
  - printBlocks
```
private String printBlocks()
```
    Returns:
    
    a string representation of the current basic block set.
  - isNonNull
```
public static boolean isNonNull(Operand op)
```
  - hasGuard
```
public static boolean hasGuard(RegisterOperand rop)
```
  - hasLessConservativeGuard
```
public static boolean hasLessConservativeGuard(RegisterOperand rop1,
                                               RegisterOperand rop2)
```
  - markGuardlessNonNull
```
public void markGuardlessNonNull(RegisterOperand rop)
```
  - copyGuardFromOperand
```
public static Operand copyGuardFromOperand(Operand op)
```
  - setGuardForRegOp
```
public static void setGuardForRegOp(RegisterOperand rop,
                                    Operand guard)
```
  - setCurrentGuard
```
private void setCurrentGuard(Operand guard)
```
  - clearCurrentGuard
```
public void clearCurrentGuard()
```
  - getCurrentGuard
```
public Operand getCurrentGuard()
```
  - do_NullCheck
```
public boolean do_NullCheck(Operand ref)
```
    Generates a null-check instruction for the given operand.
    
    Parameters:
    
    ref - the reference to check for null
    
    Returns:
    
    true if an unconditional throw is generated, false otherwise
  - do_BoundsCheck
```
public boolean do_BoundsCheck(Operand ref,
                              Operand index)
```
    Generates a boundscheck instruction for the given operand and index.
    
    Parameters:
    
    ref - the array reference
    
    index - the array index
    
    Returns:
    
    true if an unconditional throw is generated, false otherwise
  - do_IntZeroCheck
```
private boolean do_IntZeroCheck(Operand div)
```
    Generates a check for 0 for the given operand
    
    Parameters:
    
    div - the value to check
    
    Returns:
    
    true if an unconditional trap is generated, false otherwise
  - do_LongZeroCheck
```
private boolean do_LongZeroCheck(Operand div)
```
    Generates a checks for 0 for the given operand
    
    Parameters:
    
    div - the value to check
    
    Returns:
    
    true if an unconditional trap is generated, false otherwise
  - do_CheckStore
```
private boolean do_CheckStore(Operand ref,
                              Operand elem,
                              TypeReference elemType)
```
    Generate a storecheck for the given array and elem
    
    Parameters:
    
    ref - the array reference
    
    elem - the element to be written to the array
    
    elemType - the type of the array references elements
    
    Returns:
    
    true if an unconditional throw is generated, false otherwise
  - getOrCreateBlock
```
private BasicBlockLE getOrCreateBlock(int target)
```
    Gets or creates a block at the specified target. Rectifies current state with target state. Instructions to rectify state are appended to currentBBLE. If the target is between bcodes.index() and runoff, runoff is updated to be target.
    
    Parameters:
    
    target - target index
    
    Returns:
    
    a block, never null
  - getOrCreateBlock
```
private BasicBlockLE getOrCreateBlock(int target,
                                      BasicBlockLE from,
                                      OperandStack simStack,
                                      Operand[] simLocals)
```
    Get or create a block at the specified target. If simStack is non-null, rectifies stack state with target stack state. If simLocals is non-null, rectifies local state with target local state. Any instructions needed to rectify stack/local state are appended to from. If the target is between bcodes.index() and runoff, runoff is updated to be target.
    
    Parameters:
    
    target - target index
    
    from - the block from which control is being transfered and to which stack rectification instructions are added.
    
    simStack - stack state to rectify, or null
    
    simLocals - local state to rectify, or null
    
    Returns:
    
    a block, never null
  - generateTarget
```
private BranchOperand generateTarget(int offset)
```
  - _gotoHelper
```
private Instruction _gotoHelper(int offset)
```
  - _intIfHelper
```
private Instruction _intIfHelper(ConditionOperand cond)
```
  - _intIfCmpHelper
```
private Instruction _intIfCmpHelper(ConditionOperand cond)
```
  - _refIfNullHelper
```
private Instruction _refIfNullHelper(ConditionOperand cond)
```
  - _refIfCmpHelper
```
private Instruction _refIfCmpHelper(ConditionOperand cond)
```
  - replaceLocalsOnStack
```
private void replaceLocalsOnStack(int index,
                                  TypeReference type)
```
    Replaces copies of local <#index,type> with newly-generated temporaries, and generates the necessary move instructions.
    
    Parameters:
    
    index - the local's index
    
    type - the local's type
  - rectifyStateWithNullPtrExceptionHandler
```
private BasicBlock rectifyStateWithNullPtrExceptionHandler()
```
  - rectifyStateWithArrayBoundsExceptionHandler
```
private BasicBlock rectifyStateWithArrayBoundsExceptionHandler()
```
  - rectifyStateWithArithmeticExceptionHandler
```
private BasicBlock rectifyStateWithArithmeticExceptionHandler()
```
  - rectifyStateWithArrayStoreExceptionHandler
```
private BasicBlock rectifyStateWithArrayStoreExceptionHandler()
```
  - rectifyStateWithErrorHandler
```
private BasicBlock rectifyStateWithErrorHandler()
```
  - rectifyStateWithExceptionHandlers
```
public void rectifyStateWithExceptionHandlers()
```
  - rectifyStateWithExceptionHandler
```
public BasicBlock rectifyStateWithExceptionHandler(TypeReference exceptionType)
```
  - rectifyStateWithNullPtrExceptionHandler
```
private BasicBlock rectifyStateWithNullPtrExceptionHandler(boolean linkToExitIfUncaught)
```
  - rectifyStateWithArrayBoundsExceptionHandler
```
private BasicBlock rectifyStateWithArrayBoundsExceptionHandler(boolean linkToExitIfUncaught)
```
  - rectifyStateWithArithmeticExceptionHandler
```
private BasicBlock rectifyStateWithArithmeticExceptionHandler(boolean linkToExitIfUncaught)
```
  - rectifyStateWithArrayStoreExceptionHandler
```
private BasicBlock rectifyStateWithArrayStoreExceptionHandler(boolean linkToExitIfUncaught)
```
  - rectifyStateWithErrorHandler
```
private BasicBlock rectifyStateWithErrorHandler(boolean linkToExitIfUncaught)
```
  - rectifyStateWithExceptionHandler
```
private BasicBlock rectifyStateWithExceptionHandler(TypeReference exceptionType,
                                                    boolean linkToExitIfUncaught)
```
  - rectifyStateWithExceptionHandlers
```
private void rectifyStateWithExceptionHandlers(boolean linkToExitIfUncaught)
```
  - shouldInline
```
private InlineDecision shouldInline(Instruction call,
                                    boolean isExtant,
                                    int realBCI)
```
    Should we inline a call site?
    
    Parameters:
    
    call - the call instruction being considered for inlining
    
    isExtant - is the receiver of a virtual method an extant object?
    
    realBCI - the real bytecode index of the call instruction, not adjusted because of OSR
    
    Returns:
    
    the inline decision (which cannot be null)
  - maybeInlineMethod
```
private boolean maybeInlineMethod(InlineDecision inlDec,
                                  Instruction callSite)
```
    Attempt to inline a method. This may fail.
    
    Parameters:
    
    inlDec - the inline decision for this call site
    
    callSite - the call instruction we are attempting to inline
    
    Returns:
    
    true if inlining succeeded, false otherwise
  - _createOsrBarrier
```
private Instruction _createOsrBarrier()
```
  - _prepareLongConstant
```
private Operand _prepareLongConstant(Operand op)
```
    special process for long/double constants
    
    Parameters:
    
    op - a long constant
    
    Returns:
    
    a new operand
  - _prepareDoubleConstant
```
private Operand _prepareDoubleConstant(Operand op)
```
    special process for long/double constants
    
    Parameters:
    
    op - a double constant
    
    Returns:
    
    a new operand
  - _loadLocalForOSR
```
private Operand _loadLocalForOSR(Operand op)
```
    make a temporary register, and create a move instruction
    
    Parameters:
    
    op - the local variable.
    
    Returns:
    
    operand marked as use.
  - _osrHelper
```
public static Instruction _osrHelper(Instruction barrier,
                                     GenerationContext gc)
```
    Creates an OSR point instruction with its dependent OsrBarrier which provides type and variable information. The OsrPoint instruction is going to be refilled immediately after BC2IR, before any other optimizations.
    
    Parameters:
    
    barrier - the OSR barrier instruction
    
    gc - context that has information about OSR
    
    Returns:
    
    the osr point instruction
  - getLocal
```
private Operand getLocal(int i)
```
    Gets the specified local variable. This can return an RegisterOperand which refers to the given local, or some other kind of operand (if the local variable is assumed to contain a particular value.)
    
    Parameters:
    
    i - local variable number
    
    Returns:
    
    a copy of the local variable
  - getLocalDual
```
private Operand getLocalDual(int i)
```
    Gets the specified local variable (long, double). This can return an RegisterOperand which refers to the given local, or some other kind of operand (if the local variable is assumed to contain a given value.)
    
    Parameters:
    
    i - local variable number
    
    Returns:
    
    a copy of the local variable
  - setLocal
```
private void setLocal(int i,
                      Operand op)
```
    Set the specified local variable
    
    Parameters:
    
    i - local variable number
    
    op - Operand to store in the local
  - setLocalDual
```
private void setLocalDual(int i,
                          Operand op)
```
    Set the specified local variable
    
    Parameters:
    
    i - local variable number
    
    op - Operand to store in the local

Class BC2IR

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DUMMY

gc

bcodes

blocks

instrIndex

osrGuardedInline

bciAdjustment

lastInstr

endOfBasicBlock

fallThrough

currentBBLE

stack

_localState

runoff

currentGuard

inlinedSomething

param1

param2

lastOsrBarrier

DBG_SELECTIVE

DBG_SELECTED

Constructor Detail

BC2IR

Method Detail

generateHIR

start

finish

generateHIR

generateAnewarray

generateFrom

_unaryHelper

_unaryDualHelper

_binaryHelper

_guardedBinaryHelper

_binaryDualHelper

_guardedBinaryDualHelper

_moveHelper

_moveDualHelper

_aloadHelper

_callHelper

_returnHelper

appendInstruction

makeStaticFieldRef

makeInstanceFieldRef

makeTypeOperand

makeTypeOperand

couldCauseClassLoading

getConstantOperand

do_iload

do_fload

do_aload

do_lload

do_dload

do_iinc

do_store

do_astore

push

pushDual

push

pushCopy

pop

popInt

popFloat

popRef

popAddress

popLong

popDouble

popDummy

pop

popShiftInt

_jsrHelper

_retHelper

getArrayTypeOf