StackFrame

java.lang.Object
- gov.nasa.jpf.vm.StackFrame

All Implemented Interfaces:

java.lang.Cloneable

Direct Known Subclasses:

DirectCallStackFrame, JVMStackFrame, NativeStackFrame
```
public abstract class StackFrame
extends java.lang.Object
implements java.lang.Cloneable
```
Describes callerSlots stack frame. Java methods always have bounded local and operand stack sizes, computed at compile time, stored in the classfile, and checked at runtime by the bytecode verifier. Consequently, we combine locals and operands in one data structure with the following layout slot[0] : 'this' .. .. local vars slot[stackBase-1] : last local var slot[stackBase] : first operand slot .. ^ .. | operand stack range .. v slot[top] : highest used operand slot

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ATTR_IS_FROZEN` this StackFrame is not allowed to be modified anymore because it has been state stored.
`protected int`	`attributes` state management related attributes similar to ElementInfo.
`protected java.lang.Object[]`	`attrs`
`protected java.lang.Object`	`frameAttr`
`protected FixedBitSet`	`isRef`
`protected MethodInfo`	`mi`
`protected Instruction`	`pc`
`protected StackFrame`	`prev` the previous StackFrame (usually the caller, null if first).
`protected int[]`	`slots`
`protected int`	`stackBase`
`protected int`	`thisRef`
`protected int`	`top`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`StackFrame()` Creates an empty stack frame.
`protected`	`StackFrame(int nLocals, int nOperands)` creates callerSlots dummy Stackframe for testing of operand/local operations NOTE - TESTING ONLY! this does not have a MethodInfo
	`StackFrame(MethodInfo callee)`
`protected`	`StackFrame(MethodInfo callee, int nLocals, int nOperands)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addFrameAttr(java.lang.Object attr)`
`void`	`addLocalAttr(int index, java.lang.Object attr)`
`void`	`addLongLocalAttr(int index, java.lang.Object a)`
`void`	`addLongOperandAttr(java.lang.Object a)`
`void`	`addOperandAttr(int offset, java.lang.Object a)`
`void`	`addOperandAttr(java.lang.Object a)`
`void`	`addSlotAttr(int i, java.lang.Object a)`
`void`	`advancePC()`
`protected void`	`checkIsModifiable()`
`void`	`clearOperandStack()`
`StackFrame`	`clone()`
`protected FixedBitSet`	`createReferenceMap(int nSlots)`
`void`	`defreeze()`
`void`	`dup_x1()`
`void`	`dup_x2()`
`void`	`dup()`
`void`	`dup2_x1()`
`void`	`dup2_x2()`
`void`	`dup2()`
`boolean`	`equals(java.lang.Object o)`
`ObjectList.Iterator`	`frameAttrIterator()`
`<T> ObjectList.TypedIterator<T>`	`frameAttrIterator(java.lang.Class<T> attrType)`
`void`	`freeze()`
`<T> T`	`getAndResetFrameAttr(java.lang.Class<T> attrType)`
`java.lang.Object[]`	`getArgumentAttrs(MethodInfo miCallee)` return an array of all argument attrs, which in turn can be lists.
`java.lang.Object[]`	`getArgumentsValues(ThreadInfo ti, byte[] argTypes)`
`java.lang.Object[]`	`getArgumentValues(ThreadInfo ti)` this retrieves the argument values from the caller, i.e.
`java.lang.Object[]`	`getCallArguments(ThreadInfo ti)` get the arguments of the executed call Note - this throws an exception if the StackFrame pc is not an InvokeInstruction
`int`	`getCalleeThis(int size)` return reference of called object in the context of the caller (i.e.
`int`	`getCalleeThis(MethodInfo mi)` return the object reference for an instance method to be called (we are still in the caller's frame).
`StackFrame`	`getCallerFrame()`
`ClassInfo`	`getClassInfo()`
`java.lang.String`	`getClassName()`
`int`	`getDepth()`
`double`	`getDoubleLocalVariable(int idx)`
`double`	`getDoubleLocalVariable(java.lang.String name)`
`double`	`getDoubleResult()`
`java.lang.Object`	`getDoubleResultAttr()`
`int`	`getExceptionReference()`
`java.lang.Object`	`getExceptionReferenceAttribute()`
`java.lang.Object`	`getFieldValue(java.lang.String id)`
`float`	`getFloatLocalVariable(int idx)`
`float`	`getFloatResult()`
`java.lang.Object`	`getFloatResultAttr()`
`java.lang.Object`	`getFrameAttr()` this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList
`<T> T`	`getFrameAttr(java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`int`	`getLine()`
`java.lang.Object`	`getLocalAttr(int index)` this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList
`<T> T`	`getLocalAttr(int index, java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`int`	`getLocalAttrIndex(java.lang.Class<?> attrType, int startIdx)` helper to quickly find out if any of the locals slots holds an attribute of the provided type
`java.lang.Object`	`getLocalOrFieldValue(java.lang.String id)`
`java.lang.Object`	`getLocalValueObject(LocalVarInfo lv)`
`int`	`getLocalVariable(int i)`
`int`	`getLocalVariable(java.lang.String name)`
`int`	`getLocalVariableCount()`
`int`	`getLocalVariableSlotIndex(java.lang.String name)`
`java.lang.String`	`getLocalVariableType(int idx)`
`java.lang.String`	`getLocalVariableType(java.lang.String name)`
`LocalVarInfo`	`getLocalVarInfo(int idx)`
`LocalVarInfo`	`getLocalVarInfo(java.lang.String name)`
`LocalVarInfo[]`	`getLocalVars()` <2do> - this should return only LocalVarInfo for the current pc
`java.lang.Object`	`getLongLocalAttr(int index)`
`long`	`getLongLocalVariable(int idx)`
`long`	`getLongLocalVariable(java.lang.String name)`
`java.lang.Object`	`getLongOperandAttr()` this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList
`<T> T`	`getLongOperandAttr(java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`long`	`getLongResult()`
`java.lang.Object`	`getLongResultAttr()`
`MethodInfo`	`getMethodInfo()`
`java.lang.String`	`getMethodName()`
`<T> T`	`getNextFrameAttr(java.lang.Class<T> attrType, java.lang.Object prev)`
`<T> T`	`getNextLocalAttr(int index, java.lang.Class<T> attrType, java.lang.Object prev)`
`<T> T`	`getNextLongOperandAttr(java.lang.Class<T> attrType, java.lang.Object prev)`
`<T> T`	`getNextOperandAttr(java.lang.Class<T> attrType, java.lang.Object prev)`
`<T> T`	`getNextOperandAttr(int offset, java.lang.Class<T> attrType, java.lang.Object prev)`
`java.lang.Object`	`getOperandAttr()` this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList
`<T> T`	`getOperandAttr(java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`java.lang.Object`	`getOperandAttr(int offset)` this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList
`<T> T`	`getOperandAttr(int offset, java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`Instruction`	`getPC()`
`StackFrame`	`getPrevious()`
`FixedBitSet`	`getReferenceMap()`
`int`	`getReferenceResult()`
`int`	`getResult()`
`java.lang.Object`	`getResultAttr()`
`int`	`getSlot(int idx)`
`java.lang.Object`	`getSlotAttr(int i)`
`<T> T`	`getSlotAttr(int i, java.lang.Class<T> attrType)`
`java.lang.Object[]`	`getSlotAttrs()`
`int[]`	`getSlots()`
`java.lang.String`	`getSourceFile()`
`java.lang.String`	`getStackTraceInfo()`
`int`	`getThis()` if this is an instance method, return the reference of the corresponding object (note this only has to be in slot 0 upon entry)
`int`	`getTopPos()`
`boolean`	`hasAnyRef()`
`boolean`	`hasArgumentAttr(MethodInfo miCallee, java.lang.Class<?> attrType)` check if there is any argument attr of the provided type on the operand stack this is far more efficient than retrieving attribute values (we don't care for argument types)
`boolean`	`hasArgumentObjectAttr(ThreadInfo ti, MethodInfo miCallee, java.lang.Class<?> type)`
`boolean`	`hasAttrs()`
`boolean`	`hasFrameAttr()`
`boolean`	`hasFrameAttr(java.lang.Class<?> attrType)`
`boolean`	`hasFrameAttrValue(java.lang.Object a)`
`protected void`	`hash(HashData hd)`
`int`	`hashCode()`
`boolean`	`hasLocalAttr(int index)`
`boolean`	`hasLocalAttr(int index, java.lang.Class<?> type)`
`boolean`	`hasLongOperandAttr()`
`boolean`	`hasLongOperandAttr(java.lang.Class<?> type)`
`boolean`	`hasOperandAttr()`
`boolean`	`hasOperandAttr(java.lang.Class<?> type)`
`boolean`	`hasOperandAttr(int offset)`
`boolean`	`hasOperandAttr(int offset, java.lang.Class<?> type)`
`boolean`	`includesReferenceOperand(int objRef)` does any of the operand slots hold callerSlots reference value of 'objRef'
`boolean`	`includesReferenceOperand(int nTopSlots, int objRef)` does any of the 'nTopSlots' hold callerSlots reference value of 'objRef' 'nTopSlots' is usually obtained from MethodInfo.getNumberOfCallerStackSlots()
`boolean`	`isDirectCallFrame()`
`boolean`	`isFirewall()`
`boolean`	`isFrozen()`
`boolean`	`isLocalVariableRef(int idx)`
`boolean`	`isNative()`
`boolean`	`isOperandRef()`
`boolean`	`isOperandRef(int offset)`
`boolean`	`isReferenceSlot(int idx)`
`boolean`	`isReflection()`
`boolean`	`isSynthetic()`
`ObjectList.Iterator`	`localAttrIterator(int index)`
`<T> ObjectList.TypedIterator<T>`	`localAttrIterator(int index, java.lang.Class<T> attrType)`
`ObjectList.Iterator`	`longOperandAttrIterator()`
`<T> ObjectList.TypedIterator<T>`	`longOperandAttrIterator(java.lang.Class<T> attrType)`
`void`	`markThreadRoots(Heap heap, int tid)` mark all objects reachable from local or operand stack positions containing references.
`int`	`mixinExecutionStateHash(int h)`
`boolean`	`modifiesState()` is this StackFrame modifying the KernelState this is true unless this is callerSlots NativeStackFrame
`protected int`	`objectHashCode()`
`java.util.Iterator`	`operandAttrIterator()`
`<T> java.util.Iterator<T>`	`operandAttrIterator(java.lang.Class<T> attrType)`
`ObjectList.Iterator`	`operandAttrIterator(int offset)`
`<T> ObjectList.TypedIterator<T>`	`operandAttrIterator(int offset, java.lang.Class<T> attrType)`
`boolean`	`originatesFrom(StackFrame other)` to be used to check if a StackFrame got cloned due to its execution changing attributes and/or slots, but otherwise represents the same execution
`int`	`peek()`
`int`	`peek(int offset)`
`double`	`peekDouble()`
`double`	`peekDouble(int offset)`
`float`	`peekFloat()`
`float`	`peekFloat(int offset)`
`long`	`peekLong()`
`long`	`peekLong(int offset)`
`int`	`pop()`
`void`	`pop(int n)`
`double`	`popDouble()`
`float`	`popFloat()`
`long`	`popLong()`
`protected void`	`printContentsOn(java.io.PrintWriter pw)`
`void`	`printOperands(java.io.PrintStream pw)`
`void`	`printSlots(java.io.PrintStream ps)`
`void`	`printStackContent()` this includes locals and pc
`void`	`printStackTrace()`
`void`	`processRefArguments(MethodInfo miCallee, ReferenceProcessor visitor)` generic visitor for reference arguments
`void`	`push(int v)`
`void`	`push(int v, boolean ref)`
`void`	`pushDouble(double v)`
`void`	`pushFloat(float v)`
`void`	`pushLocal(int index)`
`void`	`pushLong(long v)`
`void`	`pushLongLocal(int index)`
`void`	`pushRef(int ref)`
`void`	`removeArguments(MethodInfo mi)`
`void`	`removeFrameAttr(java.lang.Object attr)`
`void`	`removeLocalAttr(int index, java.lang.Object attr)`
`void`	`removeLongOperandAttr(java.lang.Object a)`
`void`	`removeOperandAttr(int offset, java.lang.Object a)`
`void`	`removeOperandAttr(java.lang.Object a)`
`void`	`replaceFrameAttr(java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceLocalAttr(int index, java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceLongOperandAttr(java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceOperandAttr(int offset, java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceOperandAttr(java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceSlotAttr(int i, java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`reset()` re-execute method from the beginning - use with care
`abstract void`	`setArgumentLocal(int idx, int value, java.lang.Object attr)`
`void`	`setDoubleArgumentLocal(int idx, double value, java.lang.Object attr)`
`void`	`setDoubleLocalVariable(int index, double f)`
`void`	`setExceptionReference(int exRef)`
`void`	`setExceptionReferenceAttribute(java.lang.Object attr)`
`void`	`setFloatArgumentLocal(int idx, float value, java.lang.Object attr)`
`void`	`setFloatLocalVariable(int index, float f)`
`void`	`setFrameAttr(java.lang.Object attr)` this replaces all of them - use only if you know there are no SystemAttributes in the list (which would cause an exception)
`void`	`setLocalAttr(int index, java.lang.Object a)` this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()
`void`	`setLocalReferenceVariable(int index, int ref)`
`void`	`setLocalVariable(int index, int v)`
`void`	`setLocalVariable(int index, int v, boolean ref)`
`abstract void`	`setLongArgumentLocal(int idx, long value, java.lang.Object attr)`
`void`	`setLongLocalAttr(int index, java.lang.Object a)`
`void`	`setLongLocalVariable(int index, long v)`
`void`	`setLongOperandAttr(java.lang.Object a)` this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()
`void`	`setOperand(int offset, int v, boolean isRefValue)`
`void`	`setOperandAttr(int offset, java.lang.Object a)` this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()
`void`	`setOperandAttr(java.lang.Object a)` this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()
`void`	`setPC(Instruction newpc)`
`void`	`setPrevious(StackFrame frame)` to be set (by ThreadInfo) when the frame is pushed.
`abstract void`	`setReferenceArgumentLocal(int idx, int ref, java.lang.Object attr)`
`void`	`setReferenceResult(int ref, java.lang.Object attr)`
`void`	`setReflection()`
`void`	`setResult(int r, java.lang.Object attr)`
`void`	`setResult(long r, java.lang.Object attr)`
`void`	`setSlotAttr(int i, java.lang.Object a)`
`void`	`setThis(int objRef)`
`void`	`storeLongOperand(int index)`
`void`	`storeOperand(int index)`
`void`	`swap()`
`java.lang.String`	`toString()`
`void`	`visitReferenceSlots(ReferenceProcessor visitor)`

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

Field Detail
- ATTR_IS_FROZEN
```
public static final int ATTR_IS_FROZEN
```
  this StackFrame is not allowed to be modified anymore because it has been state stored. Set during state storage and checked upon each modification, causing exceptions on attempts to modify callerSlots frozen instance. The flag is reset in clones
  
  See Also:
  
  Constant Field Values
- prev
```
protected StackFrame prev
```
  the previous StackFrame (usually the caller, null if first). To be set when the frame is pushed on the ThreadInfo callstack
- attributes
```
protected int attributes
```
  state management related attributes similar to ElementInfo. The lower 16 bits are stored/restored, the upper 16 bits are for transient use
- top
```
protected int top
```
- thisRef
```
protected int thisRef
```
- stackBase
```
protected int stackBase
```
- slots
```
protected int[] slots
```
- isRef
```
protected FixedBitSet isRef
```
- frameAttr
```
protected java.lang.Object frameAttr
```
- attrs
```
protected java.lang.Object[] attrs
```
- pc
```
protected Instruction pc
```
- mi
```
protected MethodInfo mi
```

Constructor Detail

StackFrame

protected StackFrame(MethodInfo callee,
                     int nLocals,
                     int nOperands)

StackFrame
```
public StackFrame(MethodInfo callee)
```

StackFrame
```
protected StackFrame()
```
Creates an empty stack frame. Used by clone.

StackFrame
```
protected StackFrame(int nLocals,
                     int nOperands)
```
creates callerSlots dummy Stackframe for testing of operand/local operations NOTE - TESTING ONLY! this does not have a MethodInfo

Method Detail

reset
```
public void reset()
```
re-execute method from the beginning - use with care

createReferenceMap

protected FixedBitSet createReferenceMap(int nSlots)

isNative
```
public boolean isNative()
```

getCallerFrame
```
public StackFrame getCallerFrame()
```

getCalleeThis
```
public int getCalleeThis(MethodInfo mi)
```
return the object reference for an instance method to be called (we are still in the caller's frame). This only makes sense after all params have been pushed, before the INVOKEx insn is executed

getCalleeThis
```
public int getCalleeThis(int size)
```
return reference of called object in the context of the caller (i.e. we are in the caller frame)

getPrevious
```
public StackFrame getPrevious()
```

setPrevious
```
public void setPrevious(StackFrame frame)
```
to be set (by ThreadInfo) when the frame is pushed. Can also be used for non-local gotos, but be warned - that's tricky

getLocalOrFieldValue

public java.lang.Object getLocalOrFieldValue(java.lang.String id)

getLocalValueObject

public java.lang.Object getLocalValueObject(LocalVarInfo lv)

getFieldValue

public java.lang.Object getFieldValue(java.lang.String id)

getClassInfo
```
public ClassInfo getClassInfo()
```

getClassName

public java.lang.String getClassName()

getSourceFile

public java.lang.String getSourceFile()

includesReferenceOperand
```
public boolean includesReferenceOperand(int nTopSlots,
                                        int objRef)
```
does any of the 'nTopSlots' hold callerSlots reference value of 'objRef' 'nTopSlots' is usually obtained from MethodInfo.getNumberOfCallerStackSlots()

includesReferenceOperand
```
public boolean includesReferenceOperand(int objRef)
```
does any of the operand slots hold callerSlots reference value of 'objRef'

modifiesState
```
public boolean modifiesState()
```
is this StackFrame modifying the KernelState this is true unless this is callerSlots NativeStackFrame

isDirectCallFrame
```
public boolean isDirectCallFrame()
```

isSynthetic
```
public boolean isSynthetic()
```

getLine
```
public int getLine()
```

processRefArguments

public void processRefArguments(MethodInfo miCallee,
                                ReferenceProcessor visitor)

generic visitor for reference arguments

getSlot
```
public int getSlot(int idx)
```

isReferenceSlot

public boolean isReferenceSlot(int idx)

setOperand

public void setOperand(int offset,
                       int v,
                       boolean isRefValue)

hasAttrs
```
public boolean hasAttrs()
```

hasFrameAttr
```
public boolean hasFrameAttr()
```

hasFrameAttr

public boolean hasFrameAttr(java.lang.Class<?> attrType)

hasFrameAttrValue

public boolean hasFrameAttrValue(java.lang.Object a)

getFrameAttr
```
public java.lang.Object getFrameAttr()
```
this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList

setFrameAttr
```
public void setFrameAttr(java.lang.Object attr)
```
this replaces all of them - use only if you know there are no SystemAttributes in the list (which would cause an exception)

addFrameAttr

public void addFrameAttr(java.lang.Object attr)

removeFrameAttr

public void removeFrameAttr(java.lang.Object attr)

replaceFrameAttr

public void replaceFrameAttr(java.lang.Object oldAttr,
                             java.lang.Object newAttr)

getFrameAttr
```
public <T> T getFrameAttr(java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getAndResetFrameAttr

public <T> T getAndResetFrameAttr(java.lang.Class<T> attrType)

getNextFrameAttr

public <T> T getNextFrameAttr(java.lang.Class<T> attrType,
                              java.lang.Object prev)

frameAttrIterator

public ObjectList.Iterator frameAttrIterator()

frameAttrIterator

public <T> ObjectList.TypedIterator<T> frameAttrIterator(java.lang.Class<T> attrType)

hasOperandAttr
```
public boolean hasOperandAttr()
```

hasOperandAttr

public boolean hasOperandAttr(java.lang.Class<?> type)

getOperandAttr
```
public java.lang.Object getOperandAttr()
```
this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList

setOperandAttr
```
public void setOperandAttr(java.lang.Object a)
```
this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()

getOperandAttr
```
public <T> T getOperandAttr(java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextOperandAttr

public <T> T getNextOperandAttr(java.lang.Class<T> attrType,
                                java.lang.Object prev)

operandAttrIterator

public java.util.Iterator operandAttrIterator()

operandAttrIterator

public <T> java.util.Iterator<T> operandAttrIterator(java.lang.Class<T> attrType)

addOperandAttr

public void addOperandAttr(java.lang.Object a)

removeOperandAttr

public void removeOperandAttr(java.lang.Object a)

replaceOperandAttr

public void replaceOperandAttr(java.lang.Object oldAttr,
                               java.lang.Object newAttr)

hasOperandAttr

public boolean hasOperandAttr(int offset)

hasOperandAttr

public boolean hasOperandAttr(int offset,
                              java.lang.Class<?> type)

getOperandAttr
```
public java.lang.Object getOperandAttr(int offset)
```
this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList

setOperandAttr
```
public void setOperandAttr(int offset,
                           java.lang.Object a)
```
this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()

getOperandAttr
```
public <T> T getOperandAttr(int offset,
                            java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextOperandAttr

public <T> T getNextOperandAttr(int offset,
                                java.lang.Class<T> attrType,
                                java.lang.Object prev)

operandAttrIterator

public ObjectList.Iterator operandAttrIterator(int offset)

operandAttrIterator

public <T> ObjectList.TypedIterator<T> operandAttrIterator(int offset,
                                                           java.lang.Class<T> attrType)

addOperandAttr

public void addOperandAttr(int offset,
                           java.lang.Object a)

removeOperandAttr

public void removeOperandAttr(int offset,
                              java.lang.Object a)

replaceOperandAttr

public void replaceOperandAttr(int offset,
                               java.lang.Object oldAttr,
                               java.lang.Object newAttr)

hasLongOperandAttr
```
public boolean hasLongOperandAttr()
```

hasLongOperandAttr

public boolean hasLongOperandAttr(java.lang.Class<?> type)

getLongOperandAttr
```
public java.lang.Object getLongOperandAttr()
```
this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList

setLongOperandAttr
```
public void setLongOperandAttr(java.lang.Object a)
```
this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()

getLongOperandAttr
```
public <T> T getLongOperandAttr(java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextLongOperandAttr

public <T> T getNextLongOperandAttr(java.lang.Class<T> attrType,
                                    java.lang.Object prev)

longOperandAttrIterator

public ObjectList.Iterator longOperandAttrIterator()

longOperandAttrIterator

public <T> ObjectList.TypedIterator<T> longOperandAttrIterator(java.lang.Class<T> attrType)

addLongOperandAttr

public void addLongOperandAttr(java.lang.Object a)

removeLongOperandAttr

public void removeLongOperandAttr(java.lang.Object a)

replaceLongOperandAttr

public void replaceLongOperandAttr(java.lang.Object oldAttr,
                                   java.lang.Object newAttr)

hasLocalAttr

public boolean hasLocalAttr(int index)

hasLocalAttr

public boolean hasLocalAttr(int index,
                            java.lang.Class<?> type)

getLocalAttr
```
public java.lang.Object getLocalAttr(int index)
```
this returns all of them - use either if you know there will be only one attribute at callerSlots time, or check/process result with ObjectList

getLongLocalAttr

public java.lang.Object getLongLocalAttr(int index)

setLocalAttr
```
public void setLocalAttr(int index,
                         java.lang.Object a)
```
this replaces all of them - use only if you know - there will be only one attribute at callerSlots time - you obtained the value you set by callerSlots previous getXAttr() - you constructed callerSlots multi value list with ObjectList.createList()

setLongLocalAttr

public void setLongLocalAttr(int index,
                             java.lang.Object a)

addLongLocalAttr

public void addLongLocalAttr(int index,
                             java.lang.Object a)

getLocalAttr
```
public <T> T getLocalAttr(int index,
                          java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextLocalAttr

public <T> T getNextLocalAttr(int index,
                              java.lang.Class<T> attrType,
                              java.lang.Object prev)

localAttrIterator

public ObjectList.Iterator localAttrIterator(int index)

localAttrIterator

public <T> ObjectList.TypedIterator<T> localAttrIterator(int index,
                                                         java.lang.Class<T> attrType)

addLocalAttr

public void addLocalAttr(int index,
                         java.lang.Object attr)

removeLocalAttr

public void removeLocalAttr(int index,
                            java.lang.Object attr)

replaceLocalAttr

public void replaceLocalAttr(int index,
                             java.lang.Object oldAttr,
                             java.lang.Object newAttr)

getLocalAttrIndex
```
public int getLocalAttrIndex(java.lang.Class<?> attrType,
                             int startIdx)
```
helper to quickly find out if any of the locals slots holds an attribute of the provided type

Parameters:

attrType - type of attribute to look for

startIdx - local index to start from

Returns:

index of local slot with attribute, -1 if none found

getArgumentValues
```
public java.lang.Object[] getArgumentValues(ThreadInfo ti)
```
this retrieves the argument values from the caller, i.e. the previous stackframe references are returned as ElementInfos or null primitive values are returned as box objects (e.g. int -> Integer)

getCallArguments
```
public java.lang.Object[] getCallArguments(ThreadInfo ti)
```
get the arguments of the executed call Note - this throws an exception if the StackFrame pc is not an InvokeInstruction

getArgumentsValues

public java.lang.Object[] getArgumentsValues(ThreadInfo ti,
                                             byte[] argTypes)

getArgumentAttrs
```
public java.lang.Object[] getArgumentAttrs(MethodInfo miCallee)
```
return an array of all argument attrs, which in turn can be lists. If you have to retrieve values, use the ObjectList APIs this is here (and not in ThreadInfo) because we might call it on callerSlots cached/cloned StackFrame (caller stack might be already modified, e.g. for callerSlots native method). to be used from listeners.

hasArgumentAttr
```
public boolean hasArgumentAttr(MethodInfo miCallee,
                               java.lang.Class<?> attrType)
```
check if there is any argument attr of the provided type on the operand stack this is far more efficient than retrieving attribute values (we don't care for argument types)

hasArgumentObjectAttr

public boolean hasArgumentObjectAttr(ThreadInfo ti,
                                     MethodInfo miCallee,
                                     java.lang.Class<?> type)

setLocalReferenceVariable

public void setLocalReferenceVariable(int index,
                                      int ref)

setLocalVariable

public void setLocalVariable(int index,
                             int v)

setFloatLocalVariable

public void setFloatLocalVariable(int index,
                                  float f)

setDoubleLocalVariable

public void setDoubleLocalVariable(int index,
                                   double f)

setLocalVariable

public void setLocalVariable(int index,
                             int v,
                             boolean ref)

getLocalVariable
```
public int getLocalVariable(int i)
```

getLocalVariable

public int getLocalVariable(java.lang.String name)

getLocalVariableCount
```
public int getLocalVariableCount()
```

getLocalVars
```
public LocalVarInfo[] getLocalVars()
```
<2do> - this should return only LocalVarInfo for the current pc

isLocalVariableRef

public boolean isLocalVariableRef(int idx)

getLocalVariableType

public java.lang.String getLocalVariableType(java.lang.String name)

getLocalVariableType

public java.lang.String getLocalVariableType(int idx)

getLocalVarInfo

public LocalVarInfo getLocalVarInfo(java.lang.String name)

getLocalVarInfo

public LocalVarInfo getLocalVarInfo(int idx)

setThis
```
public void setThis(int objRef)
```

getReferenceMap
```
public FixedBitSet getReferenceMap()
```

getSlots
```
public int[] getSlots()
```

getSlotAttrs

public java.lang.Object[] getSlotAttrs()

getSlotAttr

public java.lang.Object getSlotAttr(int i)

getSlotAttr

public <T> T getSlotAttr(int i,
                         java.lang.Class<T> attrType)

setSlotAttr

public void setSlotAttr(int i,
                        java.lang.Object a)

addSlotAttr

public void addSlotAttr(int i,
                        java.lang.Object a)

replaceSlotAttr

public void replaceSlotAttr(int i,
                            java.lang.Object oldAttr,
                            java.lang.Object newAttr)

visitReferenceSlots

public void visitReferenceSlots(ReferenceProcessor visitor)

setLongLocalVariable

public void setLongLocalVariable(int index,
                                 long v)

getLongLocalVariable

public long getLongLocalVariable(int idx)

getDoubleLocalVariable

public double getDoubleLocalVariable(int idx)

getFloatLocalVariable

public float getFloatLocalVariable(int idx)

getDoubleLocalVariable

public double getDoubleLocalVariable(java.lang.String name)

getLongLocalVariable

public long getLongLocalVariable(java.lang.String name)

getMethodInfo
```
public MethodInfo getMethodInfo()
```

getMethodName

public java.lang.String getMethodName()

isOperandRef

public boolean isOperandRef(int offset)

isOperandRef
```
public boolean isOperandRef()
```

setPC
```
public void setPC(Instruction newpc)
```

getPC
```
public Instruction getPC()
```

advancePC
```
public void advancePC()
```

getTopPos
```
public int getTopPos()
```

isFirewall
```
public boolean isFirewall()
```

getStackTraceInfo

public java.lang.String getStackTraceInfo()

getThis
```
public int getThis()
```
if this is an instance method, return the reference of the corresponding object (note this only has to be in slot 0 upon entry)

clearOperandStack
```
public void clearOperandStack()
```

clone
```
public StackFrame clone()
```
Overrides:

clone in class java.lang.Object

checkIsModifiable
```
protected void checkIsModifiable()
```

freeze
```
public void freeze()
```

defreeze
```
public void defreeze()
```

isFrozen
```
public boolean isFrozen()
```

setReflection
```
public void setReflection()
```

isReflection
```
public boolean isReflection()
```

dup
```
public void dup()
```

dup2
```
public void dup2()
```

dup2_x1
```
public void dup2_x1()
```

dup2_x2
```
public void dup2_x2()
```

dup_x1
```
public void dup_x1()
```

dup_x2
```
public void dup_x2()
```

originatesFrom
```
public boolean originatesFrom(StackFrame other)
```
to be used to check if a StackFrame got cloned due to its execution changing attributes and/or slots, but otherwise represents the same execution

equals
```
public boolean equals(java.lang.Object o)
```
Overrides:

equals in class java.lang.Object

hasAnyRef
```
public boolean hasAnyRef()
```

mixinExecutionStateHash

public int mixinExecutionStateHash(int h)

hash
```
protected void hash(HashData hd)
```

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

markThreadRoots
```
public void markThreadRoots(Heap heap,
                            int tid)
```
mark all objects reachable from local or operand stack positions containing references. Done during phase1 marking of threads (the stack is one of the Thread gc roots)

printOperands

public void printOperands(java.io.PrintStream pw)

printStackContent
```
public void printStackContent()
```
this includes locals and pc

printStackTrace
```
public void printStackTrace()
```

swap
```
public void swap()
```

printContentsOn

protected void printContentsOn(java.io.PrintWriter pw)

printSlots

public void printSlots(java.io.PrintStream ps)

getDepth
```
public int getDepth()
```

objectHashCode
```
protected int objectHashCode()
```

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

peekFloat
```
public float peekFloat()
```

peekFloat
```
public float peekFloat(int offset)
```

peekDouble
```
public double peekDouble()
```

peekDouble
```
public double peekDouble(int offset)
```

peekLong
```
public long peekLong()
```

peekLong
```
public long peekLong(int offset)
```

pushLong
```
public void pushLong(long v)
```

pushDouble
```
public void pushDouble(double v)
```

pushFloat
```
public void pushFloat(float v)
```

popDouble
```
public double popDouble()
```

popLong
```
public long popLong()
```

peek
```
public int peek()
```

peek
```
public int peek(int offset)
```

removeArguments

public void removeArguments(MethodInfo mi)

pop
```
public void pop(int n)
```

popFloat
```
public float popFloat()
```

pop
```
public int pop()
```

pushLocal
```
public void pushLocal(int index)
```

pushLongLocal
```
public void pushLongLocal(int index)
```

storeOperand
```
public void storeOperand(int index)
```

storeLongOperand

public void storeLongOperand(int index)

push
```
public void push(int v)
```

pushRef
```
public void pushRef(int ref)
```

push

public void push(int v,
                 boolean ref)

getLocalVariableSlotIndex

public int getLocalVariableSlotIndex(java.lang.String name)

setReferenceResult

public void setReferenceResult(int ref,
                               java.lang.Object attr)

setResult

public void setResult(int r,
                      java.lang.Object attr)

setResult

public void setResult(long r,
                      java.lang.Object attr)

getResult
```
public int getResult()
```

getLongResult
```
public long getLongResult()
```

getReferenceResult
```
public int getReferenceResult()
```

getResultAttr

public java.lang.Object getResultAttr()

getLongResultAttr

public java.lang.Object getLongResultAttr()

getFloatResult
```
public float getFloatResult()
```

getDoubleResult
```
public double getDoubleResult()
```

getFloatResultAttr

public java.lang.Object getFloatResultAttr()

getDoubleResultAttr

public java.lang.Object getDoubleResultAttr()

setExceptionReference

public void setExceptionReference(int exRef)

getExceptionReference
```
public int getExceptionReference()
```

setExceptionReferenceAttribute

public void setExceptionReferenceAttribute(java.lang.Object attr)

getExceptionReferenceAttribute

public java.lang.Object getExceptionReferenceAttribute()

setArgumentLocal

public abstract void setArgumentLocal(int idx,
                                      int value,
                                      java.lang.Object attr)

setLongArgumentLocal

public abstract void setLongArgumentLocal(int idx,
                                          long value,
                                          java.lang.Object attr)

setReferenceArgumentLocal

public abstract void setReferenceArgumentLocal(int idx,
                                               int ref,
                                               java.lang.Object attr)

setFloatArgumentLocal

public void setFloatArgumentLocal(int idx,
                                  float value,
                                  java.lang.Object attr)

setDoubleArgumentLocal

public void setDoubleArgumentLocal(int idx,
                                   double value,
                                   java.lang.Object attr)

Class StackFrame

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ATTR_IS_FROZEN

prev

attributes

top

thisRef

stackBase

slots

isRef

frameAttr

attrs

pc

mi

Constructor Detail

StackFrame

StackFrame

StackFrame

StackFrame

Method Detail

reset

createReferenceMap

isNative

getCallerFrame

getCalleeThis

getCalleeThis

getPrevious

setPrevious

getLocalOrFieldValue

getLocalValueObject

getFieldValue

getClassInfo

getClassName

getSourceFile

includesReferenceOperand

includesReferenceOperand

modifiesState

isDirectCallFrame

isSynthetic

getLine

processRefArguments

getSlot

isReferenceSlot

setOperand

hasAttrs

hasFrameAttr

hasFrameAttr

hasFrameAttrValue

getFrameAttr

setFrameAttr

addFrameAttr

removeFrameAttr

replaceFrameAttr

getFrameAttr

getAndResetFrameAttr

getNextFrameAttr

frameAttrIterator

frameAttrIterator

hasOperandAttr

hasOperandAttr

getOperandAttr

setOperandAttr

getOperandAttr

getNextOperandAttr

operandAttrIterator

operandAttrIterator

addOperandAttr

removeOperandAttr

replaceOperandAttr

hasOperandAttr

hasOperandAttr

getOperandAttr

setOperandAttr

getOperandAttr

getNextOperandAttr

operandAttrIterator