Package | Description |
---|---|
gov.nasa.jpf | |
gov.nasa.jpf.jvm.bytecode | |
gov.nasa.jpf.listener | |
gov.nasa.jpf.report | |
gov.nasa.jpf.util | |
gov.nasa.jpf.vm | |
gov.nasa.jpf.vm.serialize |
Modifier and Type | Method and Description |
---|---|
void |
PropertyListenerAdapter.exceptionThrown(VM vm,
ThreadInfo currentThread,
ElementInfo thrownException) |
void |
ListenerAdapter.exceptionThrown(VM vm,
ThreadInfo currentThread,
ElementInfo thrownException) |
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) |
Modifier and Type | Method and Description |
---|---|
ElementInfo |
InstanceFieldInstruction.getLastElementInfo()
since this is based on getLastThis(), the same context restrictions apply
|
abstract ElementInfo |
FieldInstruction.getLastElementInfo() |
ElementInfo |
InstanceInvocation.getThisElementInfo(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) |
Modifier and Type | Method and Description |
---|---|
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) |
String |
FieldInstruction.getId(ElementInfo ei) |
protected boolean |
VirtualInvocation.isLastUnlock(ElementInfo ei)
If the object will still be owned, then the current thread can go on.
|
protected boolean |
INVOKESPECIAL.isLastUnlock(ElementInfo ei)
If the object will still be owned, then the current thread can go on.
|
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.isSkippedFinalField(ElementInfo ei) |
protected boolean |
InstanceFieldInstruction.isSkippedFinalField(ElementInfo ei) |
protected abstract boolean |
FieldInstruction.isSkippedFinalField(ElementInfo ei) |
protected void |
IALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected void |
CALOAD.push(StackFrame frame,
ElementInfo e,
int index) |
protected void |
BALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected void |
LALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected void |
LongArrayLoadInstruction.push(StackFrame frame,
ElementInfo e,
int index) |
protected void |
AALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected void |
DALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected void |
FALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected void |
SALOAD.push(StackFrame frame,
ElementInfo ei,
int index) |
protected abstract void |
ArrayLoadInstruction.push(StackFrame frame,
ElementInfo e,
int index) |
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) |
protected void |
LASTORE.setField(ElementInfo ei,
int index) |
protected void |
DASTORE.setField(ElementInfo ei,
int index) |
protected void |
CASTORE.setField(ElementInfo ei,
int index) |
protected void |
FASTORE.setField(ElementInfo ei,
int index) |
protected void |
SASTORE.setField(ElementInfo ei,
int index) |
protected void |
BASTORE.setField(ElementInfo ei,
int index) |
protected abstract void |
ArrayStoreInstruction.setField(ElementInfo e,
int index) |
protected void |
IASTORE.setField(ElementInfo ei,
int index) |
protected void |
AASTORE.setField(ElementInfo ei,
int index) |
protected void |
LongArrayStoreInstruction.setField(ElementInfo e,
int index,
long value) |
Modifier and Type | Field and Description |
---|---|
protected ElementInfo |
SimpleDot.lastEi |
Modifier and Type | Method and Description |
---|---|
List<ElementInfo> |
LockedStackDepth.getLockedInTopFrame(ThreadInfo thread) |
Modifier and Type | Method and Description |
---|---|
void |
ExecTracker.exceptionThrown(VM vm,
ThreadInfo ti,
ElementInfo ei) |
int |
LockedStackDepth.getLockedStackDepth(ElementInfo lock) |
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 |
HeapTracker.printElementInfo(ElementInfo ei)
private stuff
|
void |
DeadlockAnalyzer.threadBlocked(VM vm,
ThreadInfo ti,
ElementInfo ei) |
Modifier and Type | Method and Description |
---|---|
void |
Statistics.objectCreated(VM vm,
ThreadInfo ti,
ElementInfo ei) |
void |
Statistics.objectReleased(VM vm,
ThreadInfo ti,
ElementInfo ei) |
Modifier and Type | Method and Description |
---|---|
static Object |
ObjectConverter.javaObjectFromJPFObject(ElementInfo ei) |
Modifier and Type | Class and Description |
---|---|
class |
DynamicElementInfo
A specialized version of ElementInfo that represents heap objects
|
class |
StaticElementInfo
A specialized version of ElementInfo that is used for static fields.
|
Modifier and Type | Field and Description |
---|---|
protected Memento<ElementInfo> |
ElementInfo.cachedMemento |
protected ObjVector<ElementInfo> |
OVStatics.elementInfos |
protected ObjectQueue<ElementInfo> |
GenericHeap.markQueue |
protected ArrayList<ElementInfo> |
GenericHeap.weakRefs |
Modifier and Type | Method and Description |
---|---|
ElementInfo |
ElementInfo.clone() |
protected ElementInfo |
GenericHeap.createArray(String elementType,
int nElements,
ClassInfo ci,
ThreadInfo ti,
int objref) |
protected ElementInfo |
GenericHeap.createObject(ClassInfo ci,
ThreadInfo ti,
int objref) |
ElementInfo |
ElementInfo.deepClone() |
ElementInfo |
PSIMHeap.get(int ref) |
ElementInfo |
OVHeap.get(int ref)
we treat ref < 0 as NULL reference instead of throwing an exception
|
abstract ElementInfo |
GenericHeap.get(int ref)
public getter to access but not change ElementInfos
|
ElementInfo |
Heap.get(int objref) |
ElementInfo |
ThreadInfo.getBlockedObject(MethodInfo mi,
boolean isBeforeCall,
boolean isModifiable) |
ElementInfo |
ClassInfo.getClassObject() |
ElementInfo |
ElementInfo.getDeclaredObjectField(String fname,
String referenceType) |
ElementInfo |
ThreadInfo.getElementInfo(int ref) |
ElementInfo |
MJIEnv.getElementInfo(int objref) |
ElementInfo |
VM.getElementInfo(int objref) |
ElementInfo |
ClassLoaderInfo.getElementInfo(String typeName) |
ElementInfo |
DynamicElementInfo.getEnclosingElementInfo() |
ElementInfo |
ElementInfo.getEnclosingElementInfo() |
ElementInfo |
ExceptionInfo.getException() |
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.
|
ElementInfo |
ThreadInfo.getLockObject() |
ElementInfo |
PSIMHeap.getModifiable(int ref) |
ElementInfo |
OVHeap.getModifiable(int ref) |
abstract ElementInfo |
GenericHeap.getModifiable(int ref)
public getter to access modifiable ElementInfos;
|
ElementInfo |
Heap.getModifiable(int objref) |
ElementInfo |
ClassInfo.getModifiableClassObject() |
ElementInfo |
ThreadInfo.getModifiableElementInfo(int ref) |
ElementInfo |
MJIEnv.getModifiableElementInfo(int objref) |
ElementInfo |
VM.getModifiableElementInfo(int objref) |
ElementInfo |
ClassLoaderInfo.getModifiableElementInfo(String typeName) |
ElementInfo |
StaticElementInfo.getModifiableInstance() |
ElementInfo |
DynamicElementInfo.getModifiableInstance() |
abstract ElementInfo |
ElementInfo.getModifiableInstance() |
ElementInfo |
ThreadInfo.getModifiableThreadObject() |
ElementInfo |
ElementInfo.getObjectField(String fname) |
protected ElementInfo |
StaticElementInfo.getReferencedElementInfo(FieldInfo fi) |
ElementInfo |
ThreadInfo.getThisElementInfo() |
ElementInfo |
ThreadInfo.getThreadObject() |
protected ElementInfo |
GenericHeap.initializeStringObject(String str,
int index,
int vref) |
ElementInfo |
GenericHeap.newArray(String elementType,
int nElements,
ThreadInfo ti) |
ElementInfo |
Heap.newArray(String elementType,
int nElements,
ThreadInfo ti) |
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) |
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) |
Modifier and Type | Method and Description |
---|---|
Memento<ElementInfo> |
ElementInfo.getCachedMemento() |
List<ElementInfo> |
ThreadInfo.getLockedObjects() |
Iterator<ElementInfo> |
PSIMHeap.iterator() |
Iterator<ElementInfo> |
OVHeap.iterator() |
abstract Iterator<ElementInfo> |
GenericHeap.iterator()
return Iterator for all non-null ElementInfo entries
|
Iterator<ElementInfo> |
OVStatics.iterator() |
Iterable<ElementInfo> |
PSIMHeap.liveObjects() |
Iterable<ElementInfo> |
OVHeap.liveObjects() |
abstract Iterable<ElementInfo> |
GenericHeap.liveObjects() |
Iterable<ElementInfo> |
Heap.liveObjects() |
Modifier and Type | Method and Description |
---|---|
abstract FieldLockInfo |
FieldLockInfo.checkProtection(ThreadInfo ti,
ElementInfo ei,
FieldInfo fi) |
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 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.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) |
ChoiceGenerator<ThreadInfo> |
SchedulerFactory.createParkCG(ElementInfo ei,
ThreadInfo tiPark,
boolean isAbsoluteTime,
long timeOut) |
ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.createParkCG(ElementInfo ei,
ThreadInfo tiPark,
boolean isAbsoluteTime,
long timeOut) |
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) |
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) |
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.exceptionThrown(VM vm,
ThreadInfo currentThread,
ElementInfo thrownException)
exception was thrown
|
protected ChoiceGenerator<ThreadInfo> |
DefaultSchedulerFactory.getSyncCG(String id,
ElementInfo ei,
ThreadInfo ti) |
boolean |
ThreadInfo.holdsLock(ElementInfo ei) |
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 |
GenericHeap.isAlive(ElementInfo ei)
check if object is alive.
|
boolean |
Heap.isAlive(ElementInfo ei) |
boolean |
ThreadInfo.isCalleeThis(ElementInfo r) |
boolean |
ElementInfo.isReferencedBySameThreads(ElementInfo eiOther) |
abstract boolean |
SharedObjectPolicy.isShared(ElementInfo ei,
ThreadInfoSet set) |
boolean |
OverlappingContenderPolicy.isShared(ElementInfo ei,
ThreadInfoSet set) |
boolean |
GlobalTrackingPolicy.isShared(ElementInfo ei,
ThreadInfoSet set) |
boolean |
ThreadInfo.isThis(ElementInfo ei) |
boolean |
FieldLockInfo.needsPindown(ElementInfo ei) |
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.
|
void |
MJIEnv.notify(ElementInfo ei) |
void |
MJIEnv.notifyAll(ElementInfo ei) |
protected void |
VM.notifyExceptionThrown(ThreadInfo ti,
ElementInfo ei) |
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) |
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(ElementInfo ei,
FieldInfo fi,
boolean isFiltered) |
void |
JPFOutputStream.print(ElementInfo ei,
FinalBitSet filterMask) |
protected void |
JPFOutputStream.printFields(ElementInfo ei,
FieldInfo[] fields,
FinalBitSet filterMask) |
void |
GenericHeap.ElementInfoMarker.process(ElementInfo ei) |
void |
ClassInfo.processReleaseActions(ElementInfo ei)
recursively process release actions registered for this type or any of
its super types (only classes).
|
void |
GenericHeap.registerWeakReference(ElementInfo ei) |
void |
Heap.registerWeakReference(ElementInfo ei) |
void |
ReleaseAction.release(ElementInfo ei)
object is about to be terminally released (no more finalization etc.)
|
protected void |
PSIMHeap.set(int index,
ElementInfo ei) |
protected void |
OVHeap.set(int index,
ElementInfo ei) |
protected abstract void |
GenericHeap.set(int index,
ElementInfo ei)
internal setter used during allocation
|
protected void |
SystemClassLoaderInfo.setClassLoaderObject(ElementInfo ei) |
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
|
Modifier and Type | Method and Description |
---|---|
void |
ElementInfo.setCachedMemento(Memento<ElementInfo> memento) |
Constructor and Description |
---|
StaticElementInfo(int id,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti,
ElementInfo eiClsObj) |
Modifier and Type | Field and Description |
---|---|
protected ObjectQueue<ElementInfo> |
FilteringSerializer.refQueue |
Modifier and Type | Method and Description |
---|---|
protected int |
CFSerializer.getSerializedReferenceValue(ElementInfo ei) |
protected int |
FilteringSerializer.getSerializedReferenceValue(ElementInfo ei) |
void |
DynamicAbstractionSerializer.process(ElementInfo ei) |
void |
DebugCFSerializer.process(ElementInfo ei) |
void |
FilteringSerializer.process(ElementInfo ei) |
protected void |
CFSerializer.queueReference(ElementInfo ei) |
protected void |
TopFrameSerializer.queueReference(ElementInfo ei) |
protected void |
AdaptiveSerializer.queueReference(ElementInfo ei) |
Modifier and Type | Method and Description |
---|---|
protected void |
FilteringSerializer.serializeLockedObjects(List<ElementInfo> lockedObjects) |