ThreadInfo

java.lang.Object
- gov.nasa.jpf.vm.InfoObject
- - gov.nasa.jpf.vm.ThreadInfo

All Implemented Interfaces:

Restorable<ThreadInfo>, java.lang.Cloneable, java.lang.Comparable<ThreadInfo>, java.lang.Iterable<StackFrame>

Direct Known Subclasses:

FinalizerThreadInfo
```
public class ThreadInfo
extends InfoObject
implements java.lang.Iterable<StackFrame>, java.lang.Comparable<ThreadInfo>, Restorable<ThreadInfo>
```
Represents a thread. It contains the state of the thread, static information about the thread, and the stack frames. Race detection and lock order also store some information in this data structure. Note that we preserve identities according to their associated java.lang.Thread object (oref). This esp. means along the same path, a ThreadInfo reference is kept invariant <2do> remove EXECUTENATIVE,INVOKESTATIC .bytecode dependencies

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class ThreadInfo.InvokedStackIterator

protected class ThreadInfo.StackIterator

static class ThreadInfo.State

Nested Classes
Modifier and Type	Class and Description
`protected class`	`ThreadInfo.InvokedStackIterator`
`protected class`	`ThreadInfo.StackIterator`
`static class`	`ThreadInfo.State`

Field Summary

Fields
Modifier and Type	Field and Description
`protected ApplicationContext`	`appCtx`
`protected int`	`attributes`
`protected ClassInfo`	`ci`
`protected int`	`executedInstructions` counter for executed instructions along current transition
`protected int`	`id`
`protected Instruction`	`nextPc` the next insn to enter (null prior to execution)
`protected int`	`objRef`
`protected ExceptionInfo`	`pendingException`
`protected gov.nasa.jpf.vm.ThreadInfo.SUTExceptionRequest`	`pendingSUTExceptionRequest` a listener or peer request for throwing an exception into the SUT, to be processed in executeInstruction
`protected DirectCallStackFrame`	`returnedDirectCall` the last returned direct call frame
`protected int`	`stackDepth`
`protected int`	`targetRef`
`protected ThreadData`	`threadData`
`protected int`	`tlIdx`
`protected StackFrame`	`top`

