Package | Description |
---|---|
gov.nasa.jpf | |
gov.nasa.jpf.jvm | |
gov.nasa.jpf.jvm.bytecode | |
gov.nasa.jpf.listener | |
gov.nasa.jpf.util | |
gov.nasa.jpf.util.json | |
gov.nasa.jpf.vm | |
gov.nasa.jpf.vm.serialize |
Modifier and Type | Method and Description |
---|---|
void |
PropertyListenerAdapter.classLoaded(VM vm,
ClassInfo loadedClass) |
void |
ListenerAdapter.classLoaded(VM vm,
ClassInfo loadedClass) |
Modifier and Type | Class and Description |
---|---|
class |
JVMClassInfo
a ClassInfo that was created from a Java classfile
|
Modifier and Type | Method and Description |
---|---|
protected ClassInfo |
JVMClassInfo.createAnnotationProxy(String proxyName) |
ClassInfo |
JVMClassFileContainer.createClassInfo(String typeName,
ClassLoaderInfo classLoader,
String url,
byte[] data) |
ClassInfo |
DefaultJVMClassFactory.createClassInfo(String typeName,
ClassLoaderInfo classLoader,
String url,
byte[] data,
int offset,
int length) |
Modifier and Type | Method and Description |
---|---|
abstract Instruction |
JVMInstructionFactory.invokeclinit(ClassInfo ci) |
void |
JVMCodeBuilder.invokeclinit(ClassInfo ci) |
void |
ClassFileParser.parse(ClassInfo ci) |
Constructor and Description |
---|
JVMClassInfo(ClassInfo ciAnnotation,
String proxyName,
ClassLoaderInfo cli,
String url) |
Modifier and Type | Method and Description |
---|---|
ClassInfo |
StaticFieldInstruction.getClassInfo() |
protected ClassInfo |
INVOKESTATIC.getClassInfo() |
ClassInfo |
INVOKESTATIC.getInvokedClassInfo() |
ClassInfo |
StaticFieldInstruction.getLastClassInfo() |
Modifier and Type | Method and Description |
---|---|
Instruction |
InstructionFactory.invokeclinit(ClassInfo ci) |
Constructor and Description |
---|
INVOKECLINIT(ClassInfo ci) |
Modifier and Type | Method and Description |
---|---|
protected void |
Perturbator.addFieldPerturbations(Perturbator.FieldPerturbation p,
ClassInfo ci,
FieldInfo[] fieldInfos) |
void |
CoverageAnalyzer.classLoaded(VM vm,
ClassInfo ci)
print uncovered source ranges
|
void |
CGRemover.classLoaded(VM vm,
ClassInfo loadedClass) |
void |
OOMEInjector.classLoaded(VM vm,
ClassInfo loadedClass) |
void |
ExceptionInjector.classLoaded(VM vm,
ClassInfo loadedClass)
get the target insns/methods
|
void |
StopWatchFuzzer.classLoaded(VM vm,
ClassInfo ci) |
void |
Perturbator.classLoaded(VM vm,
ClassInfo loadedClass) |
protected void |
CGRemover.processClass(ClassInfo ci,
gov.nasa.jpf.listener.CGRemover.Category cat) |
Modifier and Type | Method and Description |
---|---|
ClassInfo |
TypeRef.getClassInfo()
obtain the ClassInfo (JPF class) for this ref.
|
Modifier and Type | Method and Description |
---|---|
boolean |
InstructionFactoryFilter.isInstrumentedClass(ClassInfo ci) |
boolean |
FeatureSpec.isMatchingType(ClassInfo ci) |
boolean |
TypeSpec.matches(ClassInfo ci) |
Constructor and Description |
---|
InstructionFactoryFilter(String[] includeCls,
String[] excludeCls,
ClassInfo rootCls,
ClassInfo leafCls) |
Modifier and Type | Method and Description |
---|---|
int |
JSONObject.createArray(MJIEnv env,
ClassInfo ciArray,
Value value,
ChoiceGenerator<?>[] cgs,
String prefix) |
int |
JSONObject.fillObject(MJIEnv env,
ClassInfo ci,
ChoiceGenerator<?>[] cgs,
String prefix) |
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 ClassInfo |
SystemClassLoaderInfo.charArrayClassInfo |
protected ClassInfo |
FieldInfo.ci |
protected ClassInfo |
ThreadInfo.ci |
protected ClassInfo |
MethodInfo.ci
Class the method belongs to
|
protected ClassInfo |
ElementInfo.ci |
protected ClassInfo |
SystemClassLoaderInfo.classClassInfo |
protected ClassInfo |
ClassLoaderInfo.classInfo |
protected ClassInfo |
SystemClassLoaderInfo.classLoaderClassInfo |
protected ClassInfo |
SystemClassLoaderInfo.enumClassInfo |
protected ClassInfo |
SystemClassLoaderInfo.objectClassInfo |
protected ClassInfo |
SystemClassLoaderInfo.refClassInfo |
protected ClassInfo |
SystemClassLoaderInfo.stringClassInfo |
protected ClassInfo |
ClassInfo.superClass
we only set the superClassName upon creation, it is instantiated into
a ClassInfo by resolveReferencedClass(), which is required to be called before
we can createAndInitialize objects of this type
|
protected ClassInfo |
SystemClassLoaderInfo.threadClassInfo |
protected ClassInfo |
SystemClassLoaderInfo.threadGroupClassInfo |
protected ClassInfo |
SystemClassLoaderInfo.weakRefClassInfo |
Modifier and Type | Field and Description |
---|---|
protected Set<ClassInfo> |
ClassInfo.interfaces |
protected Map<String,ClassInfo> |
ClassLoaderInfo.resolvedClasses |
Modifier and Type | Method and Description |
---|---|
ClassInfo |
ClassInfo.cloneFor(ClassLoaderInfo cl)
It creates an instance from a original ClassInfo instance.
|
protected ClassInfo |
ClassInfo.createAnnotationProxy(String proxyName) |
ClassInfo |
ClassFileMatch.createClassInfo(ClassLoaderInfo classLoader) |
abstract ClassInfo |
ClassFileContainer.createClassInfo(String typeName,
ClassLoaderInfo classLoader,
String url,
byte[] data) |
ClassInfo |
ClassFactory.createClassInfo(String typeName,
ClassLoaderInfo classLoader,
String url,
byte[] buffer,
int offset,
int length)
create a ClassInfo from raw data
|
protected ClassInfo |
ClassLoaderInfo.getAlreadyResolvedClassInfo(String cname) |
ClassInfo |
ClassInfo.getAnnotationProxy() |
protected ClassInfo |
GenericHeap.getArrayClassInfo(ThreadInfo ti,
String elementType) |
protected ClassInfo |
SystemClassLoaderInfo.getCharArrayClassInfo() |
protected ClassInfo |
SystemClassLoaderInfo.getClassClassInfo() |
ClassInfo |
FieldInfo.getClassInfo()
Returns the class that this field is associated with.
|
ClassInfo |
ThreadInfo.getClassInfo()
Returns the class information.
|
ClassInfo |
ClassInfo.getClassInfo()
required by InfoObject interface
|
ClassInfo |
MethodInfo.getClassInfo()
Returns the class the method belongs to.
|
ClassInfo |
ClassLoaderInfo.getClassInfo()
Returns the type of the corresponding class loader object
|
ClassInfo |
ElementInfo.getClassInfo() |
ClassInfo |
StackFrame.getClassInfo() |
ClassInfo |
ThreadInfo.getClassInfo(int objref) |
ClassInfo |
ClassLoaderInfo.getClassInfo(int id) |
ClassInfo |
MJIEnv.getClassInfo(int objref) |
ClassInfo |
VM.getClassInfo(int objref) |
protected ClassInfo |
SystemClassLoaderInfo.getClassLoaderClassInfo() |
ClassInfo |
ClassInfo.getComponentClassInfo() |
static ClassInfo |
ClassLoaderInfo.getCurrentResolvedClassInfo(String clsName) |
protected ClassInfo |
ClassLoaderInfo.getDefinedClassInfo(String typeName) |
ClassInfo |
ClassInfo.getEnclosingClassInfo()
beware - this loads (but not yet registers) the enclosing class
|
protected ClassInfo |
SystemClassLoaderInfo.getEnumClassInfo() |
ClassInfo |
ThreadInfo.getExecutingClassInfo()
return the ClassInfo of the topmost stackframe that is not a direct call
|
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) |
ClassInfo[] |
ClassInfo.getInnerClassInfos() |
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
|
protected ClassInfo |
SystemClassLoaderInfo.getObjectClassInfo() |
protected ClassInfo |
SystemClassLoaderInfo.getReferenceClassInfo() |
ClassInfo |
MJIEnv.getReferredClassInfo(int clsObjRef) |
ClassInfo |
ClassLoaderInfo.getResolvedAnnotationProxy(ClassInfo ciAnnotation) |
ClassInfo |
ClassLoaderInfo.getResolvedClassInfo(String className)
obtain ClassInfo object for given class name
if the requested class or any of its superclasses and interfaces
is not found this method will throw a ClassInfoException.
|
ClassInfo |
SystemClassLoaderInfo.getResolvedClassInfo(String clsName) |
ClassInfo |
ClassLoaderInfo.getResolvedClassInfo(String className,
byte[] data,
int offset,
int length)
this is for user defined ClassLoaders that explicitly provide the class file data
|
protected ClassInfo |
SystemClassLoaderInfo.getStringClassInfo() |
ClassInfo |
ClassInfo.getSuperClass()
Return the super class.
|
ClassInfo |
ClassInfo.getSuperClass(String clsName)
return the ClassInfo for the provided superclass name.
|
static ClassInfo |
ClassLoaderInfo.getSystemResolvedClassInfo(String clsName) |
protected ClassInfo |
SystemClassLoaderInfo.getThreadClassInfo() |
protected ClassInfo |
SystemClassLoaderInfo.getThreadGroupClassInfo() |
ClassInfo |
ThreadInfo.getThreadObjectClassInfo() |
ClassInfo |
FieldInfo.getTypeClassInfo() |
protected ClassInfo |
SystemClassLoaderInfo.getWeakReferenceClassInfo() |
ClassInfo |
ClassLoaderInfo.loadClass(String cname) |
ClassInfo |
SystemClassLoaderInfo.loadClass(String cname) |
protected ClassInfo |
ClassLoaderInfo.loadClassOnJPF(String typeName) |
protected ClassInfo |
ClassLoaderInfo.loadClassOnJVM(String cname) |
protected ClassInfo |
ClassInfo.loadSuperClass(String superName) |
protected ClassInfo |
ClassLoaderInfo.loadSystemClass(String clsName) |
protected ClassInfo |
SystemClassLoaderInfo.loadSystemClass(String typeName) |
ClassInfo |
ThreadInfo.resolveReferencedClass(String clsName) |
ClassInfo |
ClassInfo.resolveReferencedClass(String cname)
get a ClassInfo for a referenced type that is resolved with the same classLoader, but make
sure we only do this once per path
This method is called by the following bytecode instructions:
anewarray, checkcast, getstatic, instanceof, invokespecial,
invokestatic, ldc, ldc_w, multianewarray, new, and putstatic
It loads the class referenced by these instructions and adds it to the
resolvedClasses map of the classLoader
|
ClassInfo |
ClassLoaderInfo.tryGetResolvedClassInfo(String className)
obtain ClassInfo from context that does not care about resolution, i.e.
|
Modifier and Type | Method and Description |
---|---|
Set<ClassInfo> |
ClassInfo.getAllInterfaceClassInfos()
not very efficient, but chances are we cache the allInterfaces, and then
repetitive use would be faster
|
Set<ClassInfo> |
ClassInfo.getInterfaceClassInfos() |
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
|
Iterator<ClassInfo> |
ClassLoaderInfo.iterator()
Returns an iterator over the classes that are defined (directly loaded) by this
classloader.
|
protected Set<ClassInfo> |
ClassInfo.loadInterfaces(String[] ifcNames) |
Modifier and Type | Method and Description |
---|---|
protected void |
ClassLoaderInfo.addResolvedClass(ClassInfo ci) |
void |
VMListener.classLoaded(VM vm,
ClassInfo loadedClass)
new class was loaded.
|
protected int |
OVStatics.computeId(ClassInfo ci) |
Instruction |
ThreadInfo.createAndThrowException(ClassInfo ci,
String details)
Creates and throws an exception.
|
protected ElementInfo |
GenericHeap.createArray(String elementType,
int nElements,
ClassInfo ci,
ThreadInfo ti,
int objref) |
Fields |
DefaultFieldsFactory.createArrayFields(String type,
ClassInfo ci,
int nElements,
int typeSize,
boolean isReferenceArray) |
Fields |
FieldsFactory.createArrayFields(String type,
ClassInfo ci,
int nElements,
int typeSize,
boolean isReferenceArray) |
protected DynamicElementInfo |
GenericHeap.createElementInfo(int objref,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti) |
Fields |
DefaultFieldsFactory.createInstanceFields(ClassInfo ci) |
Fields |
FieldsFactory.createInstanceFields(ClassInfo ci) |
protected ElementInfo |
GenericHeap.createObject(ClassInfo ci,
ThreadInfo ti,
int objref) |
static int |
JPF_java_lang_ClassLoader.createPackageObject(MJIEnv env,
ClassInfo pkgClass,
String pkgName,
ClassLoaderInfo cl) |
protected StaticElementInfo |
OVStatics.createStaticElementInfo(int id,
ClassInfo ci,
ThreadInfo ti,
ElementInfo eiClsObj) |
Fields |
DefaultFieldsFactory.createStaticFields(ClassInfo ci) |
Fields |
FieldsFactory.createStaticFields(ClassInfo ci) |
AllocationContext |
HashedAllocationContext.extend(ClassInfo ci,
int anchor) |
AllocationContext |
AllocationContext.extend(ClassInfo ci,
int anchor) |
AllocationContext |
PreciseAllocationContext.extend(ClassInfo ci,
int anchor) |
static int |
JPF_java_lang_Class.getClassObject(MJIEnv env,
ClassInfo ci) |
HandlerContext |
ThreadInfo.getHandlerContextFor(ClassInfo ciException)
this is basically a side-effect free version of throwException to determine if a given
exception will be handled.
|
ExceptionHandler |
MethodInfo.getHandlerFor(ClassInfo ciException,
Instruction insn) |
FieldInfo |
FieldInfo.getInstanceFor(ClassInfo ci)
Creates a field for a given class, by cloning this FieldInfo
and reseting the class that the field belongs to
|
MethodInfo |
MethodInfo.getInstanceFor(ClassInfo ci)
Creates a method for a given class, by cloning this MethodInfo
and all the instructions belong to the method
|
protected MethodInfo |
VM.getMainEntryMethodInfo(String mthName,
ClassInfo ciMain) |
ClassInfo |
ClassLoaderInfo.getResolvedAnnotationProxy(ClassInfo ciAnnotation) |
double |
MJIEnv.getStaticDoubleField(ClassInfo ci,
String fname) |
int |
MJIEnv.getStaticIntField(ClassInfo ci,
String fname) |
long |
MJIEnv.getStaticLongField(ClassInfo ci,
String fname) |
int |
MJIEnv.getStaticReferenceField(ClassInfo ci,
String fname) |
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 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) |
void |
MJIEnv.handleClinitRequest(ClassInfo ci) |
protected void |
NativePeer.initialize(Class<?> peerClass,
ClassInfo ci,
boolean cacheMethods) |
boolean |
MethodInfo.isClinit(ClassInfo ci) |
boolean |
ThreadInfo.isClinitOnStack(ClassInfo ci) |
boolean |
ClassInfo.isInstanceOf(ClassInfo ci) |
static boolean |
ClassInfo.isObjectClassInfo(ClassInfo ci) |
static boolean |
ClassInfo.isStringClassInfo(ClassInfo ci) |
void |
MethodInfo.linkToClass(ClassInfo ci) |
protected void |
FieldInfo.linkToClass(ClassInfo ci,
int idx,
int off) |
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.
|
int |
MJIEnv.newObject(ClassInfo ci)
check if the ClassInfo is properly initialized
if yes, create a new instance of it but don't call any ctor
if no, throw a ClinitRequired exception
|
ElementInfo |
GenericHeap.newObject(ClassInfo ci,
ThreadInfo ti) |
ElementInfo |
Heap.newObject(ClassInfo ci,
ThreadInfo ti) |
int |
MJIEnv.newObjectOfUncheckedClass(ClassInfo ci)
this creates a new object without checking if the ClassInfo needs
initialization.
|
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.newSystemObject(ClassInfo ci,
ThreadInfo ti,
int anchor) |
ElementInfo |
Heap.newSystemObject(ClassInfo ci,
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) |
protected void |
VM.notifyClassLoaded(ClassInfo ci) |
void |
ClassParser.parse(ClassInfo ci) |
protected void |
VM.registerThreadListCleanup(ClassInfo ciThread) |
boolean |
MJIEnv.requiresClinitExecution(ClassInfo ci)
use this whenever a peer performs an operation on a class that might not be initialized yet
Do a repeatInvocation() in this case
|
boolean |
Instruction.requiresClinitExecution(ThreadInfo ti,
ClassInfo ci)
this is a misnomer - we actually push the clinit calls here in case
we need some.
|
void |
Attributor.setElementInfoAttributes(ClassInfo ci) |
void |
DefaultAttributor.setElementInfoAttributes(ClassInfo ci)
answer the type based object attributes for this class.
|
protected void |
SystemClassLoaderInfo.updateCachedClassInfos(ClassInfo ci) |
Modifier and Type | Method and Description |
---|---|
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
|
protected void |
VM.pushClinits(List<ClassInfo> startupClasses,
ThreadInfo tiMain) |
Constructor and Description |
---|
ClassInfo(ClassInfo annotationCls,
String name,
ClassLoaderInfo classLoader,
String url)
createAndInitialize a fully synthetic implementation of an Annotation proxy
|
ClinitRequired(ClassInfo ci) |
DynamicElementInfo(int objref,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti) |
ElementInfo(int id,
ClassInfo c,
Fields f,
Monitor m,
ThreadInfo ti) |
MethodInfo(ClassInfo ci,
String name,
String signature,
int modifiers,
int maxLocals,
int maxStack) |
StaticElementInfo(int id,
ClassInfo ci,
Fields f,
Monitor m,
ThreadInfo ti,
ElementInfo eiClsObj) |
Modifier and Type | Method and Description |
---|---|
void |
DynamicAbstractionSerializer.Attributor.classLoaded(VM vm,
ClassInfo loadedClass) |
protected FinalBitSet |
FilteringSerializer.getInstanceFilterMask(ClassInfo ci) |
protected FinalBitSet |
FilteringSerializer.getInstanceRefMask(ClassInfo ci) |
Iterable<FieldInfo> |
AmmendableFilterConfiguration.getMatchedInstanceFields(ClassInfo ci) |
Iterable<FieldInfo> |
FilterConfiguration.getMatchedInstanceFields(ClassInfo ci) |
Iterable<FieldInfo> |
AmmendableFilterConfiguration.InstanceOverride.getMatchedInstanceFields(ClassInfo ci,
Iterable<FieldInfo> preOverride) |
Iterable<FieldInfo> |
AmmendableFilterConfiguration.getMatchedStaticFields(ClassInfo ci) |
Iterable<FieldInfo> |
FilterConfiguration.getMatchedStaticFields(ClassInfo ci) |
protected FinalBitSet |
FilteringSerializer.getStaticFilterMask(ClassInfo ci) |
protected FinalBitSet |
FilteringSerializer.getStaticRefMask(ClassInfo ci) |
boolean |
AmmendableFilterConfiguration.InstanceOverride.isOverriding(ClassInfo ci) |
protected void |
DynamicAbstractionSerializer.processNamedFields(ClassInfo ci,
Fields fields) |
protected void |
FilteringSerializer.processNamedFields(ClassInfo ci,
Fields fields) |
protected void |
DynamicAbstractionSerializer.processNamedInstanceReferenceFields(ClassInfo ci,
Fields fields) |
protected void |
DynamicAbstractionSerializer.processNamedStaticReferenceFields(ClassInfo ci,
Fields fields) |