FrameStateBuilder

java.lang.Object
- org.graalvm.compiler.java.FrameStateBuilder

All Implemented Interfaces:: IntrinsicContext.SideEffectsState

public final class FrameStateBuilder
extends Object
implements IntrinsicContext.SideEffectsState

Field Summary

Fields
Modifier and Type Field and Description

protected ValueNode[] locals

protected ValueNode[] stack

Fields
Modifier and Type	Field and Description
`protected ValueNode[]`	`locals`
`protected ValueNode[]`	`stack`

Constructor Summary

Constructors
Constructor and Description
`FrameStateBuilder(GraphBuilderTool tool, Bytecode code, StructuredGraph graph, boolean shouldRetainLocalVariables)` Creates a new frame state builder for the given code attribute, method and the given target graph.
`FrameStateBuilder(GraphBuilderTool tool, ResolvedJavaMethod method, StructuredGraph graph)` Creates a new frame state builder for the given method and the given target graph.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addSideEffect(StateSplit sideEffect)` Records a side effect for the current program point.
`void`	`checkCompatibleWith(FrameStateBuilder other)` Checks invariants that must hold when merging `other` into this frame state.
`void`	`clearLocals()` Clears all local variables.
`void`	`clearNonLiveLocals(BciBlockMapping.BciBlock block, LocalLiveness liveness, boolean liveIn)`
`void`	`clearStack()` Clears all values on this stack.
`boolean`	`contains(ValueNode value)`
`FrameStateBuilder`	`copy()`
`FrameState`	`create(int bci, BytecodeParser parent, boolean duringCall, JavaKind[] pushedSlotKinds, ValueNode[] pushedValues)`
`FrameState`	`create(int bci, StateSplit forStateSplit)`
`NodeSourcePosition`	`createBytecodePosition(int bci)`
`FrameState`	`createInitialIntrinsicFrameState(ResolvedJavaMethod original)`
`void`	`disableKindVerification()`
`boolean`	`equals(Object otherObject)`
`ResolvedJavaMethod`	`getMethod()`
`int`	`hashCode()`
`void`	`inferPhiStamps(AbstractMergeNode block)`
`void`	`initializeForMethodStart(Assumptions assumptions, boolean eagerResolve, GraphBuilderConfiguration.Plugins plugins)`
`void`	`initializeFromArgumentsArray(ValueNode[] arguments)`
`void`	`insertLoopPhis(LocalLiveness liveness, int loopId, LoopBeginNode loopBegin, boolean forcePhis, boolean stampFromValueForForcedPhis)`
`void`	`insertLoopProxies(LoopExitNode loopExit, FrameStateBuilder loopEntryState)`
`void`	`insertProxies(Function<ValueNode,ValueNode> proxyFunction)`
`boolean`	`isAfterSideEffect()` Determines if the current program point is preceded by one or more side effects.
`ValueNode`	`loadLocal(int i, JavaKind slotKind)` Loads the local variable at the specified index, checking that the returned value is non-null and that two-stack values are properly handled.
`int`	`localsSize()` Returns the size of the local variables.
`int`	`lockDepth(boolean includeParents)`
`void`	`merge(AbstractMergeNode block, FrameStateBuilder other)`
`MonitorIdNode`	`peekMonitorId()`
`ValueNode`	`peekObject()`
`ValueNode`	`pop(JavaKind slotKind)` Pops an instruction off the stack with the expected type.
`ValueNode[]`	`popArguments(int argSize)` Pop the specified number of slots off of this stack and return them as an array of instructions.
`ValueNode`	`popLock()` Removes a locked monitor from this frame state.
`void`	`push(JavaKind slotKind, ValueNode x)` Pushes an instruction onto the stack with the expected type.
`void`	`pushLock(ValueNode object, MonitorIdNode monitorId)` Adds a locked monitor to this frame state.
`void`	`pushReturn(JavaKind slotKind, ValueNode x)`
`void`	`replaceValue(ValueNode oldValue, ValueNode newValue)`
`boolean`	`rethrowException()`
`void`	`setRethrowException(boolean b)`
`Iterable<StateSplit>`	`sideEffects()` Gets the side effects preceding the current program point.
`void`	`stackOp(int opcode)` Performs a raw stack operation as defined in the Java bytecode specification.
`int`	`stackSize()` Gets the current size (height) of the stack.
`void`	`storeLocal(int i, JavaKind slotKind, ValueNode x)` Stores a given local variable at the specified index.
`String`	`toString()`

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

- Field Detail
  - locals
```
protected final ValueNode[] locals
```
  - stack
```
protected final ValueNode[] stack
```
- Constructor Detail
  - FrameStateBuilder
```
public FrameStateBuilder(GraphBuilderTool tool,
                         ResolvedJavaMethod method,
                         StructuredGraph graph)