Fields inherited from class gov.nasa.jpf.vm.InfoObject
annotations, attr, typeAnnotations

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ThreadInfo(VM vm, int id, ApplicationContext appCtx)` mainThread ctor called by the VM.
`protected`	`ThreadInfo(VM vm, int objRef, int groupRef, int runnableRef, int nameRef, ThreadInfo parent)` the ctor for all explicitly (bytecode) created threads.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`addToThreadGroup(ElementInfo eiGroup)` this is used for all thread objects, not just main
`void`	`advancePC()`
`boolean`	`atMethod(java.lang.String mname)`
`boolean`	`atPosition(int position)`
`boolean`	`atReturn()`
`boolean`	`breakTransition(boolean isTerminator)` this breaks the current transition with a CG that forces an end state (i.e.
`boolean`	`breakTransition(java.lang.String reason)` this is a version that unconditionally breaks the current transition without really adding choices.
`protected Instruction`	`callUncaughtHandler(ExceptionInfo xi)` this explicitly models the standard ThreadGroup.uncaughtException(), but we want to save us a roundtrip if that's the only handler we got.
`protected Instruction`	`callUncaughtHandler(ExceptionInfo xi, int handlerRef, java.lang.String id)`
`protected void`	`checkAssertion(boolean cond, java.lang.String failMsg)`
`void`	`checkConsistency(boolean isStore)` only for debugging purposes
`void`	`checkNextChoiceGeneratorSet(java.lang.String msg)`
`void`	`clearPendingException()` watch out - just clearing it might cause an infinite loop if we don't drop frames and/or advance the pc
`java.lang.Object`	`clone()`
`int`	`compareTo(ThreadInfo that)` Comparison for sorting based on index.
`protected int`	`computeId(int objRef)`
`int`	`countStackFrames()` Returns the number of stack frames.
`Instruction`	`createAndThrowException(ClassInfo ci, java.lang.String details)` Creates and throws an exception.
`Instruction`	`createAndThrowException(java.lang.String cname)` Creates an exception and throws it.
`Instruction`	`createAndThrowException(java.lang.String cname, java.lang.String details)`
`protected ElementInfo`	`createMainThreadGroup(SystemClassLoaderInfo sysCl)` this creates and inits the main ThreadGroup object, which we have to do explicitly since we can't execute bytecode yet
`protected void`	`createMainThreadObject(SystemClassLoaderInfo sysCl)` this is called by the VM upon initialization of the main thread.
`int`	`createStackTraceElements(int[] snapshot)` turn a snapshot into an JPF array of StackTraceElements, which means a lot of objects.
`void`	`dumpStoringData(IntVector v)` Returns the information necessary to store.
`void`	`enableEmptyTransition()`
`void`	`enter()` note - this assumes the stackframe of the method to enter is already initialized and on top (pushed)
`Instruction`	`executeInstruction()` Execute next instruction.
`Instruction`	`executeInstructionHidden()` enter instruction hidden from any listeners, and do not record it in the path
`void`	`executeMethodAtomic(StackFrame frame)` Executes a method call.
`void`	`executeMethodHidden(StackFrame frame)` enter method atomically, but also hide it from listeners and do NOT add executed instructions to the path.
`protected void`	`executeTransition(SystemState ss)` enter instructions until there is none left or somebody breaks the transition (e.g.
`boolean`	`exit()` this should only be called from the top half of the last DIRECTCALLRETURN of a thread.
`ApplicationContext`	`getApplicationContext()`
`ElementInfo`	`getBlockedObject(MethodInfo mi, boolean isBeforeCall, boolean isModifiable)`
`Memento<ThreadInfo>`	`getCachedMemento()`
`int`	`getCalleeThis(int size)` Returns the this pointer of the callee from the stack.
`int`	`getCalleeThis(MethodInfo mi)` Returns the this pointer of the callee from the stack.
`StackFrame`	`getCallerStackFrame()`
`StackFrame`	`getCallerStackFrame(int offset)`
`ClassInfo`	`getClassInfo()` Returns the class information.
`ClassInfo`	`getClassInfo(int objref)`
`static ThreadInfo`	`getCurrentThread()`
`ElementInfo`	`getElementInfo(int objRef)`
`MethodInfo`	`getEntryMethod()`
`MJIEnv`	`getEnv()`
`int`	`getExecutedInstructions()` get the number of instructions executed in the current transition.
`ClassInfo`	`getExecutingClassInfo()` return the ClassInfo of the topmost stackframe that is not a direct call
`int`	`getGlobalId()` this is our internal, search global id that is used for the canonical root set
`protected int`	`getGlobalUncaughtHandler()`
`HandlerContext`	`getHandlerContextFor(ClassInfo ciException)` this is basically a side-effect free version of throwException to determine if a given exception will be handled.
`Heap`	`getHeap()`
`int`	`getId()` path local unique id for live threads.
`protected int`	`getInstanceUncaughtHandler()`
`java.util.List<StackFrame>`	`getInvokedStackFrames()` returns StackFrames which have been entered through a corresponding invoke instruction (in top first order)
`StackFrame`	`getLastInvokedStackFrame()`
`StackFrame`	`getLastNonSyntheticStackFrame()`
`int`	`getLine()` Returns the line number of the program counter of the top stack frame.
`int`	`getLockCount()` Returns the number of locks in the last wait.
`int[]`	`getLockedObjectReferences()`
`java.util.List<ElementInfo>`	`getLockedObjects()`
`ElementInfo`	`getLockObject()`
`int`	`getLockRef()`
`Memento<ThreadInfo>`	`getMemento()`
`Memento<ThreadInfo>`	`getMemento(MementoFactory factory)`
`MJIEnv`	`getMJIEnv()`
`ElementInfo`	`getModifiableElementInfo(int ref)`
`StackFrame`	`getModifiableFrame(StackFrame frame)` this replaces all frames up from 'frame' to 'top' with modifiable ones.
`StackFrame`	`getModifiableLastNonSyntheticStackFrame()`
`ElementInfo`	`getModifiableThreadObject()`
`StackFrame`	`getModifiableTopFrame()` Returns a clone of the top stack frame.
`java.lang.String`	`getName()`
`Instruction`	`getNextPC()`
`Instruction`	`getPC()` Returns the program counter of the top stack frame.
`ExceptionInfo`	`getPendingException()`
`int`	`getPriority()`
`DirectCallStackFrame`	`getReturnedDirectCall()`
`int`	`getRunnableRef()` Returns the object reference of the target.
`Scheduler`	`getScheduler()`
`int[]`	`getSnapshot(int xObjRef)` get a stack snapshot that consists of an array of {mthId,pc} pairs.
`java.util.List<StackFrame>`	`getStack()` Deprecated. - use Iterable
`int`	`getStackDepth()`
`StackFrame`	`getStackFrameExecuting(Instruction insn, int offset)` note that we don't provide a modifiable version of this.
`java.lang.String`	`getStackTrace()` get the current stack trace of this thread this is called during creation of a Throwable, hence we should skip all throwable ctors in here <2do> this is only a partial solution,since we don't catch exceptionHandlers in Throwable ctors yet
`ThreadInfo.State`	`getState()` Returns the current status of the thread.
`java.lang.String`	`getStateDescription()`
`java.lang.String`	`getStateName()`
`SystemClassLoaderInfo`	`getSystemClassLoaderInfo()`
`int`	`getThis()` Returns the pointer to the object reference of the executing method
`ElementInfo`	`getThisElementInfo()`
`protected int`	`getThreadGroupRef()`
`protected int`	`getThreadGroupUncaughtHandler(int grpRef)`
`ElementInfo`	`getThreadObject()`
`ClassInfo`	`getThreadObjectClassInfo()`
`int`	`getThreadObjectRef()` Returns the object reference.
`StackFrame`	`getTopFrame()` Returns the top stack frame.
`MethodInfo`	`getTopFrameMethodInfo()` returns the current method in the top stack frame, which is always a bytecode method (executed by JPF)
`VM`	`getVM()`
`protected boolean`	`haltOnThrow(java.lang.String exceptionClassName)`
`boolean`	`hasBeenStarted()`
`boolean`	`hasChanged()`
`boolean`	`hasDataChanged()`
`void`	`hash(HashData hd)`
`boolean`	`hasLockedObjects()`
`boolean`	`hasNextChoiceGenerator()`
`boolean`	`hasOtherRunnables()`
`boolean`	`hasReturnedFromDirectCall()`
`boolean`	`hasReturnedFromDirectCall(java.lang.String directCallId)`
`boolean`	`hasStackChanged()`
`boolean`	`hasUncaughtHandler()` is there any UncaughHandler in effect for this thread? NOTE - this doesn't check if we are already executing one (i.e.
`boolean`	`holdsLock(ElementInfo ei)`
`protected void`	`init(VM vm)`
`void`	`interrupt()`
`java.lang.Iterable<StackFrame>`	`invokedStackFrames()`
`boolean`	`isAlive()` An alive thread is anything but TERMINATED or NEW
`boolean`	`isAtomic()`
`boolean`	`isBlocked()`
`boolean`	`isBlockedOrNotified()`
`boolean`	`isCalleeThis(ElementInfo r)`
`boolean`	`isClinitOnStack(ClassInfo ci)`
`boolean`	`isCtorOnStack(int objRef)`
`boolean`	`isCurrentThread()`
`boolean`	`isDaemon()`
`boolean`	`isEmptyTransitionEnabled()` is this transition allowed to be empty (i.e.
`boolean`	`isExecutingAtomically()`
`boolean`	`isFirstStepInsn()` answers if is this the first instruction within the current transition.
`boolean`	`isInCtor()`
`boolean`	`isInCurrentThreadList()`
`boolean`	`isInNativeMethod()`
`boolean`	`isInstructionSkipped()`
`boolean`	`isInterrupted(boolean resetStatus)`
`boolean`	`isLockOwner(ElementInfo ei)`
`boolean`	`isNew()`
`boolean`	`isNotified()`
`boolean`	`isPostExec()` is this after calling Instruction.enter() used by instructions and listeners
`boolean`	`isPreExec()` to be used from methods called from listeners, to find out if we are in a pre- or post-exec notification
`boolean`	`isRunnable()` Returns true if this thread is either RUNNING or UNBLOCKED
`boolean`	`isSleeping()`
`boolean`	`isStopped()`
`boolean`	`isSuspended()`
`boolean`	`isSystemThread()`
`boolean`	`isTerminated()`
`boolean`	`isThis(ElementInfo ei)`
`boolean`	`isTimedOut()`
`boolean`	`isTimeoutRunnable()`
`boolean`	`isTimeoutWaiting()`
`boolean`	`isUnblocked()`
`protected boolean`	`isUncaughtHandlerOnStack()`
`boolean`	`isWaiting()`
`boolean`	`isWaitingOrTimedOut()`
`java.util.Iterator<StackFrame>`	`iterator()`
`boolean`	`leave()` note - this assumes the stackframe is still on top (not yet popped) return true if any threads became unblocked due to a return from a sync method
`protected void`	`markTdChanged()`
`protected void`	`markTfChanged(StackFrame frame)`
`protected void`	`markUnchanged()`
`boolean`	`maxTransitionLengthExceeded()` can be used by instructions to break long transitions (preferably on backjumps so that state matching could terminate the search)
`int`	`mixinExecutionStateHash(int h)`
`StackFrame`	`popAndGetModifiableTopFrame()`
`StackFrame`	`popAndGetTopFrame()`
`StackFrame`	`popDirectCallFrame()` removing DirectCallStackFrames is a bit different (only happens from DIRECTCALLRETURN insns)
`void`	`popFrame()` Removes a stack frame
`protected StackFrame`	`popUncaughtHandlerFrame()`
`void`	`printPendingExceptionOn(java.io.PrintWriter pw)`
`void`	`printStackContent()` Prints the content of the stack
`void`	`printStackTrace()` Prints current stacktrace information
`void`	`printStackTrace(int objRef)`
`void`	`printStackTrace(java.io.PrintWriter pw, int objRef)` the reason why this is kind of duplicated (there is also a StackFrame.getPositionInfo) is that this might be working off a StackTraceElement[] that is created when the exception is created.
`protected void`	`processPendingSUTExceptionRequest()`
`void`	`pushFrame(StackFrame frame)` Adds a new stack frame for a new called method.
`void`	`reExecuteInstruction()`
`void`	`requestSUTException(java.lang.String exceptionClsName, java.lang.String details)`
`boolean`	`reschedule(java.lang.String reason)` this is a generic request to reschedule that is not based on instruction type Note that we check for a mandatory CG, i.e.
`void`	`resetEmptyTransition()`
`void`	`resetLockRef()` thread is not blocked anymore needs to be public since we have to use it from INVOKECLINIT (during call skipping)
`void`	`resetTimedOut()`
`protected void`	`resetTransientAttributes()`
`ClassInfo`	`resolveReferencedClass(java.lang.String clsName)`
`void`	`restoreThreadData(ThreadData td)`
`boolean`	`resume()` unset suspension status
`void`	`setBlockedInAtomicSection()`
`void`	`setCachedMemento(Memento<ThreadInfo> memento)`
`void`	`setLockCount(int l)` Sets the number of locks held at the time of a wait.
`boolean`	`setNextChoiceGenerator(ChoiceGenerator<?> cg)`
`boolean`	`setNextPC(Instruction insn)` explicitly set the next insn to enter.
`void`	`setPC(Instruction pc)` Sets the program counter of the top stack frame.
`void`	`setPriority(int newPrio)`
`void`	`setRunning()`
`void`	`setSleeping()`
`void`	`setState(ThreadInfo.State newStatus)` Updates the status of the thread.
`void`	`setStopped(int throwableRef)`
`void`	`setTerminated()`
`void`	`setTimedOut()`
`void`	`setTopFrame(StackFrame frame)` replace the top frame - this is a dangerous method that should only be used from Restoreres and to restore operators and locals in post-execution notifications to their pre-execution contents
`void`	`skipInstruction()` Deprecated.
`void`	`skipInstruction(Instruction nextInsn)` skip the next bytecode.
`void`	`skipInstructionLogging()`
`boolean`	`suspend()` set suspension status
`protected ThreadData`	`threadDataClone()` Returns a clone of the thread data.
`Instruction`	`throwException(int exceptionObjRef)` unwind stack frames until we find a matching handler for the exception object
`protected Instruction`	`throwStopException()`
`java.lang.String`	`toString()`
`protected void`	`unwindTo(StackFrame newTopFrame)`
`protected StackFrame`	`unwindToFirstFrame()`
`boolean`	`willBeRunnable()`
`boolean`	`willReExecuteInstruction()`

Methods inherited from class gov.nasa.jpf.vm.InfoObject
addAnnotation, addAnnotations, addAttr, addTypeAnnotation, addTypeAnnotations, attrIterator, attrIterator, getAnnotation, getAnnotations, getAttr, getAttr, getDeclaredAnnotations, getNextAttr, getTargetTypeAnnotations, getTypeAnnotation, getTypeAnnotations, hasAnnotation, hasAnnotations, hasAttr, hasAttr, hasAttrValue, hasTypeAnnotation, hasTypeAnnotations, removeAttr, replaceAttr, setAnnotations, setAttr, setTypeAnnotations

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - pendingException
```
protected ExceptionInfo pendingException
```
  - threadData
```
protected ThreadData threadData
```
  - top
```
protected StackFrame top
```
  - stackDepth
```
protected int stackDepth
```
  - tlIdx
```
protected int tlIdx
```
  - appCtx
```
protected ApplicationContext appCtx
```
  - id
```
protected int id
```
  - objRef
```
protected int objRef
```
  - ci
```
protected ClassInfo ci
```
  - targetRef
```
protected int targetRef
```
  - attributes
```
protected int attributes
```
  - executedInstructions
```
protected int executedInstructions
```
    counter for executed instructions along current transition
  - pendingSUTExceptionRequest
```
protected gov.nasa.jpf.vm.ThreadInfo.SUTExceptionRequest pendingSUTExceptionRequest
```
    a listener or peer request for throwing an exception into the SUT, to be processed in executeInstruction
  - returnedDirectCall
```
protected DirectCallStackFrame returnedDirectCall
```
    the last returned direct call frame
  - nextPc
```
protected Instruction nextPc
```
    the next insn to enter (null prior to execution)
- Constructor Detail
  - ThreadInfo
```
protected ThreadInfo(VM vm,
                     int id,
                     ApplicationContext appCtx)
