gov.nasa.jpf.vm

Interface VMListener

All Superinterfaces:

JPFListener

All Known Implementing Classes:

AssertionProperty, BudgetChecker, CallMonitor, CGMonitor, CGRemover, ChoiceSelector, ChoiceTracker, ConstInsnPathTime, CoverageAnalyzer, DeadlockAnalyzer, DistributedSimpleDot, DynamicAbstractionSerializer.Attributor, EndlessLoopDetector, ErrorTraceGenerator, EventGeneratorFactory, ExceptionInjector, ExecTracker, HeapTracker, IdleFilter, InsnCounter, ListenerAdapter, LockedStackDepth, MethodAnalyzer, MethodTracker, NonSharedChecker, NoStateCycles, NullTracker, NumericValueChecker, ObjectTracker, OOMEInjector, OverlappingMethodAnalyzer, PathOutputMonitor, Perturbator, PreciseRaceDetector, PropertyListenerAdapter, ReferenceLocator, SearchStats, SimpleDot, SimpleIdleFilter, StackDepthChecker, StackTracker, StateCountEstimator, StateExtensionListener, StateSpaceAnalyzer, StateSpaceDot, StateTracker, Statistics, StopWatchFuzzer, Trace, TraceStorer, VarRecorder, VarTracker

public interface VMListener
extends JPFListener

interface to register for callbacks by the VM Observer role in equally named pattern Note that we only have notifications for generic events, NOT for conditions that are property specific, and especially nothing that is just triggered from an extension. If listeners are used to implement high level properties, the notifications should be used to implement properties, not to report some property violation that was detected by JPF

Method Summary

Modifier and Type	Method and Description
void	choiceGeneratorAdvanced(VM vm, ChoiceGenerator<?> currentCG) the next choice was requested from a previously registered ChoiceGenerator NOTE - this notification happens before the KernelState is stored, i.e.
void	choiceGeneratorProcessed(VM vm, ChoiceGenerator<?> processedCG) a ChoiceGnerator has returned all his choices NOTE - this notification happens before the KernelState is stored, i.e.
void	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	choiceGeneratorSet(VM vm, ChoiceGenerator<?> newCG) a new ChoiceGenerator was set, which means we are at the beginning of a new transition.
void	classLoaded(VM vm, ClassInfo loadedClass) new class was loaded.
void	exceptionBailout(VM vm, ThreadInfo currentThread) exception causes top frame to be purged
void	exceptionHandled(VM vm, ThreadInfo currentThread) exception handled by current top frame
void	exceptionThrown(VM vm, ThreadInfo currentThread, ElementInfo thrownException) exception was thrown
void	executeInstruction(VM vm, ThreadInfo currentThread, Instruction instructionToExecute) VM is about to execute the next instruction
void	gcBegin(VM vm)
void	gcEnd(VM vm)
void	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)
void	loadClass(VM vm, ClassFile cf) a new classfile is about to be parsed.
void	methodEntered(VM vm, ThreadInfo currentThread, MethodInfo enteredMethod) method body was entered.
void	methodExited(VM vm, ThreadInfo currentThread, MethodInfo exitedMethod) method body was left.
void	objectCreated(VM vm, ThreadInfo currentThread, ElementInfo newObject) new object was created
void	objectExposed(VM vm, ThreadInfo currentThread, ElementInfo fieldOwnerObject, ElementInfo exposedObject) object becomes reachable through a shared reference 'sharedObject' is the (already shared) owner of the field to which the (yet unshared) 'exposedObject' reference got assigned
void	objectLocked(VM vm, ThreadInfo currentThread, ElementInfo lockedObject) notify if an object lock was taken (this includes automatic surrender during a wait())
void	objectNotify(VM vm, ThreadInfo currentThread, ElementInfo notifyingObject) notify if an object notifies a single waiter
void	objectNotifyAll(VM vm, ThreadInfo currentThread, ElementInfo notifyingObject) notify if an object notifies all waiters
void	objectReleased(VM vm, ThreadInfo currentThread, ElementInfo releasedObject) object was garbage collected (after potential finalization)
void	objectShared(VM vm, ThreadInfo currentThread, ElementInfo sharedObject) object fields accessed by more than one live thread
void	objectUnlocked(VM vm, ThreadInfo currentThread, ElementInfo unlockedObject) notify if an object lock was released (this includes automatic reacquisition after a notify())
void	objectWait(VM vm, ThreadInfo currentThread, ElementInfo waitingObject) notify if a wait() is executed
void	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	threadInterrupted(VM vm, ThreadInfo interruptedThread) thread got interrupted
void	threadNotified(VM vm, ThreadInfo notifiedThread) thread got notified
void	threadScheduled(VM vm, ThreadInfo scheduledThread) new thread was scheduled by VM
void	threadStarted(VM vm, ThreadInfo startedThread) new Thread entered run() method
void	threadTerminated(VM vm, ThreadInfo terminatedThread) Thread exited run() method
void	threadWaiting(VM vm, ThreadInfo waitingThread) thread is waiting for signal
void	vmInitialized(VM vm) VM got initialized (but search is not yet running).

Method Detail

vmInitialized

void vmInitialized(VM vm)