```
    Creates a new frame state builder for the given method and the given target graph.
    
    Parameters:
    
    method - the method whose frame is simulated
    
    graph - the target graph of Graal nodes created by the builder
  - FrameStateBuilder
```
public FrameStateBuilder(GraphBuilderTool tool,
                         Bytecode code,
                         StructuredGraph graph,
                         boolean shouldRetainLocalVariables)
```
    Creates a new frame state builder for the given code attribute, method and the given target graph. Additionally specifies if nonLiveLocals should be retained.
    
    Parameters:
    
    code - the bytecode in which the frame exists
    
    graph - the target graph of Graal nodes created by the builder
    
    shouldRetainLocalVariables - specifies if nonLiveLocals should be retained in state.
- Method Detail
  - disableKindVerification
```
public void disableKindVerification()
```
  - initializeFromArgumentsArray
```
public void initializeFromArgumentsArray(ValueNode[] arguments)
```
  - initializeForMethodStart
```
public void initializeForMethodStart(Assumptions assumptions,
                                     boolean eagerResolve,
                                     GraphBuilderConfiguration.Plugins plugins)
```
  - getMethod
```
public ResolvedJavaMethod getMethod()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - create
```
public FrameState create(int bci,
                         StateSplit forStateSplit)
```
  - create
```
public FrameState create(int bci,
                         BytecodeParser parent,
                         boolean duringCall,
                         JavaKind[] pushedSlotKinds,
                         ValueNode[] pushedValues)
```
    Parameters:
    
    pushedValues - if non-null, values to FrameStateBuilder.push(JavaKind, ValueNode) to the stack before creating the FrameState
  - createBytecodePosition
```
public NodeSourcePosition createBytecodePosition(int bci)
```
  - copy
```
public FrameStateBuilder copy()
```
  - checkCompatibleWith
```
public void checkCompatibleWith(FrameStateBuilder other)
```
    Checks invariants that must hold when merging other into this frame state.
    
    Parameters:
    
    other -
    
    Throws:
    
    PermanentBailoutException - if the frame states are incompatible with respect to their locked objects. This indicates bytecode that has unstructured or unbalanced locks.
    
    GraalError - if the frame states are incompatible in terms of FrameStateBuilder.rethrowException or stack slots
  - merge
```
public void merge(AbstractMergeNode block,
                  FrameStateBuilder other)
```
  - inferPhiStamps
```
public void inferPhiStamps(AbstractMergeNode block)
```
  - insertLoopPhis
```
public void insertLoopPhis(LocalLiveness liveness,
                           int loopId,
                           LoopBeginNode loopBegin,
                           boolean forcePhis,
                           boolean stampFromValueForForcedPhis)
```
  - insertLoopProxies
```
public void insertLoopProxies(LoopExitNode loopExit,
                              FrameStateBuilder loopEntryState)
```
  - insertProxies
```
public void insertProxies(Function<ValueNode,ValueNode> proxyFunction)
```
  - pushLock
```
public void pushLock(ValueNode object,
                     MonitorIdNode monitorId)
```
    Adds a locked monitor to this frame state.
    
    Parameters:
    
    object - the object whose monitor will be locked.
  - popLock
```
public ValueNode popLock()
```
    Removes a locked monitor from this frame state.
    
    Returns:
    
    the object whose monitor was removed from the locks list.
  - peekMonitorId
```
public MonitorIdNode peekMonitorId()
```
  - lockDepth
```
public int lockDepth(boolean includeParents)
```
    Returns:
    
    the current lock depth
  - contains
```
public boolean contains(ValueNode value)
```
  - clearNonLiveLocals
```
public void clearNonLiveLocals(BciBlockMapping.BciBlock block,
                               LocalLiveness liveness,
                               boolean liveIn)
```
  - clearLocals
```
public void clearLocals()
```
    Clears all local variables.
  - rethrowException