```
    mainThread ctor called by the VM. Note we don't have a thread object yet (hen-and-egg problem since we can't allocate objects without a ThreadInfo)
  - ThreadInfo
```
protected ThreadInfo(VM vm,
                     int objRef,
                     int groupRef,
                     int runnableRef,
                     int nameRef,
                     ThreadInfo parent)
```
    the ctor for all explicitly (bytecode) created threads. At this point, there is at least a mainThread and we have a corresponding java.lang.Thread object
- Method Detail
  - computeId
```
protected int computeId(int objRef)
```
  - init
```
protected void init(VM vm)
```
  - getMemento
```
public Memento<ThreadInfo> getMemento(MementoFactory factory)
```
    Specified by:
    
    getMemento in interface Restorable<ThreadInfo>
  - getMemento
```
public Memento<ThreadInfo> getMemento()
```
  - getCachedMemento
```
public Memento<ThreadInfo> getCachedMemento()
```
  - setCachedMemento
```
public void setCachedMemento(Memento<ThreadInfo> memento)
```
  - getCurrentThread
```
public static ThreadInfo getCurrentThread()
```
  - isExecutingAtomically
```
public boolean isExecutingAtomically()
```
  - holdsLock
```
public boolean holdsLock(ElementInfo ei)
```
  - getVM
```
public VM getVM()
```
  - isEmptyTransitionEnabled
```
public boolean isEmptyTransitionEnabled()
```
    is *this* transition allowed to be empty (i.e. allowed to set a CG during re-execution of the current insn) reset before each instruction.execute()
  - enableEmptyTransition
```
public void enableEmptyTransition()
```
  - resetEmptyTransition
```
public void resetEmptyTransition()
```
  - isFirstStepInsn
```
public boolean isFirstStepInsn()
```
    answers if is this the first instruction within the current transition. This is mostly used to tell the top- from the bottom-half of a native method or Instruction.enter(), so that only one (the top half) registers the CG (top = register CG and reschedule insn, bottom = re-enter insn and process choice at beginning of new transition) This can be used in both pre- and post-exec notification listeners, the executedInstructions number is incremented before notifying instructionExecuted() this method depends on the sequence of operations in ThreadInfo.executeInstruction, which is: nextPc = null notify executeInstruction nextPc = insn.execute increment executedInstructions notify instructionExecuted
  - getExecutedInstructions
```
public int getExecutedInstructions()
```
    get the number of instructions executed in the current transition. This gets incremented after calling Instruction.enter(), i.e. before notifying instructionExecuted() listeners
  - isPreExec
```
public boolean isPreExec()
```
    to be used from methods called from listeners, to find out if we are in a pre- or post-exec notification
  - setState
```
public void setState(ThreadInfo.State newStatus)
```
    Updates the status of the thread.
  - getState
```
public ThreadInfo.State getState()
```
    Returns the current status of the thread.
  - isRunnable
```
public boolean isRunnable()
```
    Returns true if this thread is either RUNNING or UNBLOCKED
  - willBeRunnable
```
public boolean willBeRunnable()
```
  - isNew
```
public boolean isNew()
```
  - isTimeoutRunnable
```
public boolean isTimeoutRunnable()
```
  - isTimedOut
```
public boolean isTimedOut()
```
  - isTimeoutWaiting
```
public boolean isTimeoutWaiting()
```
  - setTimedOut
```
public void setTimedOut()
```
  - setTerminated
```
public void setTerminated()
```
  - resetTimedOut
```
public void resetTimedOut()
```
  - setSleeping
```
public void setSleeping()
```
  - isSleeping
```
public boolean isSleeping()
```
  - setRunning
```
public void setRunning()
```
  - setStopped
```
public void setStopped(int throwableRef)
```
  - isCurrentThread
```
public boolean isCurrentThread()
```
  - isInCurrentThreadList
```
public boolean isInCurrentThreadList()
```
  - isAlive
```
public boolean isAlive()
```
    An alive thread is anything but TERMINATED or NEW
  - isWaiting
```
public boolean isWaiting()
```
  - isWaitingOrTimedOut
```
public boolean isWaitingOrTimedOut()
```
  - isNotified
```
public boolean isNotified()
```
  - isUnblocked
```
public boolean isUnblocked()
```
  - isBlocked
```
public boolean isBlocked()
```
  - isTerminated
```
public boolean isTerminated()
```
  - isAtomic
```
public boolean isAtomic()
```
  - setBlockedInAtomicSection
```
public void setBlockedInAtomicSection()
```
  - isBlockedOrNotified
```
public boolean isBlockedOrNotified()
```
  - isStopped
```
public boolean isStopped()
```
  - isInNativeMethod
```
public boolean isInNativeMethod()
```
  - hasBeenStarted
```
public boolean hasBeenStarted()
```
  - getStateName
```
public java.lang.String getStateName()
```
  - iterator
```
public java.util.Iterator<StackFrame> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<StackFrame>
  - invokedStackFrames
