Package | Description |
---|---|
gov.nasa.jpf | |
gov.nasa.jpf.jvm | |
gov.nasa.jpf.jvm.bytecode | |
gov.nasa.jpf.listener | |
gov.nasa.jpf.report | |
gov.nasa.jpf.util.json | |
gov.nasa.jpf.vm | |
gov.nasa.jpf.vm.choice | |
gov.nasa.jpf.vm.serialize |
Modifier and Type | Method and Description |
---|---|
void |
PropertyListenerAdapter.choiceGeneratorRegistered(VM vm,
ChoiceGenerator<?> nextCG,
ThreadInfo currentThread,
Instruction executedInstruction) |
void |
ListenerAdapter.choiceGeneratorRegistered(VM vm,
ChoiceGenerator<?> nextCG,
ThreadInfo currentThread,
Instruction executedInstruction) |
void |
PropertyListenerAdapter.exceptionBailout(VM vm,
ThreadInfo currentThread) |
void |
ListenerAdapter.exceptionBailout(VM vm,
ThreadInfo currentThread) |
void |
PropertyListenerAdapter.exceptionHandled(VM vm,
ThreadInfo currentThread) |
void |
ListenerAdapter.exceptionHandled(VM vm,
ThreadInfo currentThread) |
void |
PropertyListenerAdapter.exceptionThrown(VM vm,
ThreadInfo currentThread,
ElementInfo thrownException) |
void |
ListenerAdapter.exceptionThrown(VM vm,
ThreadInfo currentThread,
ElementInfo thrownException) |
void |
PropertyListenerAdapter.executeInstruction(VM vm,
ThreadInfo currentThread,
Instruction instructionToExecute) |
void |
ListenerAdapter.executeInstruction(VM vm,
ThreadInfo currentThread,
Instruction instructionToExecute) |
void |
PropertyListenerAdapter.instructionExecuted(VM vm,
ThreadInfo currentThread,
Instruction nextInstruction,
Instruction executedInstruction) |
void |
ListenerAdapter.instructionExecuted(VM vm,
ThreadInfo currentThread,
Instruction nextInstruction,
Instruction executedInstruction) |
void |
PropertyListenerAdapter.methodEntered(VM vm,
ThreadInfo currentThread,
MethodInfo enteredMethod) |
void |
ListenerAdapter.methodEntered(VM vm,
ThreadInfo currentThread,
MethodInfo enteredMethod) |
void |
PropertyListenerAdapter.methodExited(VM vm,
ThreadInfo currentThread,
MethodInfo exitedMethod) |
void |
ListenerAdapter.methodExited(VM vm,
ThreadInfo currentThread,
MethodInfo exitedMethod) |
void |
PropertyListenerAdapter.objectCreated(VM vm,
ThreadInfo currentThread,
ElementInfo newObject) |
void |
ListenerAdapter.objectCreated(VM vm,
ThreadInfo currentThread,
ElementInfo newObject) |
void |
PropertyListenerAdapter.objectLocked(VM vm,
ThreadInfo currentThread,
ElementInfo lockedObject) |
void |
ListenerAdapter.objectLocked(VM vm,
ThreadInfo currentThread,
ElementInfo lockedObject) |
void |
PropertyListenerAdapter.objectNotify(VM vm,
ThreadInfo currentThread,
ElementInfo notifyingObject) |
void |
ListenerAdapter.objectNotify(VM vm,
ThreadInfo currentThread,
ElementInfo notifyingObject) |
void |
PropertyListenerAdapter.objectNotifyAll(VM vm,
ThreadInfo currentThread,
ElementInfo notifyingObject) |
void |
ListenerAdapter.objectNotifyAll(VM vm,
ThreadInfo currentThread,
ElementInfo notifyingObject) |
void |
PropertyListenerAdapter.objectReleased(VM vm,
ThreadInfo currentThread,
ElementInfo releasedObject) |
void |
ListenerAdapter.objectReleased(VM vm,
ThreadInfo currentThread,
ElementInfo releasedObject) |
void |
PropertyListenerAdapter.objectUnlocked(VM vm,
ThreadInfo currentThread,
ElementInfo unlockedObject) |
void |
ListenerAdapter.objectUnlocked(VM vm,
ThreadInfo currentThread,
ElementInfo unlockedObject) |
void |
PropertyListenerAdapter.objectWait(VM vm,
ThreadInfo currentThread,
ElementInfo waitingObject) |
void |
ListenerAdapter.objectWait(VM vm,
ThreadInfo currentThread,
ElementInfo waitingObject) |
void |
PropertyListenerAdapter.threadBlocked(VM vm,
ThreadInfo blockedThread,
ElementInfo lock) |
void |
ListenerAdapter.threadBlocked(VM vm,
ThreadInfo blockedThread,
ElementInfo lock) |
void |
PropertyListenerAdapter.threadInterrupted(VM vm,
ThreadInfo interruptedThread) |
void |
ListenerAdapter.threadInterrupted(VM vm,
ThreadInfo interruptedThread) |
void |
PropertyListenerAdapter.threadNotified(VM vm,
ThreadInfo notifiedThread) |
void |
ListenerAdapter.threadNotified(VM vm,
ThreadInfo notifiedThread) |
void |
PropertyListenerAdapter.threadScheduled(VM vm,
ThreadInfo scheduledThread) |
void |
ListenerAdapter.threadScheduled(VM vm,
ThreadInfo scheduledThread) |
void |
PropertyListenerAdapter.threadStarted(VM vm,
ThreadInfo startedThread) |
void |
ListenerAdapter.threadStarted(VM vm,
ThreadInfo startedThread) |
void |
PropertyListenerAdapter.threadTerminated(VM vm,
ThreadInfo terminatedThread) |
void |
ListenerAdapter.threadTerminated(VM vm,
ThreadInfo terminatedThread) |
void |
PropertyListenerAdapter.threadWaiting(VM vm,
ThreadInfo waitingThread) |
void |
ListenerAdapter.threadWaiting(VM vm,
ThreadInfo waitingThread) |
Modifier and Type | Method and Description |
---|---|
DirectCallStackFrame |
JVMClassInfo.createDirectCallStackFrame(ThreadInfo ti,
MethodInfo miCallee,
int nLocals) |
DirectCallStackFrame |
JVMClassInfo.createRunStartStackFrame(ThreadInfo ti,
MethodInfo miRun)
while this is a normal DirectCallStackFrame, it has different code which has to be created here
|
StackFrame |
JVMClassInfo.createStackFrame(ThreadInfo ti,
MethodInfo callee) |
void |
JVMNativeStackFrame.setArguments(ThreadInfo ti) |
protected void |
JVMStackFrame.setCallArguments(ThreadInfo ti)
this sets up arguments from a bytecode caller
|
Modifier and Type | Method and Description |
---|---|
void |
ReturnInstruction.addReturnAttr(ThreadInfo ti,
Object attr) |
void |
LongReturn.addReturnAttr(ThreadInfo ti,
Object attr) |
static int |
MULTIANEWARRAY.allocateArray(Heap heap,
String type,
int[] dim,
ThreadInfo ti,
int d) |
protected Instruction |
ArrayStoreInstruction.checkArrayStoreException(ThreadInfo ti,
ElementInfo ei) |
protected Instruction |
AASTORE.checkArrayStoreException(ThreadInfo ti,
ElementInfo ei) |
protected boolean |
InvokeInstruction.checkSyncCG(ElementInfo ei,
ThreadInfo ti) |
protected boolean |
ArrayElementInstruction.createAndSetArrayCG(ElementInfo ei,
ThreadInfo ti,
int aref,
int idx,
boolean isRead) |
protected boolean |
FieldInstruction.createAndSetSharedFieldAccessCG(ElementInfo eiFieldOwner,
ThreadInfo ti) |
protected boolean |
FieldInstruction.createAndSetSharedObjectExposureCG(ElementInfo eiFieldValue,
ThreadInfo ti) |
Instruction |
LDC.execute(ThreadInfo ti) |
Instruction |
I2F.execute(ThreadInfo ti) |
Instruction |
WIDE.execute(ThreadInfo ti) |
Instruction |
PUTFIELD.execute(ThreadInfo ti) |
Instruction |
DDIV.execute(ThreadInfo ti) |
Instruction |
IADD.execute(ThreadInfo ti) |
Instruction |
ASTORE.execute(ThreadInfo ti) |
Instruction |
DREM.execute(ThreadInfo ti) |
Instruction |
ICONST.execute(ThreadInfo ti) |
Instruction |
FMUL.execute(ThreadInfo ti) |
Instruction |
L2D.execute(ThreadInfo ti) |
Instruction |
FSTORE.execute(ThreadInfo ti) |
Instruction |
LSHR.execute(ThreadInfo ti) |
Instruction |
IOR.execute(ThreadInfo ti) |
Instruction |
ALOAD.execute(ThreadInfo ti) |
Instruction |
FADD.execute(ThreadInfo ti) |
Instruction |
I2S.execute(ThreadInfo ti) |
Instruction |
FREM.execute(ThreadInfo ti) |
Instruction |
L2F.execute(ThreadInfo ti) |
Instruction |
JSR_W.execute(ThreadInfo ti) |
Instruction |
DoubleCompareInstruction.execute(ThreadInfo ti) |
Instruction |
I2B.execute(ThreadInfo ti) |
Instruction |
IREM.execute(ThreadInfo ti) |
Instruction |
POP.execute(ThreadInfo ti) |
Instruction |
L2I.execute(ThreadInfo ti) |
Instruction |
NEW.execute(ThreadInfo ti) |
Instruction |
ISUB.execute(ThreadInfo ti) |
Instruction |
GETSTATIC.execute(ThreadInfo ti) |
Instruction |
DUP2.execute(ThreadInfo ti) |
Instruction |
DCONST.execute(ThreadInfo ti) |
Instruction |
EXECUTENATIVE.execute(ThreadInfo ti) |
Instruction |
MONITORENTER.execute(ThreadInfo ti) |
Instruction |
I2L.execute(ThreadInfo ti) |
Instruction |
I2C.execute(ThreadInfo ti) |
Instruction |
LLOAD.execute(ThreadInfo ti) |
Instruction |
PUTSTATIC.execute(ThreadInfo ti) |
Instruction |
LXOR.execute(ThreadInfo ti) |
Instruction |
DUP2_X1.execute(ThreadInfo ti) |
Instruction |
I2D.execute(ThreadInfo ti) |
Instruction |
DNEG.execute(ThreadInfo ti) |
Instruction |
VirtualInvocation.execute(ThreadInfo ti) |
Instruction |
NOP.execute(ThreadInfo th) |
Instruction |
LSTORE.execute(ThreadInfo ti) |
Instruction |
LOR.execute(ThreadInfo ti) |
Instruction |
FDIV.execute(ThreadInfo ti) |
Instruction |
FCMPL.execute(ThreadInfo ti) |
Instruction |
IAND.execute(ThreadInfo ti) |
Instruction |
INEG.execute(ThreadInfo ti) |
Instruction |
IfInstruction.execute(ThreadInfo ti) |
Instruction |
RET.execute(ThreadInfo ti) |
Instruction |
LDC2_W.execute(ThreadInfo ti) |
Instruction |
NEWARRAY.execute(ThreadInfo ti) |
Instruction |
RETURN.execute(ThreadInfo ti) |
Instruction |
POP2.execute(ThreadInfo ti) |
Instruction |
MONITOREXIT.execute(ThreadInfo ti) |
Instruction |
ILOAD.execute(ThreadInfo ti) |
Instruction |
LCMP.execute(ThreadInfo ti) |
Instruction |
DUP.execute(ThreadInfo th) |
Instruction |
DSUB.execute(ThreadInfo ti) |
Instruction |
SIPUSH.execute(ThreadInfo ti) |
Instruction |
ARRAYLENGTH.execute(ThreadInfo ti) |
Instruction |
ANEWARRAY.execute(ThreadInfo ti) |
Instruction |
D2F.execute(ThreadInfo ti) |
Instruction |
LSHL.execute(ThreadInfo ti) |
Instruction |
SwitchInstruction.execute(ThreadInfo ti) |
Instruction |
INSTANCEOF.execute(ThreadInfo ti) |
Instruction |
NATIVERETURN.execute(ThreadInfo ti) |
Instruction |
DADD.execute(ThreadInfo ti) |
Instruction |
ISHL.execute(ThreadInfo ti) |
Instruction |
DIRECTCALLRETURN.execute(ThreadInfo ti) |
Instruction |
D2L.execute(ThreadInfo ti) |
Instruction |
LMUL.execute(ThreadInfo ti) |
Instruction |
F2I.execute(ThreadInfo ti) |
Instruction |
ISTORE.execute(ThreadInfo ti) |
Instruction |
FCMPG.execute(ThreadInfo ti) |
Instruction |
FNEG.execute(ThreadInfo ti) |
Instruction |
D2I.execute(ThreadInfo ti) |
Instruction |
SWAP.execute(ThreadInfo ti) |
Instruction |
LADD.execute(ThreadInfo ti) |
Instruction |
IINC.execute(ThreadInfo ti) |
Instruction |
IXOR.execute(ThreadInfo ti) |
Instruction |
ReturnInstruction.execute(ThreadInfo ti) |
Instruction |
LAND.execute(ThreadInfo ti) |
Instruction |
ArrayLoadInstruction.execute(ThreadInfo ti) |
Instruction |
LREM.execute(ThreadInfo ti) |
Instruction |
DUP_X2.execute(ThreadInfo ti) |
Instruction |
INVOKECLINIT.execute(ThreadInfo ti) |
Instruction |
BIPUSH.execute(ThreadInfo ti) |
Instruction |
CHECKCAST.execute(ThreadInfo ti) |
Instruction |
FLOAD.execute(ThreadInfo ti) |
Instruction |
F2D.execute(ThreadInfo ti) |
Instruction |
DSTORE.execute(ThreadInfo ti) |
Instruction |
LSUB.execute(ThreadInfo ti) |
Instruction |
IUSHR.execute(ThreadInfo ti) |
Instruction |
DLOAD.execute(ThreadInfo ti) |
Instruction |
LNEG.execute(ThreadInfo ti) |
Instruction |
ArrayStoreInstruction.execute(ThreadInfo ti) |
Instruction |
MULTIANEWARRAY.execute(ThreadInfo ti) |
Instruction |
RUNSTART.execute(ThreadInfo ti) |
Instruction |
F2L.execute(ThreadInfo ti) |
Instruction |
GETFIELD.execute(ThreadInfo ti) |
Instruction |
LDIV.execute(ThreadInfo ti) |
Instruction |
INVOKESPECIAL.execute(ThreadInfo ti) |
Instruction |
FSUB.execute(ThreadInfo ti) |
Instruction |
LCONST.execute(ThreadInfo ti) |
Instruction |
LUSHR.execute(ThreadInfo ti) |
Instruction |
IMUL.execute(ThreadInfo ti) |
Instruction |
DMUL.execute(ThreadInfo ti) |
Instruction |
DUP_X1.execute(ThreadInfo ti) |
Instruction |
ISHR.execute(ThreadInfo ti) |
Instruction |
FCONST.execute(ThreadInfo ti) |
Instruction |
JSR.execute(ThreadInfo ti) |
Instruction |
GOTO.execute(ThreadInfo th) |
Instruction |
IDIV.execute(ThreadInfo ti) |
Instruction |
INVOKESTATIC.execute(ThreadInfo ti) |
Instruction |
ATHROW.execute(ThreadInfo ti) |
Instruction |
ACONST_NULL.execute(ThreadInfo ti) |
Instruction |
INVOKECG.execute(ThreadInfo ti) |
Instruction |
DUP2_X2.execute(ThreadInfo ti) |
Instruction |
SwitchInstruction.executeAllBranches(SystemState ss,
KernelState ks,
ThreadInfo ti)
useful for symbolic execution modes
|
protected Instruction |
IfInstruction.executeBothBranches(SystemState ss,
KernelState ks,
ThreadInfo ti)
use this as a delegatee in overridden executes of derived IfInstructions
(e.g.
|
protected Instruction |
TABLESWITCH.executeConditional(ThreadInfo ti) |
protected Instruction |
SwitchInstruction.executeConditional(ThreadInfo ti) |
Object[] |
InvokeInstruction.getArgumentAttrs(ThreadInfo ti) |
Object |
InvokeInstruction.getArgumentValue(String id,
ThreadInfo ti)
<2do> - this relies on same order of arguments and LocalVariableTable entries, which
seems to hold for javac, but is not required by the VM spec, which only
says that arguments are stored in consecutive slots starting at 0
|
Object[] |
InvokeInstruction.getArgumentValues(ThreadInfo ti)
this is a little helper to find out about call argument values from listeners that
don't want to dig through MethodInfos and Types.
|
int |
ArrayInstruction.getArrayRef(ThreadInfo ti)
only makes sense from an executeInstruction() or instructionExecuted() listener,
it is undefined outside of insn exec notifications
|
int |
InstanceInvocation.getCalleeThis(ThreadInfo ti) |
Object |
InvokeInstruction.getFieldOrArgumentValue(String id,
ThreadInfo ti) |
Object |
VirtualInvocation.getFieldValue(String id,
ThreadInfo ti) |
abstract Object |
InvokeInstruction.getFieldValue(String id,
ThreadInfo ti) |
Object |
INVOKESPECIAL.getFieldValue(String id,
ThreadInfo ti) |
Object |
INVOKESTATIC.getFieldValue(String id,
ThreadInfo ti) |
int |
ArrayElementInstruction.getIndex(ThreadInfo ti) |
MethodInfo |
VirtualInvocation.getInvokedMethod(ThreadInfo ti) |
abstract MethodInfo |
InvokeInstruction.getInvokedMethod(ThreadInfo ti) |
MethodInfo |
INVOKESPECIAL.getInvokedMethod(ThreadInfo th)
we can do some more caching here - the MethodInfo should be const
|
MethodInfo |
INVOKESTATIC.getInvokedMethod(ThreadInfo ti) |
MethodInfo |
VirtualInvocation.getInvokedMethod(ThreadInfo ti,
int objRef) |
<T> T |
ReturnInstruction.getNextReturnAttr(ThreadInfo ti,
Class<T> type,
Object prev) |
<T> T |
LongReturn.getNextReturnAttr(ThreadInfo ti,
Class<T> type,
Object prev) |
Object |
RETURN.getReturnAttr(ThreadInfo ti) |
Object |
NATIVERETURN.getReturnAttr(ThreadInfo ti) |
Object |
ReturnInstruction.getReturnAttr(ThreadInfo ti)
this returns all of them - use either if you know there will be only
one attribute at a time, or check/process result with ObjectList
obviously, this only makes sense from an instructionExecuted(), since
the value is pushed during the enter().
|
Object |
LongReturn.getReturnAttr(ThreadInfo ti)
this returns all of them - use either if you know there will be only
one attribute at a time, or check/process result with ObjectList
obviously, this only makes sense from an instructionExecuted(), since
the value is pushed during the enter().
|
<T> T |
ReturnInstruction.getReturnAttr(ThreadInfo ti,
Class<T> type)
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
|
<T> T |
LongReturn.getReturnAttr(ThreadInfo ti,
Class<T> type)
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
|
Float |
FRETURN.getReturnValue(ThreadInfo ti) |
Object |
DRETURN.getReturnValue(ThreadInfo ti) |
Object |
RETURN.getReturnValue(ThreadInfo ti) |
Object |
ARETURN.getReturnValue(ThreadInfo ti) |
Object |
NATIVERETURN.getReturnValue(ThreadInfo ti) |
Object |
IRETURN.getReturnValue(ThreadInfo ti) |
Object |
LRETURN.getReturnValue(ThreadInfo ti) |
abstract Object |
ReturnInstruction.getReturnValue(ThreadInfo ti) |
ElementInfo |
InstanceInvocation.getThisElementInfo(ThreadInfo ti) |
protected long |
LongArrayStoreInstruction.getValue(ThreadInfo ti) |
boolean |
InvokeInstruction.hasArgumentAttr(ThreadInfo ti,
Class<?> type)
check if there is any argument attr of the specified type
(use this before using any of the more expensive retrievers)
|
boolean |
InvokeInstruction.hasAttrRefArgument(ThreadInfo ti,
Class<?> type)
do we have a reference argument that has an object attribute?
less efficient, but still without object creation
|
boolean |
ReturnInstruction.hasReturnAttr(ThreadInfo ti) |
boolean |
LongReturn.hasReturnAttr(ThreadInfo ti) |
boolean |
ReturnInstruction.hasReturnAttr(ThreadInfo ti,
Class<?> type) |
boolean |
LongReturn.hasReturnAttr(ThreadInfo ti,
Class<?> type) |
boolean |
InvokeInstruction.isCompleted(ThreadInfo ti) |
protected boolean |
VirtualInvocation.isLockOwner(ThreadInfo ti,
ElementInfo ei)
If the current thread already owns the lock, then the current thread can go on.
|
protected boolean |
LockInstruction.isLockOwner(ThreadInfo ti,
ElementInfo ei)
If the current thread already owns the lock, then the current thread can go on.
|
protected boolean |
INVOKESPECIAL.isLockOwner(ThreadInfo ti,
ElementInfo ei)
If the current thread already owns the lock, then the current thread can go on.
|
protected boolean |
FieldInstruction.isLockProtected(ThreadInfo ti,
ElementInfo ei)
is this field supposed to be protected by a lock?
this only gets called if on-the-fly POR is in effect
NOTE this has the side effect of setting FieldLockInfos, which
in turn can be heuristic and volatile (i.e.
|
protected boolean |
StaticFieldInstruction.isNewPorFieldBoundary(ThreadInfo ti) |
protected boolean |
InstanceFieldInstruction.isNewPorFieldBoundary(ThreadInfo ti,
FieldInfo fi,
int objRef) |
protected boolean |
StaticFieldInstruction.isSchedulingRelevant(ThreadInfo ti) |
protected boolean |
InstanceFieldInstruction.isSchedulingRelevant(ThreadInfo ti,
int objRef) |
protected abstract int |
ArrayInstruction.peekArrayRef(ThreadInfo ti) |
protected int |
ARRAYLENGTH.peekArrayRef(ThreadInfo ti) |
protected int |
ArrayLoadInstruction.peekArrayRef(ThreadInfo ti)
only makes sense pre-exec
|
protected int |
ArrayStoreInstruction.peekArrayRef(ThreadInfo ti)
this is for pre-exec use
|
protected int |
LongArrayStoreInstruction.peekArrayRef(ThreadInfo ti) |
ElementInfo |
StaticFieldInstruction.peekElementInfo(ThreadInfo ti)
that's invariant, as opposed to InstanceFieldInstruction, so it's
not really a peek
|
ElementInfo |
PUTFIELD.peekElementInfo(ThreadInfo ti) |
abstract ElementInfo |
InstanceFieldInstruction.peekElementInfo(ThreadInfo ti)
this one can be used from a choiceGeneratorSet() or executeInstruction() context, since
it peeks 'this' from the operand stack (enter didn't pop the value yet)
it' less efficient than getLastElementInfo() from a instructionExecuted context
|
abstract ElementInfo |
FieldInstruction.peekElementInfo(ThreadInfo ti) |
ElementInfo |
GETFIELD.peekElementInfo(ThreadInfo ti) |
protected int |
ArrayLoadInstruction.peekIndex(ThreadInfo ti) |
protected abstract int |
ArrayElementInstruction.peekIndex(ThreadInfo ti) |
protected int |
ArrayStoreInstruction.peekIndex(ThreadInfo ti) |
protected int |
LongArrayStoreInstruction.peekIndex(ThreadInfo ti) |
protected Instruction |
FieldInstruction.put(ThreadInfo ti,
StackFrame frame,
ElementInfo eiFieldOwner) |
protected Instruction |
FieldInstruction.put1(ThreadInfo ti,
StackFrame frame,
ElementInfo eiFieldOwner) |
protected Instruction |
FieldInstruction.put2(ThreadInfo ti,
StackFrame frame,
ElementInfo eiFieldOwner) |
Iterator<?> |
ReturnInstruction.returnAttrIterator(ThreadInfo ti) |
Iterator |
LongReturn.returnAttrIterator(ThreadInfo ti) |
<T> Iterator<T> |
ReturnInstruction.returnAttrIterator(ThreadInfo ti,
Class<T> type) |
<T> Iterator<T> |
LongReturn.returnAttrIterator(ThreadInfo ti,
Class<T> type) |
void |
ReturnInstruction.setReturnAttr(ThreadInfo ti,
Object a)
this replaces all of them - use only if you know
- there will be only one attribute at a time
- you obtained the value you set by a previous getXAttr()
- you constructed a multi value list with ObjectList.createList()
we don't clone since pushing a return value already changed the caller frame
|
void |
LongReturn.setReturnAttr(ThreadInfo ti,
Object a)
this replaces all of them - use only if you know
- there will be only one attribute at a time
- you obtained the value you set by a previous getXAttr()
- you constructed a multi value list with ObjectList.createList()
we don't clone since pushing a return value already changed the caller frame
|
protected void |
InvokeInstruction.setupCallee(ThreadInfo ti,
MethodInfo callee) |
Modifier and Type | Field and Description |
---|---|
protected ThreadInfo |
SimpleDot.lastTi |
Modifier and Type | Method and Description |
---|---|
void |
CGRemover.choiceGeneratorRegistered(VM vm,
ChoiceGenerator<?> nextCG,
ThreadInfo ti,
Instruction executedInsn) |
void |
ExecTracker.exceptionThrown(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
AssertionProperty.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insn) |
void |
VarRecorder.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
StackTracker.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
ChoiceSelector.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
OOMEInjector.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
ExceptionInjector.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
MethodTracker.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
StopWatchFuzzer.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
PreciseRaceDetector.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
void |
Perturbator.executeInstruction(VM vm,
ThreadInfo ti,
Instruction insnToExecute) |
List<ElementInfo> |
LockedStackDepth.getLockedInTopFrame(ThreadInfo thread) |
void |
MethodAnalyzer.instructionExecuted(VM vm,
ThreadInfo thread,
Instruction nextInsn,
Instruction executedInsn) |
void |
InsnCounter.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
IdleFilter.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
VarRecorder.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
CGMonitor.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
CoverageAnalyzer.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
ObjectTracker.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
ReferenceLocator.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
VarTracker.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
OOMEInjector.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction insn,
Instruction executedInsn) |
void |
ExecTracker.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
BudgetChecker.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
CallMonitor.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
NumericValueChecker.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
SimpleIdleFilter.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
StopWatchFuzzer.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
TraceStorer.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
Perturbator.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
protected boolean |
Perturbator.isRelevantCallLocation(ThreadInfo ti,
Perturbator.Perturbation p) |
void |
StackDepthChecker.methodEntered(VM vm,
ThreadInfo thread,
MethodInfo mi) |
void |
HeapTracker.objectCreated(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
ObjectTracker.objectCreated(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
ReferenceLocator.objectCreated(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
LockedStackDepth.objectLocked(VM vm,
ThreadInfo thread,
ElementInfo ei) |
void |
DeadlockAnalyzer.objectLocked(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
DeadlockAnalyzer.objectNotify(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
DeadlockAnalyzer.objectNotifyAll(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
HeapTracker.objectReleased(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
ObjectTracker.objectReleased(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
ReferenceLocator.objectReleased(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
LockedStackDepth.objectUnlocked(VM vm,
ThreadInfo thread,
ElementInfo ei) |
void |
DeadlockAnalyzer.objectUnlocked(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
SimpleDot.objectWait(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
DeadlockAnalyzer.objectWait(VM vm,
ThreadInfo ti,
ElementInfo ei) |
protected void |
ReferenceLocator.printLocation(String msg,
ThreadInfo ti) |
void |
DeadlockAnalyzer.threadBlocked(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
SimpleDot.threadStarted(VM vm,
ThreadInfo ti) |
void |
DeadlockAnalyzer.threadStarted(VM vm,
ThreadInfo ti) |
void |
ChoiceSelector.threadStarted(VM vm,
ThreadInfo ti) |
void |
ExecTracker.threadStarted(VM vm,
ThreadInfo ti) |
void |
TraceStorer.threadStarted(VM vm,
ThreadInfo ti) |
void |
IdleFilter.threadTerminated(VM vm,
ThreadInfo ti) |
void |
DeadlockAnalyzer.threadTerminated(VM vm,
ThreadInfo ti) |
void |
ExecTracker.threadTerminated(VM vm,
ThreadInfo ti) |
Modifier and Type | Method and Description |
---|---|
void |
Statistics.instructionExecuted(VM vm,
ThreadInfo ti,
Instruction nextInsn,
Instruction executedInsn) |
void |
Statistics.objectCreated(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
Statistics.objectReleased(VM vm,
ThreadInfo ti,
ElementInfo ei) |
Modifier and Type | Method and Description |
---|---|
boolean |
JSONObject.requiresClinitExecution(ClassInfo ci,
ThreadInfo ti)
check if all required ClassInfos for this object have been initialized so
that the caller can decide if it has to re-execute before proceeding
NOTE - this currently does not support concrete field types that are subtypes
of the respective field types
|
Modifier and Type | Field and Description |
---|---|
protected ThreadInfo[] |
ThreadList.threads |
protected ThreadInfo |
ChoiceGeneratorBase.ti |
protected ThreadInfo |
PreciseAllocationContext.ti |
Modifier and Type | Method and Description |
---|---|
protected ThreadInfo |
VM.createMainThreadInfo(int id,
ApplicationContext appCtx) |
protected ThreadInfo |
VM.createThreadInfo(int objRef,
int groupRef,
int runnableRef,
int nameRef) |
protected ThreadInfo[] |
PrioritySchedulerFactory.filter(ThreadInfo[] list)
the private filter method to get the topmost prio threads out of the
provided list.
|
protected ThreadInfo[] |
DefaultSchedulerFactory.filter(ThreadInfo[] list)
post process a list of choices.
|
protected ThreadInfo[] |
ContextBoundingSchedulerFactory.filter(ThreadInfo[] list) |
ThreadInfo[] |
MultiProcessVM.getAppThreads(ThreadInfo ti)
Returns all the threads that belong to the same application as ti
|
ThreadInfo[] |
ElementInfo.getBlockedOrWaitingThreads() |
ThreadInfo[] |
Monitor.getBlockedOrWaitingThreads() |
ThreadInfo[] |
ElementInfo.getBlockedThreads() |
ThreadInfo[] |
Monitor.getBlockedThreads() |
static ThreadInfo |
ThreadInfo.getCurrentThread() |
ThreadInfo |
VM.getCurrentThread() |
ThreadInfo |
MJIEnv.getLiveThreadInfoForId(int id) |
ThreadInfo |
MJIEnv.getLiveThreadInfoForObjRef(int id) |
ThreadInfo[] |
MJIEnv.getLiveThreads() |
ThreadInfo[] |
VM.getLiveThreads() |
ThreadInfo[] |
Monitor.getLockedThreads()
Returns the list of locked threads
|
ThreadInfo |
ElementInfo.getLockingThread() |
ThreadInfo |
Monitor.getLockingThread()
Returns the identifier of the thread holding the lock.
|
ThreadInfo[] |
MultiProcessVM.getRunnableAppThreads(ThreadInfo ti) |
ThreadInfo[] |
MultiProcessVM.getRunnableAppThreadsWith(ThreadInfo ti) |
ThreadInfo[] |
MultiProcessVM.getRunnableAppThreadsWithout(ThreadInfo ti) |
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnables(ThreadInfo ti)
get list of all runnable threads in the same process as ti
|
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnables(ThreadInfo ti)
get list of all runnable threads
|
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnablesIfChoices(ThreadInfo ti)
return a list of runnable choices, or null if there is only one,
in the same process as ti
|
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnablesIfChoices(ThreadInfo ti)
return a list of runnable choices, or null if there is only one
|
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnablesWith(ThreadInfo ti) |
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnablesWith(ThreadInfo ti) |
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnablesWithout(ThreadInfo ti) |
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnablesWithout(ThreadInfo ti) |
ThreadInfo[] |
ThreadList.getRunnableThreads() |
ThreadInfo[] |
ThreadList.getRunnableThreads(Predicate<ThreadInfo> pred) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWith(ThreadInfo ti) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWith(ThreadInfo ti,
Predicate<ThreadInfo> pred) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWithout(ThreadInfo ti) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWithout(ThreadInfo ti,
Predicate<ThreadInfo> pred) |
ThreadInfo |
ExceptionInfo.getThread() |
ThreadInfo |
HandlerContext.getThreadInfo() |
ThreadInfo |
ChoiceGeneratorBase.getThreadInfo() |
ThreadInfo |
MJIEnv.getThreadInfo() |
ThreadInfo |
ChoiceGenerator.getThreadInfo() |
ThreadInfo |
Transition.getThreadInfo() |
ThreadInfo |
ThreadList.getThreadInfoForId(int tid) |
ThreadInfo |
MJIEnv.getThreadInfoForId(int id)
NOTE - callers have to be prepared this might return null in case
the thread got already terminated
|
ThreadInfo |
ThreadList.getThreadInfoForObjRef(int objRef) |
ThreadInfo |
MJIEnv.getThreadInfoForObjRef(int id)
NOTE - callers have to be prepared this might return null in case
the thread got already terminated
|
ThreadInfo[] |
ThreadList.getThreads()
Returns the array of threads.
|
ThreadInfo[] |
ElementInfo.getWaitingThreads()
get a cloned list of the waiters for this object
|
ThreadInfo[] |
Monitor.getWaitingThreads() |
protected ThreadInfo |
VM.initializeMainThread(ApplicationContext appCtx,
int tid)
create and initialize the main thread for the given ApplicationContext.
|
ThreadInfo |
ThreadList.locate(int objref) |
Modifier and Type | Method and Description |
---|---|
boolean |
ThreadInfoSet.add(ThreadInfo ti) |
int |
ThreadList.add(ThreadInfo ti)
add a new ThreadInfo if it isn't already in the list.
|
boolean |
TidSet.add(ThreadInfo ti) |
void |
ElementInfo.block(ThreadInfo ti)
from a MONITOR_ENTER or sync INVOKExx if we cannot acquire the lock
note: this is not called from a NOTIFIED_UNBLOCKED state, so we don't have to restore NOTIFIED
|
boolean |
ElementInfo.canLock(ThreadInfo th) |
boolean |
Monitor.canLock(ThreadInfo th)
Returns true if it is possible to lock the monitor.
|
abstract FieldLockInfo |
FieldLockInfo.checkProtection(ThreadInfo ti,
ElementInfo ei,
FieldInfo fi) |
void |
VMListener.choiceGeneratorRegistered(VM vm,
ChoiceGenerator<?> nextCG,
ThreadInfo currentThread,
Instruction executedInstruction)
next ChoiceGenerator was registered, which means this is the end of the current transition
the reason why we have this in addition to the choiceGeneratorSet is that listeners
can reset the registered CG and so force the current transition to continue (although the
listener in this case has to make sure the operand stack is in a consistent state for
continued execution because there might be a bottom half of an Instruction.execute() missing)
|
void |
ConstInsnPathTime.choiceGeneratorRegistered(VM vm,
ChoiceGenerator<?> nextCG,
ThreadInfo ti,
Instruction executedInsn) |
abstract void |
SharedObjectPolicy.cleanupThreadTermination(ThreadInfo ti) |
void |
OverlappingContenderPolicy.cleanupThreadTermination(ThreadInfo ti) |
void |
GlobalTrackingPolicy.cleanupThreadTermination(ThreadInfo ti) |
int |
ThreadInfo.compareTo(ThreadInfo that)
Comparison for sorting based on index.
|
boolean |
ThreadInfoSet.contains(ThreadInfo ti) |
boolean |
ThreadChoiceGenerator.contains(ThreadInfo ti) |
boolean |
ThreadList.contains(ThreadInfo ti) |
boolean |
TidSet.contains(ThreadInfo ti) |
void |
ElementInfo.copyElements(ThreadInfo ti,
ElementInfo eiSrc,
int srcIdx,
int dstIdx,
int length)
this is the backend for System.arraycopy implementations, but since it only
throws general exceptions it can also be used in other contexts that require
type and objRef checking
note that we have to do some additional type checking here because we store
reference arrays as int[], i.e.
|
protected ElementInfo |
GenericHeap.createArray(String elementType,
int nElements,
ClassInfo ci,
ThreadInfo ti,
int objref) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createBeginAtomicCG(ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createBeginAtomicCG(ThreadInfo atomicThread) |
DirectCallStackFrame |
MethodInfo.createDirectCallStackFrame(ThreadInfo ti,
int nLocals) |
DirectCallStackFrame |
ClassInfo.createDirectCallStackFrame(ThreadInfo ti,
MethodInfo callee,
int nLocalSlots) |
protected DynamicElementInfo |
GenericHeap.createElementInfo(int objref,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createEndAtomicCG(ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createEndAtomicCG(ThreadInfo atomicThread) |
protected ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createEnterCG(String id,
ElementInfo ei,
ThreadInfo ti)
the public interface towards the insns
|
protected ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createExitCG(String id,
ElementInfo ei,
ThreadInfo ti) |
FieldLockInfo |
FieldLockInfoFactory.createFieldLockInfo(ThreadInfo ti,
ElementInfo ei,
FieldInfo fi) |
FieldLockInfo |
StatisticFieldLockInfoFactory.createFieldLockInfo(ThreadInfo ti,
ElementInfo ei,
FieldInfo fi) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createInterruptCG(ThreadInfo interruptedThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createInterruptCG(ThreadInfo interruptedThread) |
protected int |
VM.createMainThreadGroup(SystemClassLoaderInfo sysCl,
ThreadInfo tiMain,
int mainThreadRef)
we need to initialize the ThreadGroup object explicitly because the main thread is not yet runnable
|
protected void |
VM.createMainThreadObject(SystemClassLoaderInfo sysCl,
ThreadInfo tiMain)
we need to initialize the Thread object explicitly because the main thread is not yet runnable
|
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createMonitorEnterCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createMonitorEnterCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
ContextBoundingSchedulerFactory.createMonitorEnterCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
PrioritySchedulerFactory.createMonitorExitCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createMonitorExitCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createMonitorExitCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createNotifyAllCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createNotifyAllCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createNotifyCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createNotifyCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
ContextBoundingSchedulerFactory.createNotifyCG(ElementInfo ei,
ThreadInfo ti) |
protected ElementInfo |
GenericHeap.createObject(ClassInfo ci,
ThreadInfo ti,
int objref) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createParkCG(ElementInfo ei,
ThreadInfo tiPark,
boolean isAbsoluteTime,
long timeOut) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createParkCG(ElementInfo ei,
ThreadInfo tiPark,
boolean isAbsoluteTime,
long timeOut) |
DirectCallStackFrame |
MethodInfo.createRunStartStackFrame(ThreadInfo ti) |
DirectCallStackFrame |
ClassInfo.createRunStartStackFrame(ThreadInfo ti,
MethodInfo miRun) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createSharedArrayAccessCG(ElementInfo eiArray,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createSharedArrayAccessCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createSharedFieldAccessCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createSharedFieldAccessCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createSharedObjectExposureCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createSharedObjectExposureCG(ElementInfo ei,
ThreadInfo ti) |
StackFrame |
ClassInfo.createStackFrame(ThreadInfo ti,
MethodInfo callee) |
protected StaticElementInfo |
OVStatics.createStaticElementInfo(int id,
ClassInfo ci,
ThreadInfo ti,
ElementInfo eiClsObj) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createSyncMethodEnterCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createSyncMethodEnterCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createSyncMethodExitCG(ElementInfo ei,
ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createSyncMethodExitCG(ElementInfo ei,
ThreadInfo ti) |
protected void |
VM.createSystemClassLoaderObject(SystemClassLoaderInfo sysCl,
ThreadInfo tiMain) |
protected ThreadInfoSet |
StaticElementInfo.createThreadInfoSet(ThreadInfo ti) |
protected ThreadInfoSet |
DynamicElementInfo.createThreadInfoSet(ThreadInfo ti) |
protected abstract ThreadInfoSet |
ElementInfo.createThreadInfoSet(ThreadInfo ti) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadResumeCG(ThreadInfo resumedThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadResumeCG(ThreadInfo resumedThread) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadSleepCG(ThreadInfo sleepThread,
long millis,
int nanos) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadSleepCG(ThreadInfo sleepThread,
long millis,
int nanos) |
ChoiceGenerator<ThreadInfo> |
PrioritySchedulerFactory.createThreadStartCG(ThreadInfo newThread)
as soon as a higher prio thread becomes runnable, we have to switch
|
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadStartCG(ThreadInfo newThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadStartCG(ThreadInfo newThread) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadStopCG(ThreadInfo stoppedThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadStopCG(ThreadInfo stoppedThread) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadSuspendCG(ThreadInfo suspendedThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadSuspendCG(ThreadInfo suspendedThread) |
ChoiceGenerator<ThreadInfo> |
DistributedSchedulerFactory.createThreadTerminateCG(ThreadInfo terminateThread)
the public interface towards the insns
|
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadTerminateCG(ThreadInfo terminatedThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadTerminateCG(ThreadInfo terminateThread) |
ChoiceGenerator<ThreadInfo> |
ContextBoundingSchedulerFactory.createThreadTerminateCG(ThreadInfo terminateThread) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createThreadYieldCG(ThreadInfo yieldThread) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createThreadYieldCG(ThreadInfo yieldThread) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createUnparkCG(ThreadInfo tiUnparked) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createUnparkCG(ThreadInfo tiUnparked) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createWaitCG(ElementInfo ei,
ThreadInfo ti,
long timeOut) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createWaitCG(ElementInfo ei,
ThreadInfo ti,
long timeOut) |
ChoiceGenerator<ThreadInfo> |
ContextBoundingSchedulerFactory.createWaitCG(ElementInfo ei,
ThreadInfo ti,
long timeOut) |
void |
VMListener.exceptionBailout(VM vm,
ThreadInfo currentThread)
exception causes top frame to be purged
|
void |
VMListener.exceptionHandled(VM vm,
ThreadInfo currentThread)
exception handled by current top frame
|
void |
VMListener.exceptionThrown(VM vm,
ThreadInfo currentThread,
ElementInfo thrownException)
exception was thrown
|
abstract Instruction |
Instruction.execute(ThreadInfo ti)
this is the real workhorse
returns next instruction to enter in this thread
<2do> it's unfortunate we roll every side effect into this method, because
it diminishes the value of the 'executeInstruction' notification: all
insns that require some sort of late binding (InvokeVirtual, GetField, ..)
are not yet fully analyzable (e.g.
|
void |
VMListener.executeInstruction(VM vm,
ThreadInfo currentThread,
Instruction instructionToExecute)
VM is about to execute the next instruction
|
Instruction |
NativeMethodInfo.executeNative(ThreadInfo ti) |
protected ThreadInfo[] |
PrioritySchedulerFactory.filter(ThreadInfo[] list)
the private filter method to get the topmost prio threads out of the
provided list.
|
protected ThreadInfo[] |
DefaultSchedulerFactory.filter(ThreadInfo[] list)
post process a list of choices.
|
protected ThreadInfo[] |
ContextBoundingSchedulerFactory.filter(ThreadInfo[] list) |
ThreadInfo[] |
MultiProcessVM.getAppThreads(ThreadInfo ti)
Returns all the threads that belong to the same application as ti
|
protected Object[] |
NativeMethodInfo.getArguments(ThreadInfo ti)
Get and convert the native method parameters off the ThreadInfo stack.
|
protected ClassInfo |
GenericHeap.getArrayClassInfo(ThreadInfo ti,
String elementType) |
ThreadList.Count |
ThreadList.getCountWithout(ThreadInfo tiExclude) |
static ClassLoaderInfo |
ClassLoaderInfo.getCurrentClassLoader(ThreadInfo ti) |
static ClassInfo |
ClassInfo.getInitializedClassInfo(String clsName,
ThreadInfo ti)
this one is for clients that need to synchronously get an initialized classinfo.
|
ClassInfo |
ClassLoaderInfo.getInitializedClassInfo(String clsName,
ThreadInfo ti)
this one is for clients that need to synchronously get an initialized classinfo.
|
static ClassInfo |
ClassInfo.getInitializedSystemClassInfo(String clsName,
ThreadInfo ti) |
ElementInfo |
ElementInfo.getInstanceWithUpdatedSharedness(ThreadInfo ti)
update referencingThreads and set shared flag accordingly (if not frozen)
NOTE - this might return a new (cloned) ElementInfo in case the state stored/restored
flag has been changed.
|
protected ClassInfo |
VM.getMainClassInfo(SystemClassLoaderInfo sysCl,
String mainClassName,
ThreadInfo tiMain,
List<ClassInfo> list)
this adds the application main class and its supers to the list of startup classes
|
Memento<ThreadInfo> |
MementoFactory.getMemento(ThreadInfo ti) |
Memento<ThreadInfo> |
DefaultMementoRestorer.getMemento(ThreadInfo ti) |
Instruction |
Instruction.getNext(ThreadInfo ti)
this is returning the next Instruction to enter, to be called to obtain
the return value of enter() if this is not a branch insn
Be aware of that we might have had exceptions caused by our execution
(-> lower frame), or we might have had overlaid calls (-> higher frame),
i.e.
|
protected ThreadInfoSet |
GlobalTrackingPolicy.getRegisteredSet(int key,
ThreadInfo allocThread) |
int |
MultiProcessVM.getRunnableAppThreadCount(ThreadInfo ti) |
ThreadInfo[] |
MultiProcessVM.getRunnableAppThreads(ThreadInfo ti) |
ThreadInfo[] |
MultiProcessVM.getRunnableAppThreadsWith(ThreadInfo ti) |
ThreadInfo[] |
MultiProcessVM.getRunnableAppThreadsWithout(ThreadInfo ti) |
protected ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.getRunnableCG(String id,
ThreadInfo ti) |
protected ChoiceGenerator<ThreadInfo> |
ContextBoundingSchedulerFactory.getRunnableCG(String id,
ThreadInfo ti) |
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnables(ThreadInfo ti)
get list of all runnable threads in the same process as ti
|
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnables(ThreadInfo ti)
get list of all runnable threads
|
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnablesIfChoices(ThreadInfo ti)
return a list of runnable choices, or null if there is only one,
in the same process as ti
|
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnablesIfChoices(ThreadInfo ti)
return a list of runnable choices, or null if there is only one
|
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnablesWith(ThreadInfo ti) |
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnablesWith(ThreadInfo ti) |
protected ThreadInfo[] |
DistributedSchedulerFactory.getRunnablesWithout(ThreadInfo ti) |
protected ThreadInfo[] |
DefaultSchedulerFactory.getRunnablesWithout(ThreadInfo ti) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWith(ThreadInfo ti) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWith(ThreadInfo ti,
Predicate<ThreadInfo> pred) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWithout(ThreadInfo ti) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWithout(ThreadInfo ti,
Predicate<ThreadInfo> pred) |
protected List<ClassInfo> |
VM.getStartupSystemClassInfos(SystemClassLoaderInfo sysCl,
ThreadInfo tiMain)
return a list of ClassInfos for essential system types
If system classes are not found, or are not valid JPF model classes, we throw
a JPFConfigException and exit
returned ClassInfos are not yet registered in Statics and don't have class objects
|
protected abstract AllocationContext |
GenericHeap.getSUTAllocationContext(ClassInfo ci,
ThreadInfo ti) |
static AllocationContext |
HashedAllocationContext.getSUTAllocationContext(ClassInfo ci,
ThreadInfo ti)
this one is for allocations that should depend on the SUT thread context (such as all
explicit NEW executions)
|
protected AllocationContext |
GenericSGOIDHeap.getSUTAllocationContext(ClassInfo ci,
ThreadInfo ti) |
static PreciseAllocationContext |
PreciseAllocationContext.getSUTExecutionContext(ClassInfo ci,
ThreadInfo ti) |
protected ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.getSyncCG(String id,
ElementInfo ei,
ThreadInfo ti) |
protected abstract AllocationContext |
GenericHeap.getSystemAllocationContext(ClassInfo ci,
ThreadInfo ti,
int anchor) |
static AllocationContext |
HashedAllocationContext.getSystemAllocationContext(ClassInfo ci,
ThreadInfo ti,
int anchor)
this one is for allocations that should NOT depend on the SUT thread context (such as
automatic allocation of java.lang.Class objects by the VM)
|
protected AllocationContext |
GenericSGOIDHeap.getSystemAllocationContext(ClassInfo ci,
ThreadInfo ti,
int anchor) |
abstract ThreadInfoSet |
SharedObjectPolicy.getThreadInfoSet(ThreadInfo allocThread,
DynamicElementInfo ei) |
ThreadInfoSet |
OverlappingContenderPolicy.getThreadInfoSet(ThreadInfo allocThread,
DynamicElementInfo ei) |
ThreadInfoSet |
GlobalTrackingPolicy.getThreadInfoSet(ThreadInfo allocThread,
DynamicElementInfo ei) |
abstract ThreadInfoSet |
SharedObjectPolicy.getThreadInfoSet(ThreadInfo allocThread,
StaticElementInfo ei) |
ThreadInfoSet |
OverlappingContenderPolicy.getThreadInfoSet(ThreadInfo allocThread,
StaticElementInfo ei) |
ThreadInfoSet |
GlobalTrackingPolicy.getThreadInfoSet(ThreadInfo allocThread,
StaticElementInfo ei) |
Instruction |
VM.handleException(ThreadInfo ti,
int xObjRef)
this is here so that we can intercept it in subclassed VMs
|
boolean |
MultiProcessVM.hasOnlyDaemonRunnablesOtherThan(ThreadInfo ti) |
boolean |
SingleProcessVM.hasOnlyDaemonRunnablesOtherThan(ThreadInfo ti) |
abstract boolean |
VM.hasOnlyDaemonRunnablesOtherThan(ThreadInfo ti) |
boolean |
VM.hasOtherNonDaemonRunnablesThan(ThreadInfo ti) |
boolean |
VM.hasOtherRunnablesThan(ThreadInfo ti) |
static int |
BoxObjectCacheManager.initByteCache(ThreadInfo ti) |
static int |
BoxObjectCacheManager.initCharCache(ThreadInfo ti) |
abstract void |
FieldInfo.initialize(ElementInfo ei,
ThreadInfo ti)
pushClinit the corresponding data in the provided Fields instance
|
void |
BooleanFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
IntegerFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
FloatFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
ShortFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
ByteFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
DoubleFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
ReferenceFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
CharFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
void |
LongFieldInfo.initialize(ElementInfo ei,
ThreadInfo ti) |
boolean |
ClassInfo.initializeClass(ThreadInfo ti)
perform static initialization of class
this recursively initializes all super classes, but NOT the interfaces
|
static int |
BoxObjectCacheManager.initIntCache(ThreadInfo ti) |
static int |
BoxObjectCacheManager.initLongCache(ThreadInfo ti) |
static int |
BoxObjectCacheManager.initShortCache(ThreadInfo ti) |
protected void |
VM.initSystemState(ThreadInfo mainThread) |
void |
VMListener.instructionExecuted(VM vm,
ThreadInfo currentThread,
Instruction nextInstruction,
Instruction executedInstruction)
VM has executed the next instruction
(can be used to analyze branches, monitor PUTFIELD / GETFIELD and
INVOKExx / RETURN instructions)
|
boolean |
Instruction.isCompleted(ThreadInfo ti)
this is for listeners that process instructionExecuted(), but need to
determine if there was a CG registration, an overlayed direct call
(like clinit) etc.
|
boolean |
ElementInfo.isLockedBy(ThreadInfo ti) |
boolean |
ElementInfo.isLocking(ThreadInfo ti) |
boolean |
Monitor.isLocking(ThreadInfo ti) |
boolean |
ElementInfo.isReferencedByThread(ThreadInfo ti) |
boolean |
Instruction.isSchedulingRelevant(SystemState ss,
KernelState ks,
ThreadInfo ti) |
boolean |
ClassInfo.isStaticMethodAbstractionDeterministic(ThreadInfo th,
MethodInfo mi)
Checks if a static method call is deterministic, but only for
abtraction based determinism, due to Bandera.choose() calls
|
boolean |
MethodInfo.isThreadEntry(ThreadInfo ti) |
void |
ElementInfo.lock(ThreadInfo ti)
from a MONITOR_ENTER or sync INVOKExx if we can acquire the lock
|
void |
ElementInfo.lockNotified(ThreadInfo ti)
re-acquire lock after being notified.
|
void |
VMListener.methodEntered(VM vm,
ThreadInfo currentThread,
MethodInfo enteredMethod)
method body was entered.
|
void |
VMListener.methodExited(VM vm,
ThreadInfo currentThread,
MethodInfo exitedMethod)
method body was left.
|
ElementInfo |
GenericHeap.newArray(String elementType,
int nElements,
ThreadInfo ti) |
ElementInfo |
Heap.newArray(String elementType,
int nElements,
ThreadInfo ti) |
StaticElementInfo |
OVStatics.newClass(ClassInfo ci,
ThreadInfo ti,
ElementInfo eiClsObj) |
StaticElementInfo |
Statics.newClass(ClassInfo ci,
ThreadInfo ti,
ElementInfo eiClsObj)
this returns the search global id which is unique within this ClassLoader namespace.
|
ElementInfo |
GenericHeap.newInternString(String str,
ThreadInfo ti) |
ElementInfo |
Heap.newInternString(String str,
ThreadInfo ti) |
ElementInfo |
GenericHeap.newObject(ClassInfo ci,
ThreadInfo ti) |
ElementInfo |
Heap.newObject(ClassInfo ci,
ThreadInfo ti) |
StaticElementInfo |
OVStatics.newStartupClass(ClassInfo ci,
ThreadInfo ti) |
StaticElementInfo |
Statics.newStartupClass(ClassInfo ci,
ThreadInfo ti)
startup classes are registered and initialized in two steps since object
creation has to be deferred until we have at least Object and Class ClassInfos
|
protected ElementInfo |
GenericHeap.newString(ClassInfo ciString,
ClassInfo ciChars,
String str,
ThreadInfo ti,
AllocationContext ctx) |
ElementInfo |
GenericHeap.newString(String str,
ThreadInfo ti) |
ElementInfo |
Heap.newString(String str,
ThreadInfo ti) |
ElementInfo |
GenericHeap.newSystemArray(String elementType,
int nElements,
ThreadInfo ti,
int anchor) |
ElementInfo |
Heap.newSystemArray(String elementType,
int nElements,
ThreadInfo ti,
int anchor) |
ElementInfo |
GenericHeap.newSystemObject(ClassInfo ci,
ThreadInfo ti,
int anchor) |
ElementInfo |
Heap.newSystemObject(ClassInfo ci,
ThreadInfo ti,
int anchor) |
ElementInfo |
GenericHeap.newSystemString(String str,
ThreadInfo ti,
int anchor) |
ElementInfo |
Heap.newSystemString(String str,
ThreadInfo ti,
int anchor) |
ElementInfo |
GenericHeap.newSystemThrowable(ClassInfo ciThrowable,
String details,
int[] stackSnapshot,
int causeRef,
ThreadInfo ti,
int anchor) |
ElementInfo |
Heap.newSystemThrowable(ClassInfo ci,
String details,
int[] stackSnapshot,
int causeRef,
ThreadInfo ti,
int anchor) |
void |
ElementInfo.notifies(SystemState ss,
ThreadInfo ti)
notifies one of the waiters.
|
void |
ElementInfo.notifies(SystemState ss,
ThreadInfo ti,
boolean hasToHoldLock) |
protected void |
VM.notifyChoiceGeneratorRegistered(ChoiceGenerator<?> cg,
ThreadInfo ti) |
protected void |
VM.notifyExceptionBailout(ThreadInfo ti) |
protected void |
VM.notifyExceptionHandled(ThreadInfo ti) |
protected void |
VM.notifyExceptionThrown(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyExecuteInstruction(ThreadInfo ti,
Instruction insn) |
protected void |
VM.notifyInstructionExecuted(ThreadInfo ti,
Instruction insn,
Instruction nextInsn) |
protected void |
VM.notifyMethodEntered(ThreadInfo ti,
MethodInfo mi) |
protected void |
VM.notifyMethodExited(ThreadInfo ti,
MethodInfo mi) |
protected void |
VM.notifyObjectCreated(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyObjectLocked(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyObjectNotifies(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyObjectNotifiesAll(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyObjectReleased(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyObjectUnlocked(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyObjectWait(ThreadInfo ti,
ElementInfo ei) |
protected void |
VM.notifyThreadBlocked(ThreadInfo ti) |
protected void |
VM.notifyThreadInterrupted(ThreadInfo ti) |
protected void |
VM.notifyThreadNotified(ThreadInfo ti) |
protected void |
VM.notifyThreadScheduled(ThreadInfo ti) |
protected void |
VM.notifyThreadStarted(ThreadInfo ti) |
protected void |
VM.notifyThreadTerminated(ThreadInfo ti) |
protected void |
VM.notifyThreadWaiting(ThreadInfo ti) |
void |
VMListener.objectCreated(VM vm,
ThreadInfo currentThread,
ElementInfo newObject)
new object was created
|
void |
VMListener.objectLocked(VM vm,
ThreadInfo currentThread,
ElementInfo lockedObject)
notify if an object lock was taken (this includes automatic
surrender during a wait())
|
void |
VMListener.objectNotify(VM vm,
ThreadInfo currentThread,
ElementInfo notifyingObject)
notify if an object notifies a single waiter
|
void |
VMListener.objectNotifyAll(VM vm,
ThreadInfo currentThread,
ElementInfo notifyingObject)
notify if an object notifies all waiters
|
void |
VMListener.objectReleased(VM vm,
ThreadInfo currentThread,
ElementInfo releasedObject)
object was garbage collected (after potential finalization)
|
void |
VMListener.objectUnlocked(VM vm,
ThreadInfo currentThread,
ElementInfo unlockedObject)
notify if an object lock was released (this includes automatic
reacquisition after a notify())
|
void |
VMListener.objectWait(VM vm,
ThreadInfo currentThread,
ElementInfo waitingObject)
notify if a wait() is executed
|
void |
JPFOutputStream.print(ThreadInfo ti) |
protected boolean |
ClassInfo.pushClinit(ThreadInfo ti)
local class initialization
|
protected void |
VM.pushClinits(List<ClassInfo> startupClasses,
ThreadInfo tiMain) |
protected void |
VM.pushMainEntry(MethodInfo miMain,
String[] args,
ThreadInfo tiMain) |
protected void |
VM.pushMainEntryArgs(MethodInfo miMain,
String[] args,
ThreadInfo tiMain,
DirectCallStackFrame frame) |
boolean |
ClassInfo.pushRequiredClinits(ThreadInfo ti)
check if this class requires clinit execution.
|
StaticElementInfo |
ClassInfo.registerClass(ThreadInfo ti)
this registers a ClassInfo in the corresponding ClassLoader statics so that we can cross-link from
SUT code and access static fields.
|
void |
ElementInfo.registerLockContender(ThreadInfo ti)
threads that will grab our lock on their next execution have to be
registered, so that they can be blocked in case somebody else gets
scheduled
|
int |
VM.registerThread(ThreadInfo ti) |
boolean |
ThreadInfoSet.remove(ThreadInfo ti) |
boolean |
ThreadList.remove(ThreadInfo ti) |
boolean |
TidSet.remove(ThreadInfo ti) |
boolean |
Instruction.requiresClinitExecution(ThreadInfo ti,
ClassInfo ci)
this is a misnomer - we actually push the clinit calls here in case
we need some.
|
void |
ElementInfo.resumeNonlockedWaiter(ThreadInfo ti)
this is for waiters that did not own the lock
|
void |
ThreadList.setAll(ThreadInfo[] threads)
Replaces the array of ThreadInfos.
|
void |
ChoiceGeneratorBase.setContext(ThreadInfo tiCreator) |
void |
ChoiceGenerator.setContext(ThreadInfo tiCreator) |
void |
ClassInfo.setInitializing(ThreadInfo ti) |
void |
SystemState.setStartThread(ThreadInfo ti) |
void |
ChoiceGeneratorBase.setThreadInfo(ThreadInfo ti) |
void |
ChoiceGenerator.setThreadInfo(ThreadInfo ti) |
void |
VMListener.threadBlocked(VM vm,
ThreadInfo blockedThread,
ElementInfo lock)
thread waits to acquire a lock
// NOTE: vm.getLastThreadInfo() does NOT have to be the running thread, as this
// notification can occur as a result of a lock operation in the current thread
|
void |
VMListener.threadInterrupted(VM vm,
ThreadInfo interruptedThread)
thread got interrupted
|
void |
VMListener.threadNotified(VM vm,
ThreadInfo notifiedThread)
thread got notified
|
void |
VMListener.threadScheduled(VM vm,
ThreadInfo scheduledThread)
new thread was scheduled by VM
|
void |
VMListener.threadStarted(VM vm,
ThreadInfo startedThread)
new Thread entered run() method
|
void |
VMListener.threadTerminated(VM vm,
ThreadInfo terminatedThread)
Thread exited run() method
|
void |
VMListener.threadWaiting(VM vm,
ThreadInfo waitingThread)
thread is waiting for signal
|
void |
ElementInfo.unlock(ThreadInfo ti)
from a MONITOR_EXIT or sync method RETURN
release a possibly recursive lock if lockCount goes to zero
|
void |
ElementInfo.unregisterLockContender(ThreadInfo ti)
somebody made up his mind and decided not to enter a synchronized section
of code it had registered before (e.g.
|
static int |
BoxObjectCacheManager.valueOfBoolean(ThreadInfo ti,
boolean b) |
static int |
BoxObjectCacheManager.valueOfByte(ThreadInfo ti,
byte b) |
static int |
BoxObjectCacheManager.valueOfCharacter(ThreadInfo ti,
char c) |
static int |
BoxObjectCacheManager.valueOfInteger(ThreadInfo ti,
int i) |
static int |
BoxObjectCacheManager.valueOfLong(ThreadInfo ti,
long l) |
static int |
BoxObjectCacheManager.valueOfShort(ThreadInfo ti,
short s) |
void |
ElementInfo.wait(ThreadInfo ti,
long timeout)
wait to be notified.
|
void |
ElementInfo.wait(ThreadInfo ti,
long timeout,
boolean hasToHoldLock) |
Modifier and Type | Method and Description |
---|---|
int |
ThreadList.getRunnableThreadCount(Predicate<ThreadInfo> pred) |
ThreadInfo[] |
ThreadList.getRunnableThreads(Predicate<ThreadInfo> pred) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWith(ThreadInfo ti,
Predicate<ThreadInfo> pred) |
ThreadInfo[] |
ThreadList.getRunnableThreadsWithout(ThreadInfo ti,
Predicate<ThreadInfo> pred) |
void |
ThreadInfo.setCachedMemento(Memento<ThreadInfo> memento) |
Constructor and Description |
---|
DynamicElementInfo(int objref,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti) |
ElementInfo(int id,
ClassInfo c,
Fields f,
Monitor m,
ThreadInfo ti) |
StaticElementInfo(int id,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti,
ElementInfo eiClsObj) |
ThreadInfo(VM vm,
int objRef,
int groupRef,
int runnableRef,
int nameRef,
ThreadInfo parent)
the ctor for all explicitly (bytecode) created threads.
|
TidSet(ThreadInfo ti) |
Transition(ChoiceGenerator<?> cg,
ThreadInfo ti) |
UncaughtException(ThreadInfo ti,
int objRef) |
Modifier and Type | Field and Description |
---|---|
protected ThreadInfo[] |
ThreadChoiceFromSet.values |
Modifier and Type | Method and Description |
---|---|
ThreadInfo[] |
ThreadChoiceFromSet.getAllThreadChoices() |
ThreadInfo[] |
ThreadChoiceFromSet.getChoices() |
ThreadInfo |
BreakGenerator.getNextChoice() |
ThreadInfo |
ThreadChoiceFromSet.getNextChoice() |
Modifier and Type | Method and Description |
---|---|
Class<ThreadInfo> |
BreakGenerator.getChoiceType() |
Class<ThreadInfo> |
ThreadChoiceFromSet.getChoiceType() |
ChoiceGenerator<ThreadInfo> |
BreakGenerator.randomize() |
Modifier and Type | Method and Description |
---|---|
boolean |
BreakGenerator.contains(ThreadInfo ti) |
boolean |
ThreadChoiceFromSet.contains(ThreadInfo ti) |
Modifier and Type | Method and Description |
---|---|
ThreadChoiceGenerator |
ThreadChoiceFromSet.reorder(Comparator<ThreadInfo> comparator) |
Constructor and Description |
---|
BreakGenerator(String id,
ThreadInfo ti,
boolean isTerminator) |
ThreadChoiceFromSet(String id,
ThreadInfo[] set,
boolean isSchedulingPoint) |
Modifier and Type | Method and Description |
---|---|
protected void |
DebugCFSerializer.serializeStackFrames(ThreadInfo ti) |
protected void |
TopFrameSerializer.serializeStackFrames(ThreadInfo ti) |
protected void |
FilteringSerializer.serializeStackFrames(ThreadInfo ti) |
protected void |
FilteringSerializer.serializeThreadState(ThreadInfo ti) |