```
public boolean rethrowException()
```
    See Also:
    
    BytecodeFrame.rethrowException
  - setRethrowException
```
public void setRethrowException(boolean b)
```
    See Also:
    
    BytecodeFrame.rethrowException
  - localsSize
```
public int localsSize()
```
    Returns the size of the local variables.
    
    Returns:
    
    the size of the local variables
  - stackSize
```
public int stackSize()
```
    Gets the current size (height) of the stack.
  - loadLocal
```
public ValueNode loadLocal(int i,
                           JavaKind slotKind)
```
    Loads the local variable at the specified index, checking that the returned value is non-null and that two-stack values are properly handled.
    
    Parameters:
    
    i - the index of the local variable to load
    
    slotKind - the kind of the local variable from the point of view of the bytecodes
    
    Returns:
    
    the instruction that produced the specified local
  - storeLocal
```
public void storeLocal(int i,
                       JavaKind slotKind,
                       ValueNode x)
```
    Stores a given local variable at the specified index. If the value occupies two slots, then the next local variable index is also overwritten.
    
    Parameters:
    
    i - the index at which to store
    
    slotKind - the kind of the local variable from the point of view of the bytecodes
    
    x - the instruction which produces the value for the local
  - push
```
public void push(JavaKind slotKind,
                 ValueNode x)
```
    Pushes an instruction onto the stack with the expected type.
    
    Parameters:
    
    slotKind - the kind of the stack element from the point of view of the bytecodes
    
    x - the instruction to push onto the stack
  - pushReturn
```
public void pushReturn(JavaKind slotKind,
                       ValueNode x)
```
  - pop
```
public ValueNode pop(JavaKind slotKind)
```
    Pops an instruction off the stack with the expected type.
    
    Parameters:
    
    slotKind - the kind of the stack element from the point of view of the bytecodes
    
    Returns:
    
    the instruction on the top of the stack
  - peekObject
```
public ValueNode peekObject()
```
  - popArguments
```
public ValueNode[] popArguments(int argSize)
```
    Pop the specified number of slots off of this stack and return them as an array of instructions.
    
    Returns:
    
    an array containing the arguments off of the stack
  - clearStack
```
public void clearStack()
```
    Clears all values on this stack.
  - stackOp
```
public void stackOp(int opcode)
```
    Performs a raw stack operation as defined in the Java bytecode specification.
    
    Parameters:
    
    opcode - The Java bytecode.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object otherObject)
```
    Overrides:
    
    equals in class Object
  - isAfterSideEffect
```
public boolean isAfterSideEffect()
```
    Description copied from interface: IntrinsicContext.SideEffectsState
    
    Determines if the current program point is preceded by one or more side effects.
    
    Specified by:
    
    isAfterSideEffect in interface IntrinsicContext.SideEffectsState
  - sideEffects
```
public Iterable<StateSplit> sideEffects()
```
    Description copied from interface: IntrinsicContext.SideEffectsState
    
    Gets the side effects preceding the current program point.
    
    Specified by:
    
    sideEffects in interface IntrinsicContext.SideEffectsState
  - addSideEffect
```
public void addSideEffect(StateSplit sideEffect)
```
    Description copied from interface: IntrinsicContext.SideEffectsState
    
    Records a side effect for the current program point.
    
    Specified by:
    
    addSideEffect in interface IntrinsicContext.SideEffectsState
  - replaceValue
```
public void replaceValue(ValueNode oldValue,
                         ValueNode newValue)
```
  - createInitialIntrinsicFrameState
```
public FrameState createInitialIntrinsicFrameState(ResolvedJavaMethod original)
```

Class FrameStateBuilder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

locals

stack

Constructor Detail

FrameStateBuilder

FrameStateBuilder

Method Detail

disableKindVerification

initializeFromArgumentsArray

initializeForMethodStart

getMethod

toString

create

create

createBytecodePosition

copy

checkCompatibleWith

merge

inferPhiStamps

insertLoopPhis

insertLoopProxies

insertProxies

pushLock

popLock

peekMonitorId

lockDepth

contains

clearNonLiveLocals

clearLocals

rethrowException

setRethrowException

localsSize

stackSize

loadLocal

storeLocal

push

pushReturn

pop

peekObject

popArguments

clearStack

stackOp

hashCode

equals

isAfterSideEffect

sideEffects

addSideEffect

replaceValue

createInitialIntrinsicFrameState