```
public java.lang.Iterable<StackFrame> invokedStackFrames()
```
  - getStack
```
@Deprecated
public java.util.List<StackFrame> getStack()
```
    Deprecated. - use Iterable
    
    this returns a copy of the StackFrames in reverse order. Note this is redundant because the frames are linked explicitly
  - getInvokedStackFrames
```
public java.util.List<StackFrame> getInvokedStackFrames()
```
    returns StackFrames which have been entered through a corresponding invoke instruction (in top first order)
  - getScheduler
```
public Scheduler getScheduler()
```
  - getStackDepth
```
public int getStackDepth()
```
  - getEntryMethod
```
public MethodInfo getEntryMethod()
```
  - getCallerStackFrame
```
public StackFrame getCallerStackFrame(int offset)
```
  - getLastInvokedStackFrame
```
public StackFrame getLastInvokedStackFrame()
```
  - getLastNonSyntheticStackFrame
```
public StackFrame getLastNonSyntheticStackFrame()
```
  - getModifiableLastNonSyntheticStackFrame
```
public StackFrame getModifiableLastNonSyntheticStackFrame()
```
  - getCalleeThis
```
public int getCalleeThis(MethodInfo mi)
```
    Returns the this pointer of the callee from the stack.
  - getCalleeThis
```
public int getCalleeThis(int size)
```
    Returns the this pointer of the callee from the stack.
  - getClassInfo
