BytecodeParser (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.java.BytecodeParser

All Implemented Interfaces:

GraphBuilderContext
```
public class BytecodeParser
extends Object
implements GraphBuilderContext
```
The GraphBuilder class parses the bytecode of a method and builds the IR graph.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`BytecodeParser.BytecodeParserError`
`private static class`	`BytecodeParser.ExplodedLoopContext`
`(package private) static class`	`BytecodeParser.IntrinsicScope` A scoped object for tasks to be performed after parsing an intrinsic such as processing placeholder frames states.
`(package private) class`	`BytecodeParser.InvocationPluginAssertions` Contains all the assertion checking logic around the application of an `InvocationPlugin`.
`static class`	`BytecodeParser.Options`
`(package private) static class`	`BytecodeParser.SuccessorInfo`
`private static class`	`BytecodeParser.Target`

Field Summary

Fields
Modifier and Type	Field and Description
`private FixedWithNextNode`	`beforeReturnNode`
`private FixedWithNextNode`	`beforeUnwindNode`
`private BciBlockMapping`	`blockMap`
`static DebugMetric`	`BytecodesParsed` Meters the number of actual bytecodes parsed.
`protected ConstantPool`	`constantPool`
`private ConstantReflectionProvider`	`constantReflection`
`private boolean`	`controlFlowSplit`
`protected BciBlockMapping.BciBlock`	`currentBlock`
`private CallTargetNode.InvokeKind`	`currentInvokeKind`
`private JavaType`	`currentInvokeReturnType`
`private int`	`currentLineNumber`
`protected int`	`entryBCI`
`private FrameStateBuilder[]`	`entryStateArray`
`private FrameStateBuilder[][]`	`entryStateMatrix`
`protected static DebugMetric`	`EXPLICIT_EXCEPTIONS`
`private boolean`	`explodeLoops`
`private Deque<BytecodeParser.ExplodedLoopContext>`	`explodeLoopsContext`
`private FixedWithNextNode[]`	`firstInstructionArray`
`private FixedWithNextNode[][]`	`firstInstructionMatrix`
`private boolean`	`forceInliningEverything`
`protected FrameStateBuilder`	`frameState`
`protected StructuredGraph`	`graph`
`protected GraphBuilderConfiguration`	`graphBuilderConfig`
`private GraphBuilderPhase.Instance`	`graphBuilderInstance`
`protected IntrinsicContext`	`intrinsicContext`
`private InvocationPlugins.InvocationPluginReceiver`	`invocationPluginReceiver`
`(package private) InlineInvokePlugin.InlineInfo`	`lastInlineInfo`
`private FixedWithNextNode`	`lastInstr`
`private LocalLiveness`	`liveness`
`private LineNumberTable`	`lnt`
`private boolean`	`mergeExplosions`
`private Map<FrameStateBuilder,Integer>`	`mergeExplosionsMap`
`protected MetaAccessProvider`	`metaAccess`
`protected ResolvedJavaMethod`	`method`
`private ValueNode`	`methodSynchronizedObject`
`private int`	`nextPeelIteration`
`protected OptimisticOptimizations`	`optimisticOpts`
`private BytecodeParser`	`parent`
`private int`	`previousLineNumber`
`protected ProfilingInfo`	`profilingInfo`
`private ValueNode`	`returnValue`
`private StampProvider`	`stampProvider`
`protected BytecodeStream`	`stream`
`static int`	`TRACELEVEL_INSTRUCTIONS` The minimum value to which `BytecodeParser.Options.TraceBytecodeParserLevel` must be set to trace the bytecode instructions as they are parsed.
`static int`	`TRACELEVEL_STATE` The minimum value to which `BytecodeParser.Options.TraceBytecodeParserLevel` must be set to trace the frame state before each bytecode instruction as it is parsed.
`private ValueNode`	`unwindValue`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`BytecodeParser(GraphBuilderPhase.Instance graphBuilderInstance, StructuredGraph graph, BytecodeParser parent, ResolvedJavaMethod method, int entryBCI, IntrinsicContext intrinsicContext)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addLoopExits(LoopBeginNode loopBegin, LoopBeginNode inner, IdentityHashMap<LoopBeginNode,List<LoopBeginNode>> innerLoopsMap, NodeBitMap visited)`
`private void`	`addToMergeCache(FrameStateBuilder key, int dimension)`
`private static boolean`	`allPositive(double[] a)`
`<T extends ValueNode> T`	`append(T v)` Raw operation for adding a node to the graph when neither `GraphBuilderContext.add(T)` nor `GraphBuilderContext.addPush(Kind, ValueNode)` can be used.
`protected ConstantNode`	`appendConstant(JavaConstant constant)`
`private void`	`appendGoto(BciBlockMapping.BciBlock successor)`
`private void`	`appendInvoke(CallTargetNode.InvokeKind initialInvokeKind, ResolvedJavaMethod initialTargetMethod, ValueNode[] args)`
`private LoopBeginNode`	`appendLoopBegin(FixedWithNextNode fixedWithNext)`
`private ValueNode`	`appendNullCheck(ValueNode object)`
`private static Class<?>`	`arrayTypeCodeToClass(int code)` Gets the kind of array elements for the array type code that appears in a `Bytecodes.NEWARRAY` bytecode.
`protected BytecodeParser.BytecodeParserError`	`asParserError(Throwable e)`
`private boolean`	`assertAtIfBytecode()`
`private static boolean`	`assertionsEnabled()`
`BailoutException`	`bailout(String string)`
`int`	`bci()` Gets the index of the bytecode instruction currently being parsed.
`private void`	`beforeReturn(ValueNode x, Kind kind)`
`protected double`	`branchProbability()`
`protected void`	`build(FixedWithNextNode startInstruction, FrameStateBuilder startFrameState)`
`protected void`	`buildRootMethod()`
`private static boolean`	`callTargetIsResolved(JavaMethod target)` Ensure that concrete classes are at least linked before generating an invoke.
`protected boolean`	`checkLastInstruction()`
`private BytecodeParser.Target`	`checkLoopExit(FixedNode target, BciBlockMapping.BciBlock targetBlock, FrameStateBuilder state)`
`private int`	`checkPositiveIntConstantPushed(BciBlockMapping.BciBlock block)`
`protected void`	`cleanupFinalGraph()`
`private boolean`	`computeKindVerification(FrameStateBuilder startFrameState)`
`private AbstractBeginNode`	`createBlockTarget(double probability, BciBlockMapping.BciBlock block, FrameStateBuilder stateAfter)` Returns a block begin node with the specified state.
`private BytecodePosition`	`createBytecodePosition()`
`protected ValueNode`	`createCheckCast(ResolvedJavaType type, ValueNode object, JavaTypeProfile profileForTypeCheck, boolean forStoreCheck)`
`private void`	`createExceptionDispatch(BciBlockMapping.ExceptionDispatchBlock block)`
`private FrameState`	`createFrameState(int bci, StateSplit forStateSplit)`
`protected ValueNode`	`createInstanceOf(ResolvedJavaType type, ValueNode object, JavaTypeProfile profileForTypeCheck)`
`protected InvokeNode`	`createInvoke(CallTargetNode callTarget, Kind resultType)`
`protected InvokeWithExceptionNode`	`createInvokeWithException(CallTargetNode callTarget, Kind resultType)`
`private LogicNode`	`createLogicNode(Condition cond, ValueNode a, ValueNode b)`
`protected MethodCallTargetNode`	`createMethodCallTarget(CallTargetNode.InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] args, JavaType returnType, JavaTypeProfile profile)`
`protected NewArrayNode`	`createNewArray(ResolvedJavaType elementType, ValueNode length, boolean fillContents)`
`protected NewInstanceNode`	`createNewInstance(ResolvedJavaType type, boolean fillContents)`
`protected NewMultiArrayNode`	`createNewMultiArray(ResolvedJavaType type, List<ValueNode> dimensions)`
`private FrameState`	`createStateAfterStartOfReplacementGraph()` Creates the frame state after the start node of a graph for an `intrinsic` that is the parse root (either for root compiling or for post-parse inlining).
`private FixedNode`	`createTarget(BciBlockMapping.BciBlock block, FrameStateBuilder state)`
`private FixedNode`	`createTarget(BciBlockMapping.BciBlock block, FrameStateBuilder state, boolean canReuseInstruction, boolean canReuseState)`
`private FixedNode`	`createTarget(double probability, BciBlockMapping.BciBlock block, FrameStateBuilder stateAfter)`
`private void`	`createUnwind()`
`private void`	`detectLoops(FixedNode startInstruction)`
`protected void`	`emitExplicitBoundsCheck(ValueNode index, ValueNode length)`
`protected ValueNode`	`emitExplicitExceptions(ValueNode receiver, ValueNode index)`
`protected ValueNode`	`emitExplicitNullCheck(ValueNode receiver)`
`private int`	`findOperatingDimension(BciBlockMapping.BciBlock block, FrameStateBuilder state)`
`private int`	`findOperatingDimensionWithLoopExplosion(BciBlockMapping.BciBlock block, FrameStateBuilder state)`
`protected FixedWithNextNode`	`finishInstruction(FixedWithNextNode instr, FrameStateBuilder state)` Hook for subclasses to modify the last instruction or add other instructions.
`protected void`	`finishPrepare(FixedWithNextNode startInstr)` Hook for subclasses to modify the graph start instruction or append new instructions to it.
`protected boolean`	`forceLoopPhis()`
`protected ValueNode`	`genAnd(ValueNode x, ValueNode y)`
`private void`	`genArithmeticOp(Kind kind, int opcode)`
`private void`	`genArrayLength()`
`protected ValueNode`	`genArrayLength(ValueNode x)`
`private void`	`genCheckCast()`
`private void`	`genCompareOp(Kind kind, boolean isUnorderedLess)`
`protected ValueNode`	`genConditional(ValueNode x)`
`private void`	`genConditionalForIf(BciBlockMapping.BciBlock trueBlock, LogicNode condition, int oldBci, int trueBlockInt, int falseBlockInt, boolean genReturn)`
`private void`	`genConstantTargetIf(BciBlockMapping.BciBlock trueBlock, BciBlockMapping.BciBlock falseBlock, boolean negate, LogicNode condition)`
`protected ValueNode`	`genFloatAdd(ValueNode x, ValueNode y)`
`private void`	`genFloatConvert(FloatConvert op, Kind from, Kind to)`
`protected ValueNode`	`genFloatConvert(FloatConvert op, ValueNode input)`
`protected ValueNode`	`genFloatDiv(ValueNode x, ValueNode y)`
`protected ValueNode`	`genFloatMul(ValueNode x, ValueNode y)`
`protected ValueNode`	`genFloatRem(ValueNode x, ValueNode y)`
`protected ValueNode`	`genFloatSub(ValueNode x, ValueNode y)`
`private void`	`genGetField(JavaField field)`
`private void`	`genGetStatic(JavaField field)`
`protected void`	`genGoto()`
`protected void`	`genIf(ValueNode x, Condition cond, ValueNode y)`
`protected ValueNode`	`genIfNode(LogicNode condition, FixedNode falseSuccessor, FixedNode trueSuccessor, double d)`
`private void`	`genIfNull(Condition cond)`
`private void`	`genIfSame(Kind kind, Condition cond)`
`private void`	`genIfZero(Condition cond)`
`private void`	`genIncrement()`
`private void`	`genInfoPointNode(InfopointReason reason, ValueNode escapedReturnValue)`
`private void`	`genInstanceOf()`
`protected ValueNode`	`genIntegerAdd(ValueNode x, ValueNode y)`
`protected ValueNode`	`genIntegerDiv(ValueNode x, ValueNode y)`
`private void`	`genIntegerDivOp(Kind kind, int opcode)`
`protected LogicNode`	`genIntegerEquals(ValueNode x, ValueNode y)`
`protected LogicNode`	`genIntegerLessThan(ValueNode x, ValueNode y)`
`protected ValueNode`	`genIntegerMul(ValueNode x, ValueNode y)`
`protected ValueNode`	`genIntegerRem(ValueNode x, ValueNode y)`
`protected ValueNode`	`genIntegerSub(ValueNode x, ValueNode y)`
`protected void`	`genIntegerSwitch(ValueNode value, ArrayList<BciBlockMapping.BciBlock> actualSuccessors, int[] keys, double[] keyProbabilities, int[] keySuccessors)`
`protected void`	`genInvokeDynamic(JavaMethod target)`
`protected void`	`genInvokeInterface(JavaMethod target)`
`protected void`	`genInvokeSpecial(JavaMethod target)`
`protected void`	`genInvokeStatic(JavaMethod target)`
`protected void`	`genInvokeVirtual(JavaMethod target)`
`protected void`	`genJsr(int dest)`
`protected ValueNode`	`genLeftShift(ValueNode x, ValueNode y)`
`private void`	`genLoadConstant(int cpi, int opcode)`
`protected ValueNode`	`genLoadField(ValueNode receiver, ResolvedJavaField field)`
`private void`	`genLoadIndexed(Kind kind)`
`protected ValueNode`	`genLoadIndexed(ValueNode array, ValueNode index, Kind kind)`
`private void`	`genLogicOp(Kind kind, int opcode)`
`protected void`	`genMonitorEnter(ValueNode x, int bci)`
`protected void`	`genMonitorExit(ValueNode x, ValueNode escapedReturnValue, int bci)`
`private void`	`genNarrow(Kind from, Kind to)`
`protected ValueNode`	`genNarrow(ValueNode input, int bitCount)`
`private void`	`genNegateOp(Kind kind)`
`protected ValueNode`	`genNegateOp(ValueNode x)`
`(package private) void`	`genNewInstance(int cpi)`
`private void`	`genNewMultiArray(int cpi)`
`private void`	`genNewObjectArray(int cpi)`
`private void`	`genNewPrimitiveArray(int typeCode)`
`protected ValueNode`	`genNormalizeCompare(ValueNode x, ValueNode y, boolean isUnorderedLess)`
`protected LogicNode`	`genObjectEquals(ValueNode x, ValueNode y)`
`protected ValueNode`	`genOr(ValueNode x, ValueNode y)`
`private void`	`genPutField(JavaField field)`
`private void`	`genPutStatic(JavaField field)`
`protected void`	`genRet(int localIndex)`
`protected void`	`genReturn(ValueNode returnVal, Kind returnKind)`
`protected ValueNode`	`genRightShift(ValueNode x, ValueNode y)`
`private void`	`genShiftOp(Kind kind, int opcode)`
`private void`	`genSignExtend(Kind from, Kind to)`
`protected ValueNode`	`genSignExtend(ValueNode input, int bitCount)`
`protected void`	`genStoreField(ValueNode receiver, ResolvedJavaField field, ValueNode value)`
`private void`	`genStoreIndexed(Kind kind)`
`protected void`	`genStoreIndexed(ValueNode array, ValueNode index, Kind kind, ValueNode value)`
`private void`	`genSwitch(BytecodeSwitch bs)`
`protected void`	`genThrow()`
`protected ValueNode`	`genUnique(ValueNode x)`
`protected ValueNode`	`genUnsignedRightShift(ValueNode x, ValueNode y)`
`protected ValueNode`	`genXor(ValueNode x, ValueNode y)`
`private void`	`genZeroExtend(Kind from, Kind to)`
`protected ValueNode`	`genZeroExtend(ValueNode input, int bitCount)`
`FixedWithNextNode`	`getBeforeReturnNode()`
`FixedWithNextNode`	`getBeforeUnwindNode()`
`ConstantReflectionProvider`	`getConstantReflection()`
`private int`	`getCurrentDimension()`
`private FrameStateBuilder`	`getEntryState(BciBlockMapping.BciBlock block, int dimension)`
`private FrameStateBuilder`	`getEntryStateMultiDimension(int dimension, int id)`
`private FixedWithNextNode`	`getFirstInstruction(BciBlockMapping.BciBlock block, int dimension)`
`private FixedWithNextNode`	`getFirstInstructionMultiDimension(int dimension, int id)`
`FrameStateBuilder`	`getFrameStateBuilder()`
`StructuredGraph`	`getGraph()` Gets the graph being processed by this builder.
`IntrinsicContext`	`getIntrinsic()` Gets the intrinsic of the current parsing context or `null` if not `parsing an intrinsic`.
`CallTargetNode.InvokeKind`	`getInvokeKind()` Gets the kind of invocation currently being parsed.
`JavaType`	`getInvokeReturnType()` Gets the return type of the invocation currently being parsed.
`private ConstantNode`	`getJsrConstant(long bci)`
`MetaAccessProvider`	`getMetaAccess()`
`ResolvedJavaMethod`	`getMethod()` Gets the method being parsed by this context.
`BytecodeParser`	`getNonIntrinsicAncestor()` Gets the first ancestor parsing context that is not parsing a intrinsic.
`BytecodeParser`	`getParent()` Gets the parsing context for the method that inlines the method being parsed by this context.
`private JavaTypeProfile`	`getProfileForTypeCheck(ResolvedJavaType type)`
`ValueNode`	`getReturnValue()`
`StampProvider`	`getStampProvider()`
`protected BytecodeStream`	`getStream()`
`ValueNode`	`getUnwindValue()`
`private boolean`	`gotoOrFallThroughAfterConstant(BciBlockMapping.BciBlock block)`
`private DispatchBeginNode`	`handleException(ValueNode exceptionObject, int bci)`
`void`	`handleReplacedInvoke(CallTargetNode.InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] args, boolean inlineEverything)` Handles an invocation that a plugin determines can replace the original invocation (i.e., the one for which the plugin was applied).
`private void`	`handleReturnBlock()`
`protected void`	`handleUnresolvedCheckCast(JavaType type, ValueNode object)`
`protected void`	`handleUnresolvedExceptionType(JavaType type)`
`protected void`	`handleUnresolvedInstanceOf(JavaType type, ValueNode object)`
`protected void`	`handleUnresolvedInvoke(JavaMethod javaMethod, CallTargetNode.InvokeKind invokeKind)`
`protected void`	`handleUnresolvedLoadConstant(JavaType type)`
`protected void`	`handleUnresolvedLoadField(JavaField field, ValueNode receiver)`
`protected void`	`handleUnresolvedNewInstance(JavaType type)`
`protected void`	`handleUnresolvedNewMultiArray(JavaType type, List<ValueNode> dims)`
`protected void`	`handleUnresolvedNewObjectArray(JavaType type, ValueNode length)`
`protected void`	`handleUnresolvedStoreField(JavaField field, ValueNode value, ValueNode receiver)`
`private void`	`handleUnwindBlock()`
`private boolean`	`inline(ResolvedJavaMethod targetMethod, ResolvedJavaMethod inlinedMethod, boolean isIntrinsic, ValueNode[] args)`
`private void`	`insertLoopEnds(FixedNode startInstruction)`
`private void`	`insertLoopExits(LoopBeginNode loopBegin, IdentityHashMap<LoopBeginNode,List<LoopBeginNode>> innerLoopsMap)`
`void`	`intrinsify(ResolvedJavaMethod targetMethod, ResolvedJavaMethod substitute, ValueNode[] args)` Intrinsifies an invocation of a given method by inlining the bytecodes of a given substitution method.
`protected boolean`	`isNeverExecutedCode(double probability)`
`private int`	`iterateBlock(BciBlockMapping.BciBlock[] blocks, BciBlockMapping.BciBlock block)`
`protected void`	`iterateBytecodesForBlock(BciBlockMapping.BciBlock block)`
`private int`	`iterateExplodedLoopHeader(BciBlockMapping.BciBlock[] blocks, BciBlockMapping.BciBlock header)`
`void`	`loadLocal(int index, Kind kind)`
`private Object`	`lookupConstant(int cpi, int opcode)`
`private JavaField`	`lookupField(int cpi, int opcode)`
`private JavaMethod`	`lookupMethod(int cpi, int opcode)`
`protected JavaType`	`lookupType(int cpi, int bytecode)`
`private void`	`maybeEagerlyResolve(int cpi, int bytecode)`
`(package private) static String`	`nSpaces(int n)`
`private void`	`parseAndInlineCallee(ResolvedJavaMethod targetMethod, ValueNode[] args, IntrinsicContext calleeIntrinsicContext)`
`boolean`	`parsingIntrinsic()` Determines if this parsing context is within the bytecode of an intrinsic or a method inlined by an intrinsic.
`private void`	`peelIteration(BciBlockMapping.BciBlock[] blocks, BciBlockMapping.BciBlock header, BytecodeParser.ExplodedLoopContext context)`
`protected void`	`processBlock(BytecodeParser parser, BciBlockMapping.BciBlock block)`
`void`	`processBytecode(int bci, int opcode)`
`void`	`push(Kind slotKind, ValueNode value)` Pushes a given value to the frame state stack using an explicit kind.
`protected void`	`reanchorGuardedNodes(BeginNode beginNode)` Removes `GuardedNode`s from `beginNode`'s usages and re-attaches them to an appropriate preceeding `GuardingNode`.
`<T extends ValueNode> T`	`recursiveAppend(T v)` Adds the given node to the graph and also adds recursively all referenced inputs.
`private boolean`	`returnAfterConstant(BciBlockMapping.BciBlock block)`
`void`	`setCurrentFrameState(FrameStateBuilder frameState)`
`private void`	`setEntryState(BciBlockMapping.BciBlock block, int dimension, FrameStateBuilder entryState)`
`private void`	`setEntryStateMultiDimension(int dimension, FrameStateBuilder entryState, int id)`
`private void`	`setFirstInstruction(BciBlockMapping.BciBlock block, int dimension, FixedWithNextNode firstInstruction)`
`private void`	`setFirstInstructionMultiDimension(int dimension, FixedWithNextNode firstInstruction, int id)`
`private void`	`setMergeStateAfter(BciBlockMapping.BciBlock block, FixedWithNextNode firstInstruction)`
`void`	`setStateAfter(StateSplit sideEffect)` Creates a snap shot of the current frame state with the BCI of the instruction after the one currently being parsed and assigns it to a given side effect node.
`void`	`storeLocal(Kind kind, int index)`
`private static double[]`	`successorProbabilites(int successorCount, int[] keySuccessors, double[] keyProbabilities)` Helper function that sums up the probabilities of all keys that lead to a specific successor.
`private double[]`	`switchProbability(int numberOfCases, int bci)`
`private void`	`synchronizedEpilogue(int bci, ValueNode currentReturnValue, Kind currentReturnValueKind)`
`private ValueNode`	`synchronizedObject(FrameStateBuilder state, ResolvedJavaMethod target)`
`String`	`toString()`
`protected boolean`	`traceInstruction(int bci, int opcode, boolean blockStart)`
`private void`	`traceInstructionHelper(int bci, int opcode, boolean blockStart)`
`private boolean`	`traceState()`
`protected void`	`traceWithContext(String format, Object... args)` Prints a line to `TTY` with a prefix indicating the current parse context.
`private boolean`	`tryGenConditionalForIf(BciBlockMapping.BciBlock trueBlock, BciBlockMapping.BciBlock falseBlock, LogicNode condition, int oldBci, int trueBlockInt, int falseBlockInt)`
`private boolean`	`tryInline(ValueNode[] args, ResolvedJavaMethod targetMethod, JavaType returnType)`
`private boolean`	`tryInvocationPlugin(ValueNode[] args, ResolvedJavaMethod targetMethod, Kind resultType)`
`private boolean`	`tryNodePluginForInvocation(ValueNode[] args, ResolvedJavaMethod targetMethod)`
`private <T extends ValueNode> void`	`updateLastInstruction(T v)`

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

Methods inherited from interface com.oracle.graal.graphbuilderconf.GraphBuilderContext
add, addPush, getAssumptions, getDepth, getInvokeReturnStamp, nullCheckedValue

Field Detail

TRACELEVEL_INSTRUCTIONS
```
public static final int TRACELEVEL_INSTRUCTIONS
```
The minimum value to which BytecodeParser.Options.TraceBytecodeParserLevel must be set to trace the bytecode instructions as they are parsed.

See Also:

Constant Field Values

TRACELEVEL_STATE
```
public static final int TRACELEVEL_STATE
```
The minimum value to which BytecodeParser.Options.TraceBytecodeParserLevel must be set to trace the frame state before each bytecode instruction as it is parsed.

See Also:

Constant Field Values

BytecodesParsed
```
public static final DebugMetric BytecodesParsed
```
Meters the number of actual bytecodes parsed.

EXPLICIT_EXCEPTIONS

protected static final DebugMetric EXPLICIT_EXCEPTIONS

graphBuilderInstance

private final GraphBuilderPhase.Instance graphBuilderInstance

graph
```
protected final StructuredGraph graph
```

blockMap
```
private BciBlockMapping blockMap
```

liveness
```
private LocalLiveness liveness
```

entryBCI
```
protected final int entryBCI
```

parent
```
private final BytecodeParser parent
```

lnt
```
private LineNumberTable lnt
```

previousLineNumber
```
private int previousLineNumber
```

currentLineNumber
```
private int currentLineNumber
```

methodSynchronizedObject

private ValueNode methodSynchronizedObject

returnValue
```
private ValueNode returnValue
```

beforeReturnNode

private FixedWithNextNode beforeReturnNode

unwindValue
```
private ValueNode unwindValue
```

beforeUnwindNode

private FixedWithNextNode beforeUnwindNode

lastInstr
```
private FixedWithNextNode lastInstr
```

explodeLoops
```
private final boolean explodeLoops
```

mergeExplosions
```
private final boolean mergeExplosions
```

mergeExplosionsMap

private final Map<FrameStateBuilder,Integer> mergeExplosionsMap

explodeLoopsContext

private Deque<BytecodeParser.ExplodedLoopContext> explodeLoopsContext

nextPeelIteration
```
private int nextPeelIteration
```

controlFlowSplit
```
private boolean controlFlowSplit
```

invocationPluginReceiver

private final InvocationPlugins.InvocationPluginReceiver invocationPluginReceiver

firstInstructionArray

private FixedWithNextNode[] firstInstructionArray

entryStateArray

private FrameStateBuilder[] entryStateArray

firstInstructionMatrix

private FixedWithNextNode[][] firstInstructionMatrix

entryStateMatrix

private FrameStateBuilder[][] entryStateMatrix

currentInvokeKind

private CallTargetNode.InvokeKind currentInvokeKind

currentInvokeReturnType

private JavaType currentInvokeReturnType

frameState
```
protected FrameStateBuilder frameState
```

currentBlock

protected BciBlockMapping.BciBlock currentBlock

stream
```
protected final BytecodeStream stream
```

graphBuilderConfig

protected final GraphBuilderConfiguration graphBuilderConfig

method

protected final ResolvedJavaMethod method

profilingInfo

protected final ProfilingInfo profilingInfo

optimisticOpts

protected final OptimisticOptimizations optimisticOpts

constantPool

protected final ConstantPool constantPool

metaAccess

protected final MetaAccessProvider metaAccess

constantReflection

private final ConstantReflectionProvider constantReflection

stampProvider

private final StampProvider stampProvider

intrinsicContext

protected final IntrinsicContext intrinsicContext

forceInliningEverything

private boolean forceInliningEverything

lastInlineInfo

InlineInvokePlugin.InlineInfo lastInlineInfo

Constructor Detail

BytecodeParser

protected BytecodeParser(GraphBuilderPhase.Instance graphBuilderInstance,
                         StructuredGraph graph,
                         BytecodeParser parent,
                         ResolvedJavaMethod method,
                         int entryBCI,
                         IntrinsicContext intrinsicContext)

Method Detail

getReturnValue
```
public ValueNode getReturnValue()
```

getBeforeReturnNode

public FixedWithNextNode getBeforeReturnNode()

getUnwindValue
```
public ValueNode getUnwindValue()
```

getBeforeUnwindNode

public FixedWithNextNode getBeforeUnwindNode()

buildRootMethod
```
protected void buildRootMethod()
```

build

protected void build(FixedWithNextNode startInstruction,
                     FrameStateBuilder startFrameState)

computeKindVerification

private boolean computeKindVerification(FrameStateBuilder startFrameState)

finishPrepare
```
protected void finishPrepare(FixedWithNextNode startInstr)
```
Hook for subclasses to modify the graph start instruction or append new instructions to it.

Parameters:

startInstr - the start instruction of the graph

cleanupFinalGraph
```
protected void cleanupFinalGraph()
```

reanchorGuardedNodes
```
protected void reanchorGuardedNodes(BeginNode beginNode)
```
Removes GuardedNodes from beginNode's usages and re-attaches them to an appropriate preceeding GuardingNode.

createStateAfterStartOfReplacementGraph
```
private FrameState createStateAfterStartOfReplacementGraph()
```
Creates the frame state after the start node of a graph for an intrinsic that is the parse root (either for root compiling or for post-parse inlining).

detectLoops

private void detectLoops(FixedNode startInstruction)

insertLoopEnds

private void insertLoopEnds(FixedNode startInstruction)

insertLoopExits

private void insertLoopExits(LoopBeginNode loopBegin,
                             IdentityHashMap<LoopBeginNode,List<LoopBeginNode>> innerLoopsMap)

addLoopExits

private void addLoopExits(LoopBeginNode loopBegin,
                          LoopBeginNode inner,
                          IdentityHashMap<LoopBeginNode,List<LoopBeginNode>> innerLoopsMap,
                          NodeBitMap visited)

iterateBlock

private int iterateBlock(BciBlockMapping.BciBlock[] blocks,
                         BciBlockMapping.BciBlock block)

iterateExplodedLoopHeader

private int iterateExplodedLoopHeader(BciBlockMapping.BciBlock[] blocks,
                                      BciBlockMapping.BciBlock header)

addToMergeCache

private void addToMergeCache(FrameStateBuilder key,
                             int dimension)

peelIteration

private void peelIteration(BciBlockMapping.BciBlock[] blocks,
                           BciBlockMapping.BciBlock header,
                           BytecodeParser.ExplodedLoopContext context)

handleUnresolvedLoadConstant
```
protected void handleUnresolvedLoadConstant(JavaType type)
```
Parameters:

type - the unresolved type of the constant

handleUnresolvedCheckCast

protected void handleUnresolvedCheckCast(JavaType type,
                                         ValueNode object)

Parameters:: type - the unresolved type of the type check; object - the object value whose type is being checked against type

handleUnresolvedInstanceOf

protected void handleUnresolvedInstanceOf(JavaType type,
                                          ValueNode object)

Parameters:: type - the unresolved type of the type check; object - the object value whose type is being checked against type

handleUnresolvedNewInstance
```
protected void handleUnresolvedNewInstance(JavaType type)
```
Parameters:

type - the type being instantiated

handleUnresolvedNewObjectArray

protected void handleUnresolvedNewObjectArray(JavaType type,
                                              ValueNode length)

Parameters:: type - the type of the array being instantiated; length - the length of the array

handleUnresolvedNewMultiArray

protected void handleUnresolvedNewMultiArray(JavaType type,
                                             List<ValueNode> dims)

Parameters:: type - the type being instantiated; dims - the dimensions for the multi-array

handleUnresolvedLoadField

protected void handleUnresolvedLoadField(JavaField field,
                                         ValueNode receiver)

Parameters:: field - the unresolved field; receiver - the object containing the field or null if field is static

handleUnresolvedStoreField

protected void handleUnresolvedStoreField(JavaField field,
                                          ValueNode value,
                                          ValueNode receiver)

Parameters:: field - the unresolved field; value - the value being stored to the field; receiver - the object containing the field or null if field is static

handleUnresolvedExceptionType

protected void handleUnresolvedExceptionType(JavaType type)

Parameters:: type -

handleUnresolvedInvoke

protected void handleUnresolvedInvoke(JavaMethod javaMethod,
                                      CallTargetNode.InvokeKind invokeKind)

Parameters:: javaMethod -; invokeKind -

handleException

private DispatchBeginNode handleException(ValueNode exceptionObject,
                                          int bci)

genLoadIndexed

protected ValueNode genLoadIndexed(ValueNode array,
                                   ValueNode index,
                                   Kind kind)

genStoreIndexed

protected void genStoreIndexed(ValueNode array,
                               ValueNode index,
                               Kind kind,
                               ValueNode value)

genIntegerAdd

protected ValueNode genIntegerAdd(ValueNode x,
                                  ValueNode y)

genIntegerSub

protected ValueNode genIntegerSub(ValueNode x,
                                  ValueNode y)

genIntegerMul

protected ValueNode genIntegerMul(ValueNode x,
                                  ValueNode y)

genFloatAdd

protected ValueNode genFloatAdd(ValueNode x,
                                ValueNode y)

genFloatSub

protected ValueNode genFloatSub(ValueNode x,
                                ValueNode y)

genFloatMul

protected ValueNode genFloatMul(ValueNode x,
                                ValueNode y)

genFloatDiv

protected ValueNode genFloatDiv(ValueNode x,
                                ValueNode y)

genFloatRem

protected ValueNode genFloatRem(ValueNode x,
                                ValueNode y)

genIntegerDiv

protected ValueNode genIntegerDiv(ValueNode x,
                                  ValueNode y)

genIntegerRem

protected ValueNode genIntegerRem(ValueNode x,
                                  ValueNode y)

genNegateOp

protected ValueNode genNegateOp(ValueNode x)

genLeftShift

protected ValueNode genLeftShift(ValueNode x,
                                 ValueNode y)

genRightShift

protected ValueNode genRightShift(ValueNode x,
                                  ValueNode y)

genUnsignedRightShift

protected ValueNode genUnsignedRightShift(ValueNode x,
                                          ValueNode y)

genAnd

protected ValueNode genAnd(ValueNode x,
                           ValueNode y)

genOr

protected ValueNode genOr(ValueNode x,
                          ValueNode y)

genXor

protected ValueNode genXor(ValueNode x,
                           ValueNode y)

genNormalizeCompare

protected ValueNode genNormalizeCompare(ValueNode x,
                                        ValueNode y,
                                        boolean isUnorderedLess)

genFloatConvert

protected ValueNode genFloatConvert(FloatConvert op,
                                    ValueNode input)

genNarrow

protected ValueNode genNarrow(ValueNode input,
                              int bitCount)

genSignExtend

protected ValueNode genSignExtend(ValueNode input,
                                  int bitCount)

genZeroExtend

protected ValueNode genZeroExtend(ValueNode input,
                                  int bitCount)

genGoto
```
protected void genGoto()
```

genObjectEquals

protected LogicNode genObjectEquals(ValueNode x,
                                    ValueNode y)

genIntegerEquals

protected LogicNode genIntegerEquals(ValueNode x,
                                     ValueNode y)

genIntegerLessThan

protected LogicNode genIntegerLessThan(ValueNode x,
                                       ValueNode y)

genUnique

protected ValueNode genUnique(ValueNode x)

genIfNode

protected ValueNode genIfNode(LogicNode condition,
                              FixedNode falseSuccessor,
                              FixedNode trueSuccessor,
                              double d)

genThrow
```
protected void genThrow()
```

createCheckCast

protected ValueNode createCheckCast(ResolvedJavaType type,
                                    ValueNode object,
                                    JavaTypeProfile profileForTypeCheck,
                                    boolean forStoreCheck)

createInstanceOf

protected ValueNode createInstanceOf(ResolvedJavaType type,
                                     ValueNode object,
                                     JavaTypeProfile profileForTypeCheck)

genConditional

protected ValueNode genConditional(ValueNode x)

createNewInstance

protected NewInstanceNode createNewInstance(ResolvedJavaType type,
                                            boolean fillContents)

createNewArray

protected NewArrayNode createNewArray(ResolvedJavaType elementType,
                                      ValueNode length,
                                      boolean fillContents)

createNewMultiArray

protected NewMultiArrayNode createNewMultiArray(ResolvedJavaType type,
                                                List<ValueNode> dimensions)

genLoadField

protected ValueNode genLoadField(ValueNode receiver,
                                 ResolvedJavaField field)

emitExplicitNullCheck

protected ValueNode emitExplicitNullCheck(ValueNode receiver)

emitExplicitBoundsCheck

protected void emitExplicitBoundsCheck(ValueNode index,
                                       ValueNode length)

genArrayLength

protected ValueNode genArrayLength(ValueNode x)

genStoreField

protected void genStoreField(ValueNode receiver,
                             ResolvedJavaField field,
                             ValueNode value)

callTargetIsResolved
```
private static boolean callTargetIsResolved(JavaMethod target)
```
Ensure that concrete classes are at least linked before generating an invoke. Interfaces may never be linked so simply return true for them.

Parameters:

target -

Returns:

true if the declared holder is an interface or is linked

genInvokeStatic

protected void genInvokeStatic(JavaMethod target)

genInvokeInterface

protected void genInvokeInterface(JavaMethod target)

genInvokeDynamic

protected void genInvokeDynamic(JavaMethod target)

genInvokeVirtual

protected void genInvokeVirtual(JavaMethod target)

genInvokeSpecial

protected void genInvokeSpecial(JavaMethod target)

getInvokeKind
```
public CallTargetNode.InvokeKind getInvokeKind()
```
Description copied from interface: GraphBuilderContext

Gets the kind of invocation currently being parsed.

Specified by:

getInvokeKind in interface GraphBuilderContext

getInvokeReturnType
```
public JavaType getInvokeReturnType()
```
Description copied from interface: GraphBuilderContext

Gets the return type of the invocation currently being parsed.

Specified by:

getInvokeReturnType in interface GraphBuilderContext

handleReplacedInvoke
```
public void handleReplacedInvoke(CallTargetNode.InvokeKind invokeKind,
                                 ResolvedJavaMethod targetMethod,
                                 ValueNode[] args,
                                 boolean inlineEverything)
```
Description copied from interface: GraphBuilderContext

Handles an invocation that a plugin determines can replace the original invocation (i.e., the one for which the plugin was applied). This applies all standard graph builder processing to the replaced invocation including applying any relevant plugins.

Specified by:

handleReplacedInvoke in interface GraphBuilderContext

Parameters:

invokeKind - the kind of the replacement invocation

targetMethod - the target of the replacement invocation

args - the arguments to the replacement invocation

inlineEverything - specifies if all invocations encountered in the scope of handling the replaced invoke are to be force inlined

appendInvoke

private void appendInvoke(CallTargetNode.InvokeKind initialInvokeKind,
                          ResolvedJavaMethod initialTargetMethod,
                          ValueNode[] args)

tryInvocationPlugin

private boolean tryInvocationPlugin(ValueNode[] args,
                                    ResolvedJavaMethod targetMethod,
                                    Kind resultType)

tryNodePluginForInvocation

private boolean tryNodePluginForInvocation(ValueNode[] args,
                                           ResolvedJavaMethod targetMethod)

tryInline

private boolean tryInline(ValueNode[] args,
                          ResolvedJavaMethod targetMethod,
                          JavaType returnType)

intrinsify
```
public void intrinsify(ResolvedJavaMethod targetMethod,
                       ResolvedJavaMethod substitute,
                       ValueNode[] args)
```
Description copied from interface: GraphBuilderContext

Intrinsifies an invocation of a given method by inlining the bytecodes of a given substitution method.

Specified by:

intrinsify in interface GraphBuilderContext

Parameters:

targetMethod - the method being intrinsified

substitute - the intrinsic implementation

args - the arguments with which to inline the invocation

inline

private boolean inline(ResolvedJavaMethod targetMethod,
                       ResolvedJavaMethod inlinedMethod,
                       boolean isIntrinsic,
                       ValueNode[] args)

traceWithContext

protected void traceWithContext(String format,
                                Object... args)

Prints a line to TTY with a prefix indicating the current parse context. The prefix is of the form:

 {SPACE * n} {name of method being parsed} "(" {file name} ":" {line number} ")"

where n is the current inlining depth.

Parameters:: format - a format string; args - arguments to the format string

asParserError

protected BytecodeParser.BytecodeParserError asParserError(Throwable e)

parseAndInlineCallee

private void parseAndInlineCallee(ResolvedJavaMethod targetMethod,
                                  ValueNode[] args,
                                  IntrinsicContext calleeIntrinsicContext)

createMethodCallTarget

protected MethodCallTargetNode createMethodCallTarget(CallTargetNode.InvokeKind invokeKind,
                                                      ResolvedJavaMethod targetMethod,
                                                      ValueNode[] args,
                                                      JavaType returnType,
                                                      JavaTypeProfile profile)

createInvoke

protected InvokeNode createInvoke(CallTargetNode callTarget,
                                  Kind resultType)

createInvokeWithException

protected InvokeWithExceptionNode createInvokeWithException(CallTargetNode callTarget,
                                                            Kind resultType)

genReturn

protected void genReturn(ValueNode returnVal,
                         Kind returnKind)

beforeReturn

private void beforeReturn(ValueNode x,
                          Kind kind)

genMonitorEnter

protected void genMonitorEnter(ValueNode x,
                               int bci)

genMonitorExit

protected void genMonitorExit(ValueNode x,
                              ValueNode escapedReturnValue,
                              int bci)

genJsr
```
protected void genJsr(int dest)
```

genRet

protected void genRet(int localIndex)

getJsrConstant

private ConstantNode getJsrConstant(long bci)

genIntegerSwitch

protected void genIntegerSwitch(ValueNode value,
                                ArrayList<BciBlockMapping.BciBlock> actualSuccessors,
                                int[] keys,
                                double[] keyProbabilities,
                                int[] keySuccessors)

successorProbabilites

private static double[] successorProbabilites(int successorCount,
                                              int[] keySuccessors,
                                              double[] keyProbabilities)

Helper function that sums up the probabilities of all keys that lead to a specific successor.

Returns:: an array of size successorCount with the accumulated probability for each successor.

appendConstant

protected ConstantNode appendConstant(JavaConstant constant)

append
```
public <T extends ValueNode> T append(T v)
```
Description copied from interface: GraphBuilderContext

Raw operation for adding a node to the graph when neither GraphBuilderContext.add(T) nor GraphBuilderContext.addPush(Kind, ValueNode) can be used.

Specified by:

append in interface GraphBuilderContext

Returns:

either the node added or an equivalent node

recursiveAppend
```
public <T extends ValueNode> T recursiveAppend(T v)
```
Description copied from interface: GraphBuilderContext

Adds the given node to the graph and also adds recursively all referenced inputs.

Specified by:

recursiveAppend in interface GraphBuilderContext

Parameters:

v - the node to be added to the graph

Returns:

either the node added or an equivalent node

updateLastInstruction

private <T extends ValueNode> void updateLastInstruction(T v)

checkLoopExit

private BytecodeParser.Target checkLoopExit(FixedNode target,
                                            BciBlockMapping.BciBlock targetBlock,
                                            FrameStateBuilder state)

getEntryState

private FrameStateBuilder getEntryState(BciBlockMapping.BciBlock block,
                                        int dimension)

getEntryStateMultiDimension

private FrameStateBuilder getEntryStateMultiDimension(int dimension,
                                                      int id)

setEntryState

private void setEntryState(BciBlockMapping.BciBlock block,
                           int dimension,
                           FrameStateBuilder entryState)

setEntryStateMultiDimension

private void setEntryStateMultiDimension(int dimension,
                                         FrameStateBuilder entryState,
                                         int id)

setFirstInstruction

private void setFirstInstruction(BciBlockMapping.BciBlock block,
                                 int dimension,
                                 FixedWithNextNode firstInstruction)

setFirstInstructionMultiDimension

private void setFirstInstructionMultiDimension(int dimension,
                                               FixedWithNextNode firstInstruction,
                                               int id)

getFirstInstruction

private FixedWithNextNode getFirstInstruction(BciBlockMapping.BciBlock block,
                                              int dimension)

getFirstInstructionMultiDimension

private FixedWithNextNode getFirstInstructionMultiDimension(int dimension,
                                                            int id)

createTarget

private FixedNode createTarget(double probability,
                               BciBlockMapping.BciBlock block,
                               FrameStateBuilder stateAfter)

createTarget

private FixedNode createTarget(BciBlockMapping.BciBlock block,
                               FrameStateBuilder state)

createTarget

private FixedNode createTarget(BciBlockMapping.BciBlock block,
                               FrameStateBuilder state,
                               boolean canReuseInstruction,
                               boolean canReuseState)

findOperatingDimension

private int findOperatingDimension(BciBlockMapping.BciBlock block,
                                   FrameStateBuilder state)

findOperatingDimensionWithLoopExplosion

private int findOperatingDimensionWithLoopExplosion(BciBlockMapping.BciBlock block,
                                                    FrameStateBuilder state)

createBlockTarget

private AbstractBeginNode createBlockTarget(double probability,
                                            BciBlockMapping.BciBlock block,
                                            FrameStateBuilder stateAfter)

Returns a block begin node with the specified state. If the specified probability is 0, the block deoptimizes immediately.

synchronizedObject

private ValueNode synchronizedObject(FrameStateBuilder state,
                                     ResolvedJavaMethod target)

processBlock

protected void processBlock(BytecodeParser parser,
                            BciBlockMapping.BciBlock block)

handleUnwindBlock
```
private void handleUnwindBlock()
```

handleReturnBlock
```
private void handleReturnBlock()
```

setMergeStateAfter

private void setMergeStateAfter(BciBlockMapping.BciBlock block,
                                FixedWithNextNode firstInstruction)

createUnwind
```
private void createUnwind()
```

synchronizedEpilogue

private void synchronizedEpilogue(int bci,
                                  ValueNode currentReturnValue,
                                  Kind currentReturnValueKind)

createExceptionDispatch

private void createExceptionDispatch(BciBlockMapping.ExceptionDispatchBlock block)

appendGoto

private void appendGoto(BciBlockMapping.BciBlock successor)

iterateBytecodesForBlock

protected void iterateBytecodesForBlock(BciBlockMapping.BciBlock block)

forceLoopPhis
```
protected boolean forceLoopPhis()
```

checkLastInstruction

protected boolean checkLastInstruction()

appendLoopBegin

private LoopBeginNode appendLoopBegin(FixedWithNextNode fixedWithNext)

finishInstruction
```
protected FixedWithNextNode finishInstruction(FixedWithNextNode instr,
                                              FrameStateBuilder state)
```
Hook for subclasses to modify the last instruction or add other instructions.

Parameters:

instr - The last instruction (= fixed node) which was added.

state - The current frame state.

Returns:

Returns the (new) last instruction.

genInfoPointNode

private void genInfoPointNode(InfopointReason reason,
                              ValueNode escapedReturnValue)

traceState
```
private boolean traceState()
```

genIf

protected void genIf(ValueNode x,
                     Condition cond,
                     ValueNode y)

tryGenConditionalForIf

private boolean tryGenConditionalForIf(BciBlockMapping.BciBlock trueBlock,
                                       BciBlockMapping.BciBlock falseBlock,
                                       LogicNode condition,
                                       int oldBci,
                                       int trueBlockInt,
                                       int falseBlockInt)

genConditionalForIf

private void genConditionalForIf(BciBlockMapping.BciBlock trueBlock,
                                 LogicNode condition,
                                 int oldBci,
                                 int trueBlockInt,
                                 int falseBlockInt,
                                 boolean genReturn)

createLogicNode

private LogicNode createLogicNode(Condition cond,
                                  ValueNode a,
                                  ValueNode b)

genConstantTargetIf

private void genConstantTargetIf(BciBlockMapping.BciBlock trueBlock,
                                 BciBlockMapping.BciBlock falseBlock,
                                 boolean negate,
                                 LogicNode condition)

checkPositiveIntConstantPushed

private int checkPositiveIntConstantPushed(BciBlockMapping.BciBlock block)

gotoOrFallThroughAfterConstant

private boolean gotoOrFallThroughAfterConstant(BciBlockMapping.BciBlock block)

returnAfterConstant

private boolean returnAfterConstant(BciBlockMapping.BciBlock block)

getStampProvider
```
public StampProvider getStampProvider()
```
Specified by:

getStampProvider in interface GraphBuilderContext

getMetaAccess
```
public MetaAccessProvider getMetaAccess()
```
Specified by:

getMetaAccess in interface GraphBuilderContext

push
```
public void push(Kind slotKind,
                 ValueNode value)
```
Description copied from interface: GraphBuilderContext

Pushes a given value to the frame state stack using an explicit kind. This should be used when value.getKind() is different from the kind that the bytecode instruction currently being parsed pushes to the stack.

Specified by:

push in interface GraphBuilderContext

Parameters:

slotKind - the kind to use when type checking this operation

value - the value to push to the stack. The value must already have been appended.

getCurrentDimension
```
private int getCurrentDimension()
```

getConstantReflection
```
public ConstantReflectionProvider getConstantReflection()
```
Specified by:

getConstantReflection in interface GraphBuilderContext

getGraph
```
public StructuredGraph getGraph()
```
Gets the graph being processed by this builder.

Specified by:

getGraph in interface GraphBuilderContext

getParent
```
public BytecodeParser getParent()
```
Description copied from interface: GraphBuilderContext

Gets the parsing context for the method that inlines the method being parsed by this context.

Specified by:

getParent in interface GraphBuilderContext

getIntrinsic
```
public IntrinsicContext getIntrinsic()
```
Description copied from interface: GraphBuilderContext

Gets the intrinsic of the current parsing context or null if not parsing an intrinsic.

Specified by:

getIntrinsic in interface GraphBuilderContext

toString
```
public String toString()
```
Overrides:

toString in class Object

bailout
```
public BailoutException bailout(String string)
```
Specified by:

bailout in interface GraphBuilderContext

createFrameState

private FrameState createFrameState(int bci,
                                    StateSplit forStateSplit)

setStateAfter
```
public void setStateAfter(StateSplit sideEffect)
```
Description copied from interface: GraphBuilderContext

Creates a snap shot of the current frame state with the BCI of the instruction after the one currently being parsed and assigns it to a given side effect node.

Specified by:

setStateAfter in interface GraphBuilderContext

Parameters:

sideEffect - a side effect node just appended to the graph

createBytecodePosition

private BytecodePosition createBytecodePosition()

setCurrentFrameState

public void setCurrentFrameState(FrameStateBuilder frameState)

getStream

protected final BytecodeStream getStream()

bci
```
public int bci()
```
Description copied from interface: GraphBuilderContext

Gets the index of the bytecode instruction currently being parsed.

Specified by:

bci in interface GraphBuilderContext

loadLocal

public void loadLocal(int index,
                      Kind kind)

storeLocal

public void storeLocal(Kind kind,
                       int index)

genLoadConstant

private void genLoadConstant(int cpi,
                             int opcode)

genLoadIndexed

private void genLoadIndexed(Kind kind)

genStoreIndexed

private void genStoreIndexed(Kind kind)

genArithmeticOp

private void genArithmeticOp(Kind kind,
                             int opcode)

genIntegerDivOp

private void genIntegerDivOp(Kind kind,
                             int opcode)

genNegateOp
```
private void genNegateOp(Kind kind)
```

genShiftOp

private void genShiftOp(Kind kind,
                        int opcode)

genLogicOp

private void genLogicOp(Kind kind,
                        int opcode)

genCompareOp

private void genCompareOp(Kind kind,
                          boolean isUnorderedLess)

genFloatConvert

private void genFloatConvert(FloatConvert op,
                             Kind from,
                             Kind to)

genSignExtend

private void genSignExtend(Kind from,
                           Kind to)

genZeroExtend

private void genZeroExtend(Kind from,
                           Kind to)

genNarrow

private void genNarrow(Kind from,
                       Kind to)

genIncrement
```
private void genIncrement()
```

genIfZero

private void genIfZero(Condition cond)

genIfNull

private void genIfNull(Condition cond)

genIfSame

private void genIfSame(Kind kind,
                       Condition cond)

lookupType

protected JavaType lookupType(int cpi,
                              int bytecode)

lookupMethod

private JavaMethod lookupMethod(int cpi,
                                int opcode)

lookupField

private JavaField lookupField(int cpi,
                              int opcode)

lookupConstant

private Object lookupConstant(int cpi,
                              int opcode)

maybeEagerlyResolve

private void maybeEagerlyResolve(int cpi,
                                 int bytecode)

getProfileForTypeCheck

private JavaTypeProfile getProfileForTypeCheck(ResolvedJavaType type)

genCheckCast
```
private void genCheckCast()
```

appendNullCheck

private ValueNode appendNullCheck(ValueNode object)

genInstanceOf
```
private void genInstanceOf()
```

genNewInstance
```
void genNewInstance(int cpi)
```

arrayTypeCodeToClass
```
private static Class<?> arrayTypeCodeToClass(int code)
```
Gets the kind of array elements for the array type code that appears in a Bytecodes.NEWARRAY bytecode.

Parameters:

code - the array type code

Returns:

the kind from the array type code

genNewPrimitiveArray

private void genNewPrimitiveArray(int typeCode)

genNewObjectArray

private void genNewObjectArray(int cpi)

genNewMultiArray

private void genNewMultiArray(int cpi)

genGetField

private void genGetField(JavaField field)

emitExplicitExceptions
```
protected ValueNode emitExplicitExceptions(ValueNode receiver,
                                           ValueNode index)
```
Parameters:

receiver - the receiver of an object based operation

index - the index of an array based operation that is to be tested for out of bounds. This is null for a non-array operation.

Returns:

the receiver value possibly modified to have a tighter stamp

genPutField

private void genPutField(JavaField field)

genGetStatic

private void genGetStatic(JavaField field)

genPutStatic

private void genPutStatic(JavaField field)

switchProbability

private double[] switchProbability(int numberOfCases,
                                   int bci)

allPositive

private static boolean allPositive(double[] a)

genSwitch

private void genSwitch(BytecodeSwitch bs)

isNeverExecutedCode

protected boolean isNeverExecutedCode(double probability)

branchProbability
```
protected double branchProbability()
```

assertAtIfBytecode
```
private boolean assertAtIfBytecode()
```

processBytecode

public final void processBytecode(int bci,
                                  int opcode)

genArrayLength
```
private void genArrayLength()
```

getMethod
```
public ResolvedJavaMethod getMethod()
```
Description copied from interface: GraphBuilderContext

Gets the method being parsed by this context.

Specified by:

getMethod in interface GraphBuilderContext

getFrameStateBuilder

public FrameStateBuilder getFrameStateBuilder()

traceInstruction

protected boolean traceInstruction(int bci,
                                   int opcode,
                                   boolean blockStart)

traceInstructionHelper

private void traceInstructionHelper(int bci,
                                    int opcode,
                                    boolean blockStart)

parsingIntrinsic
```
public boolean parsingIntrinsic()
```
Description copied from interface: GraphBuilderContext

Determines if this parsing context is within the bytecode of an intrinsic or a method inlined by an intrinsic.

Specified by:

parsingIntrinsic in interface GraphBuilderContext

getNonIntrinsicAncestor
```
public BytecodeParser getNonIntrinsicAncestor()
```
Description copied from interface: GraphBuilderContext

Gets the first ancestor parsing context that is not parsing a intrinsic.

Specified by:

getNonIntrinsicAncestor in interface GraphBuilderContext

nSpaces
```
static String nSpaces(int n)
```

assertionsEnabled

private static boolean assertionsEnabled()

Class BytecodeParser

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.oracle.graal.graphbuilderconf.GraphBuilderContext

Field Detail

TRACELEVEL_INSTRUCTIONS

TRACELEVEL_STATE

BytecodesParsed

EXPLICIT_EXCEPTIONS

graphBuilderInstance

graph

blockMap

liveness

entryBCI

parent

lnt

previousLineNumber

currentLineNumber

methodSynchronizedObject

returnValue

beforeReturnNode

unwindValue

beforeUnwindNode

lastInstr

explodeLoops

mergeExplosions

mergeExplosionsMap

explodeLoopsContext

nextPeelIteration

controlFlowSplit

invocationPluginReceiver

firstInstructionArray

entryStateArray

firstInstructionMatrix

entryStateMatrix

currentInvokeKind

currentInvokeReturnType

frameState

currentBlock

stream

graphBuilderConfig

method

profilingInfo

optimisticOpts

constantPool

metaAccess

constantReflection

stampProvider

intrinsicContext

forceInliningEverything

lastInlineInfo

Constructor Detail

BytecodeParser

Method Detail

getReturnValue

getBeforeReturnNode

getUnwindValue

getBeforeUnwindNode

buildRootMethod

build

computeKindVerification

finishPrepare

cleanupFinalGraph

reanchorGuardedNodes

createStateAfterStartOfReplacementGraph

detectLoops

insertLoopEnds

insertLoopExits

addLoopExits

iterateBlock

iterateExplodedLoopHeader

addToMergeCache

peelIteration

handleUnresolvedLoadConstant

handleUnresolvedCheckCast

handleUnresolvedInstanceOf

handleUnresolvedNewInstance