VM got initialized (but search is not yet running). This can be used to do type initialization in listeners, since the ClassLoader mechanism is now functional

executeInstruction

void executeInstruction(VM vm,
                        ThreadInfo currentThread,
                        Instruction instructionToExecute)

VM is about to execute the next instruction

instructionExecuted

void 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)

threadStarted

void threadStarted(VM vm,
                   ThreadInfo startedThread)

new Thread entered run() method

threadBlocked

void 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

threadWaiting

void threadWaiting(VM vm,
                   ThreadInfo waitingThread)

thread is waiting for signal

threadNotified

void threadNotified(VM vm,
                    ThreadInfo notifiedThread)

thread got notified

threadInterrupted

void threadInterrupted(VM vm,
                       ThreadInfo interruptedThread)

thread got interrupted

threadTerminated

void threadTerminated(VM vm,
                      ThreadInfo terminatedThread)

Thread exited run() method

threadScheduled

void threadScheduled(VM vm,
                     ThreadInfo scheduledThread)

new thread was scheduled by VM

loadClass

void loadClass(VM vm,
               ClassFile cf)

a new classfile is about to be parsed. This notification allows replacement of the related classfile data via ClassFile.{get/set}Data() and can be used to do on-the-fly classfile instrumentation with 3rd party libraries

classLoaded

void classLoaded(VM vm,
                 ClassInfo loadedClass)

new class was loaded. This is notified after the ClassInfo has been instantiated, but before the class object is initialized, i.e. clinit is called. The main use for this notification is to identify and store ClassInfos, MethodInfos, FieldInfos or Instructions that are used by listeners etc. in order to enable efficient identify based filters in the performance critical instruction notifications

objectCreated

void objectCreated(VM vm,
                   ThreadInfo currentThread,
                   ElementInfo newObject)

new object was created

objectReleased

void objectReleased(VM vm,
                    ThreadInfo currentThread,
                    ElementInfo releasedObject)

object was garbage collected (after potential finalization)

objectLocked

void objectLocked(VM vm,
                  ThreadInfo currentThread,
                  ElementInfo lockedObject)

notify if an object lock was taken (this includes automatic surrender during a wait())

objectUnlocked

void objectUnlocked(VM vm,
                    ThreadInfo currentThread,
                    ElementInfo unlockedObject)

notify if an object lock was released (this includes automatic reacquisition after a notify())

objectWait

void objectWait(VM vm,
                ThreadInfo currentThread,
                ElementInfo waitingObject)

notify if a wait() is executed

objectNotify

void objectNotify(VM vm,
                  ThreadInfo currentThread,
                  ElementInfo notifyingObject)

notify if an object notifies a single waiter

objectNotifyAll

void objectNotifyAll(VM vm,
                     ThreadInfo currentThread,
                     ElementInfo notifyingObject)

notify if an object notifies all waiters

objectExposed

void objectExposed(VM vm,
                   ThreadInfo currentThread,
                   ElementInfo fieldOwnerObject,
                   ElementInfo exposedObject)

object becomes reachable through a shared reference 'sharedObject' is the (already shared) owner of the field to which the (yet unshared) 'exposedObject' reference got assigned

objectShared

void objectShared(VM vm,
                  ThreadInfo currentThread,
                  ElementInfo sharedObject)

object fields accessed by more than one live thread

gcBegin

void gcBegin(VM vm)

gcEnd

void gcEnd(VM vm)

exceptionThrown

void exceptionThrown(VM vm,
                     ThreadInfo currentThread,
                     ElementInfo thrownException)

exception was thrown

exceptionBailout

void exceptionBailout(VM vm,
                      ThreadInfo currentThread)

exception causes top frame to be purged

exceptionHandled

void exceptionHandled(VM vm,
                      ThreadInfo currentThread)

exception handled by current top frame

choiceGeneratorRegistered

void 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)

choiceGeneratorSet

void choiceGeneratorSet(VM vm,
                        ChoiceGenerator<?> newCG)

a new ChoiceGenerator was set, which means we are at the beginning of a new transition. NOTE - this notification happens before the KernelState is stored, i.e. listeners are NOT allowed to alter the KernelState (e.g. by changing field values or thread states)

choiceGeneratorAdvanced

void choiceGeneratorAdvanced(VM vm,
                             ChoiceGenerator<?> currentCG)

the next choice was requested from a previously registered ChoiceGenerator NOTE - this notification happens before the KernelState is stored, i.e. listeners are NOT allowed to alter the KernelState (e.g. by changing field values or thread states)

choiceGeneratorProcessed

void choiceGeneratorProcessed(VM vm,
                              ChoiceGenerator<?> processedCG)

a ChoiceGnerator has returned all his choices NOTE - this notification happens before the KernelState is stored, i.e. listeners are NOT allowed to alter the KernelState (e.g. by changing field values or thread states)

methodEntered

void methodEntered(VM vm,
                   ThreadInfo currentThread,
                   MethodInfo enteredMethod)

method body was entered. This is notified before the first instruction is executed

methodExited

void methodExited(VM vm,
                  ThreadInfo currentThread,
                  MethodInfo exitedMethod)

method body was left. This is notified after the last instruction had been executed NOTE - this is also notified when a StackFrame is dropped due to unhandled exceptions