```
public ClassInfo getClassInfo(int objref)
```
  - isCalleeThis
```
public boolean isCalleeThis(ElementInfo r)
```
  - getApplicationContext
```
public ApplicationContext getApplicationContext()
```
  - getSystemClassLoaderInfo
```
public SystemClassLoaderInfo getSystemClassLoaderInfo()
```
  - getClassInfo
```
public ClassInfo getClassInfo()
```
    Returns the class information.
  - getEnv
```
public MJIEnv getEnv()
```
  - isInterrupted
```
public boolean isInterrupted(boolean resetStatus)
```
  - getId
```
public int getId()
```
    path local unique id for live threads. This is what we use for the public java.lang.Thread.getId() that can be called from SUT code. It is NOT what we use for our canonical root set
  - getGlobalId
```
public int getGlobalId()
```
    this is our internal, search global id that is used for the canonical root set
  - resetLockRef
```
public void resetLockRef()
```
    thread is not blocked anymore needs to be public since we have to use it from INVOKECLINIT (during call skipping)
  - getLockRef
```
public int getLockRef()
```
  - getLockObject
```
public ElementInfo getLockObject()
```
  - getLine
```
public int getLine()
```
    Returns the line number of the program counter of the top stack frame.
  - suspend
```
public boolean suspend()
```
    set suspension status
    
    Returns:
    
    true if thread was not suspended
  - resume
```
public boolean resume()
```
    unset suspension status
    
    Returns:
    
    true if thread was suspended
  - isSuspended
```
public boolean isSuspended()
```
  - setLockCount
```
public void setLockCount(int l)
```
    Sets the number of locks held at the time of a wait.
  - getLockCount
```
public int getLockCount()
```
    Returns the number of locks in the last wait.
  - getLockedObjects
```
public java.util.List<ElementInfo> getLockedObjects()
```
  - hasLockedObjects
```
public boolean hasLockedObjects()
```
  - getLockedObjectReferences
```
public int[] getLockedObjectReferences()
```
  - isLockOwner
```
public boolean isLockOwner(ElementInfo ei)
```
  - getTopFrameMethodInfo
```
public MethodInfo getTopFrameMethodInfo()
```
    returns the current method in the top stack frame, which is always a bytecode method (executed by JPF)
  - getExecutingClassInfo
```
public ClassInfo getExecutingClassInfo()
```
    return the ClassInfo of the topmost stackframe that is not a direct call
  - resolveReferencedClass
```
public ClassInfo resolveReferencedClass(java.lang.String clsName)
```
  - isInCtor
```
public boolean isInCtor()
```
  - isCtorOnStack
```
public boolean isCtorOnStack(int objRef)
```
  - isClinitOnStack
```
public boolean isClinitOnStack(ClassInfo ci)
```
  - getName
```
public java.lang.String getName()
```
  - getThreadObjectRef
```
public int getThreadObjectRef()
```
    Returns the object reference.
  - getThreadObject
```
public ElementInfo getThreadObject()
```
  - getModifiableThreadObject
```
public ElementInfo getModifiableThreadObject()
```
  - setPC
```
public void setPC(Instruction pc)
```
    Sets the program counter of the top stack frame.
  - advancePC
```
public void advancePC()
```
  - getPC
```
public Instruction getPC()
```
    Returns the program counter of the top stack frame.
  - getNextPC
```
public Instruction getNextPC()
```
  - getStackTrace
```
public java.lang.String getStackTrace()
```
    get the current stack trace of this thread this is called during creation of a Throwable, hence we should skip all throwable ctors in here <2do> this is only a partial solution,since we don't catch exceptionHandlers in Throwable ctors yet
  - dumpStoringData
```
public void dumpStoringData(IntVector v)
```
    Returns the information necessary to store. <2do> pcm - not clear to me how lower stack frames can contribute to a different threadinfo state hash - only the current one can be changed by the executing method
  - getRunnableRef
```
public int getRunnableRef()
```
    Returns the object reference of the target.
  - getThis
```
public int getThis()
```
    Returns the pointer to the object reference of the executing method
  - getThisElementInfo
```
public ElementInfo getThisElementInfo()
```
  - isThis
```
public boolean isThis(ElementInfo ei)
```
  - atMethod
```
public boolean atMethod(java.lang.String mname)
```
  - atPosition
```
public boolean atPosition(int position)
```
  - atReturn
```
public boolean atReturn()
```
  - clone
```
public java.lang.Object clone()
```
    Overrides:
    
    clone in class java.lang.Object
  - countStackFrames
```
public int countStackFrames()
```
    Returns the number of stack frames.
  - getSnapshot
```
public int[] getSnapshot(int xObjRef)
```
    get a stack snapshot that consists of an array of {mthId,pc} pairs. strip stackframes that enter instance methods of the exception object
  - createStackTraceElements
```
public int createStackTraceElements(int[] snapshot)
```
    turn a snapshot into an JPF array of StackTraceElements, which means a lot of objects. Do this only on demand
  - printStackTrace
```
public void printStackTrace(int objRef)
```
  - printPendingExceptionOn
```
public void printPendingExceptionOn(java.io.PrintWriter pw)
```
  - printStackTrace
```
public void printStackTrace(java.io.PrintWriter pw,
                            int objRef)
```
    the reason why this is kind of duplicated (there is also a StackFrame.getPositionInfo) is that this might be working off a StackTraceElement[] that is created when the exception is created. At the time printStackTrace() is called, the StackFrames in question are most likely already be unwinded
  - requestSUTException
```
public void requestSUTException(java.lang.String exceptionClsName,
                                java.lang.String details)
```
  - processPendingSUTExceptionRequest
```
protected void processPendingSUTExceptionRequest()
```
  - createAndThrowException
```
public Instruction createAndThrowException(ClassInfo ci,
                                           java.lang.String details)
```
    Creates and throws an exception. This is what is used if the exception is thrown by the VM (or a listener)
  - createAndThrowException
```
public Instruction createAndThrowException(java.lang.String cname)
```
    Creates an exception and throws it.
  - createAndThrowException
```
public Instruction createAndThrowException(java.lang.String cname,
                                           java.lang.String details)
```
  - maxTransitionLengthExceeded
```
public boolean maxTransitionLengthExceeded()
```
    can be used by instructions to break long transitions (preferably on backjumps so that state matching could terminate the search)
  - executeTransition
```
protected void executeTransition(SystemState ss)
                          throws JPFException
```
    enter instructions until there is none left or somebody breaks the transition (e.g. by registering a CG) this is the inner interpreter loop of JPF
    
    Throws:
    
    JPFException
  - resetTransientAttributes
```
protected void resetTransientAttributes()
```
  - executeInstruction
```
public Instruction executeInstruction()
```
    Execute next instruction.
  - executeInstructionHidden
```
public Instruction executeInstructionHidden()
```
    enter instruction hidden from any listeners, and do not record it in the path
  - isPostExec
```
public boolean isPostExec()
```
    is this after calling Instruction.enter() used by instructions and listeners
  - reExecuteInstruction
```
public void reExecuteInstruction()
```
  - willReExecuteInstruction
```
public boolean willReExecuteInstruction()
```
  - skipInstruction
```
public void skipInstruction(Instruction nextInsn)
```
    skip the next bytecode. To be used by listeners to on-the-fly replace instructions
  - skipInstruction
```
@Deprecated
public void skipInstruction()
```
    Deprecated.
    
    skip and continue with the following instruction. This is deprecated because callers should explicitly provide the next instruction (depending on the skipped insn)
  - isInstructionSkipped
```
public boolean isInstructionSkipped()
```
  - skipInstructionLogging
```
public void skipInstructionLogging()
```
  - setNextPC
```
public boolean setNextPC(Instruction insn)
```
    explicitly set the next insn to enter. To be used by listeners that replace bytecode exec (during 'executeInstruction' notification Note this is dangerous because you have to make sure the operand stack is in a consistent state. This also will fail if someone already ordered reexecution of the current instruction
  - executeMethodAtomic
```
public void executeMethodAtomic(StackFrame frame)
```
    Executes a method call. Be aware that it executes the whole method as one atomic step. Arguments have to be already on the provided stack This only works for non-native methods, and does not allow any choice points, so you have to know very well what you are doing. Instructions executed by this method are still fully observable and stored in the path
  - executeMethodHidden
```
public void executeMethodHidden(StackFrame frame)
```
    enter method atomically, but also hide it from listeners and do NOT add executed instructions to the path. this can be even more confusing than executeMethodAtomic(), since nothing prevents such a method from changing the program state, and we wouldn't know for what reason by looking at the trace this method should only be used if we have to enter test application code like hashCode() or equals() from native code, e.g. to silently check property violations executeMethodHidden also acts as an exception firewall, since we don't want any silently executed code fall back into the visible path (for no observable reason)
  - getHeap
```
public Heap getHeap()
```
  - getElementInfo
```
public ElementInfo getElementInfo(int objRef)
```
  - getModifiableElementInfo
```
public ElementInfo getModifiableElementInfo(int ref)
```
  - getBlockedObject
```
public ElementInfo getBlockedObject(MethodInfo mi,
                                    boolean isBeforeCall,
                                    boolean isModifiable)
```
  - setNextChoiceGenerator
```
public boolean setNextChoiceGenerator(ChoiceGenerator<?> cg)
```
  - hasNextChoiceGenerator
```
public boolean hasNextChoiceGenerator()
```
  - checkNextChoiceGeneratorSet
```
public void checkNextChoiceGeneratorSet(java.lang.String msg)
```
  - enter
```
public void enter()
```
    note - this assumes the stackframe of the method to enter is already initialized and on top (pushed)
  - leave
```
public boolean leave()
```
    note - this assumes the stackframe is still on top (not yet popped) return true if any threads became unblocked due to a return from a sync method
  - exit
```
public boolean exit()
```
    this should only be called from the top half of the last DIRECTCALLRETURN of a thread.
    
    Returns:
    
    true - if the thread is done, false - if instruction has to be re-executed
  - createMainThreadObject
```
protected void createMainThreadObject(SystemClassLoaderInfo sysCl)
```
    this is called by the VM upon initialization of the main thread. At this point, we have a tiMain and a java.lang.Thread object, but there is no ThreadGroup yet This method is here to keep all Thread/ThreadGroup field dependencies in one place. The downside of not keeping this in VM is that we can't override in order to have specialized ThreadInfos, but there is no factory for them anyways
  - createMainThreadGroup
```
protected ElementInfo createMainThreadGroup(SystemClassLoaderInfo sysCl)
```
    this creates and inits the main ThreadGroup object, which we have to do explicitly since we can't execute bytecode yet
  - addToThreadGroup
```
protected void addToThreadGroup(ElementInfo eiGroup)
```
    this is used for all thread objects, not just main
  - hash
```
public void hash(HashData hd)
```
  - interrupt
```
public void interrupt()
```
  - setTopFrame
```
public void setTopFrame(StackFrame frame)
```
    replace the top frame - this is a dangerous method that should only be used from Restoreres and to restore operators and locals in post-execution notifications to their pre-execution contents
  - pushFrame
```
public void pushFrame(StackFrame frame)
```
    Adds a new stack frame for a new called method.
  - popFrame
```
public void popFrame()
```
    Removes a stack frame
  - popAndGetModifiableTopFrame
```
public StackFrame popAndGetModifiableTopFrame()
```
  - popAndGetTopFrame
```
public StackFrame popAndGetTopFrame()
```
  - popDirectCallFrame
```
public StackFrame popDirectCallFrame()
```
    removing DirectCallStackFrames is a bit different (only happens from DIRECTCALLRETURN insns)
  - hasReturnedFromDirectCall
```
public boolean hasReturnedFromDirectCall()
```
  - hasReturnedFromDirectCall
```
public boolean hasReturnedFromDirectCall(java.lang.String directCallId)
```
  - getReturnedDirectCall
```
public DirectCallStackFrame getReturnedDirectCall()
```
  - getStateDescription
```
public java.lang.String getStateDescription()
```
  - getThreadObjectClassInfo
```
public ClassInfo getThreadObjectClassInfo()
```
  - printStackContent
```
public void printStackContent()
```
    Prints the content of the stack
  - printStackTrace
```
public void printStackTrace()
```
    Prints current stacktrace information
  - haltOnThrow
```
protected boolean haltOnThrow(java.lang.String exceptionClassName)
```
  - throwStopException
```
protected Instruction throwStopException()
```
  - getHandlerContextFor
```
public HandlerContext getHandlerContextFor(ClassInfo ciException)
```
    this is basically a side-effect free version of throwException to determine if a given exception will be handled.
  - throwException
```
public Instruction throwException(int exceptionObjRef)
```
    unwind stack frames until we find a matching handler for the exception object
  - hasUncaughtHandler
```
public boolean hasUncaughtHandler()
```
    is there any UncaughHandler in effect for this thread? NOTE - this doesn't check if we are already executing one (i.e. it would still handle an exception) or if uncaughtHandlers are enabled within JPF
  - callUncaughtHandler
```
protected Instruction callUncaughtHandler(ExceptionInfo xi)
```
    this explicitly models the standard ThreadGroup.uncaughtException(), but we want to save us a roundtrip if that's the only handler we got. If we would use a handler block in the run()/main() direct call stubs that just delegate to the standard ThreadGroup.uncaughtException(), we would have trouble mapping this to NoUncaughtExceptionProperty violations (which is just a normal printStackTrace() in there).
  - isUncaughtHandlerOnStack
```
protected boolean isUncaughtHandlerOnStack()
```
  - getInstanceUncaughtHandler
```
protected int getInstanceUncaughtHandler()
```
  - getThreadGroupRef
```
protected int getThreadGroupRef()
```
  - getThreadGroupUncaughtHandler
```
protected int getThreadGroupUncaughtHandler(int grpRef)
```
  - getGlobalUncaughtHandler
```
protected int getGlobalUncaughtHandler()
```
  - callUncaughtHandler
```
protected Instruction callUncaughtHandler(ExceptionInfo xi,
                                          int handlerRef,
                                          java.lang.String id)
```
  - popUncaughtHandlerFrame
```
protected StackFrame popUncaughtHandlerFrame()
```
  - unwindTo
```
protected void unwindTo(StackFrame newTopFrame)
```
  - unwindToFirstFrame
```
protected StackFrame unwindToFirstFrame()
```
  - getPendingException
```
public ExceptionInfo getPendingException()
```
  - clearPendingException
```
public void clearPendingException()
```
    watch out - just clearing it might cause an infinite loop if we don't drop frames and/or advance the pc
  - threadDataClone
```
protected ThreadData threadDataClone()
```
    Returns a clone of the thread data. To be called every time we change some ThreadData field (which unfortunately includes lock counts, hence this should be changed)
  - restoreThreadData
```
public void restoreThreadData(ThreadData td)
```
  - reschedule
```
public boolean reschedule(java.lang.String reason)
```
    this is a generic request to reschedule that is not based on instruction type Note that we check for a mandatory CG, i.e. the policy has to return a CG to make sure there is a transition break. We still go through the policy object for selection of scheduling choices though
  - breakTransition
```
public boolean breakTransition(java.lang.String reason)
```
    this is a version that unconditionally breaks the current transition without really adding choices. It only goes on with the same thread (to avoid state explosion). Since we require a break, and there is no choice (current thread is supposed to continue), there is no point going through the SyncPolicy if the current transition is already marked as ignored, this method does nothing
  - breakTransition
```
public boolean breakTransition(boolean isTerminator)
```
    this breaks the current transition with a CG that forces an end state (i.e. has no choices) this only takes effect if the current transition is not already marked as ignored
  - hasOtherRunnables
```
public boolean hasOtherRunnables()
```
  - markUnchanged
```
protected void markUnchanged()
```
  - markTfChanged
```
protected void markTfChanged(StackFrame frame)
```
  - markTdChanged
```
protected void markTdChanged()
```
  - getCallerStackFrame
```
public StackFrame getCallerStackFrame()
```
  - mixinExecutionStateHash
```
public int mixinExecutionStateHash(int h)
```
  - hasDataChanged
```
public boolean hasDataChanged()
```
  - hasStackChanged
```
public boolean hasStackChanged()
```
  - hasChanged
```
public boolean hasChanged()
```
  - getModifiableTopFrame
```
public StackFrame getModifiableTopFrame()
```
    Returns a clone of the top stack frame.
  - getTopFrame
```
public StackFrame getTopFrame()
```
    Returns the top stack frame.
  - getModifiableFrame
```
public StackFrame getModifiableFrame(StackFrame frame)
```
    this replaces all frames up from 'frame' to 'top' with modifiable ones. NOTE - you can't use this AFTER getModifiableTopFrame() since it changes top. Because it is inherently unsafe, it should be used with care and you have to make sure nothing else has stored top references, or respective references are updated after this call. NOTE also that we assume there is no frozen frame on top of an unfrozen one <2do> that should probably be reported as an error since it is a stack consistency violation
  - getStackFrameExecuting
```
public StackFrame getStackFrameExecuting(Instruction insn,
                                         int offset)
```
    note that we don't provide a modifiable version of this. All modifications should only happen in the executing (top) frame
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - isDaemon
```
public boolean isDaemon()
```
  - getMJIEnv
```
public MJIEnv getMJIEnv()
```
  - setPriority
```
public void setPriority(int newPrio)
```
  - getPriority
```
public int getPriority()
```
  - compareTo
```
public int compareTo(ThreadInfo that)
```
    Comparison for sorting based on index.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<ThreadInfo>
  - checkConsistency
```
public void checkConsistency(boolean isStore)
```
    only for debugging purposes
  - checkAssertion
```
protected void checkAssertion(boolean cond,
                              java.lang.String failMsg)
```
  - isSystemThread
```
public boolean isSystemThread()
```

Class ThreadInfo

Nested Class Summary

Field Summary

Fields inherited from class gov.nasa.jpf.vm.InfoObject

Constructor Summary

Method Summary

Methods inherited from class gov.nasa.jpf.vm.InfoObject

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

pendingException

threadData

top

stackDepth

tlIdx

appCtx

id

objRef

ci

targetRef

attributes

executedInstructions

pendingSUTExceptionRequest

returnedDirectCall

nextPc

Constructor Detail

ThreadInfo

ThreadInfo

Method Detail

computeId

init

getMemento

getMemento

getCachedMemento

setCachedMemento

getCurrentThread

isExecutingAtomically

holdsLock

getVM

isEmptyTransitionEnabled

enableEmptyTransition

resetEmptyTransition

isFirstStepInsn

getExecutedInstructions

isPreExec

setState

getState

isRunnable

willBeRunnable

isNew

isTimeoutRunnable

isTimedOut

isTimeoutWaiting

setTimedOut

setTerminated

resetTimedOut

setSleeping

isSleeping

setRunning

setStopped

isCurrentThread

isInCurrentThreadList

isAlive

isWaiting

isWaitingOrTimedOut

isNotified

isUnblocked

isBlocked

isTerminated

isAtomic

setBlockedInAtomicSection

isBlockedOrNotified

isStopped

isInNativeMethod

hasBeenStarted

getStateName

iterator

invokedStackFrames

getStack

getInvokedStackFrames