//
// Copyright (C) 2013 United States Government as represented by the
// Administrator of the National Aeronautics and Space Administration
// (NASA). All Rights Reserved.
//
// This software is distributed under the NASA Open Source Agreement
// (NOSA), version 1.3. The NOSA has been approved by the Open Source
// Initiative. See the file NOSA-1.3-JPF at the top of the distribution
// directory tree for the complete NOSA document.
//
// THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY
// KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT
// LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO
// SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT
// THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT
// DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE.
//
package gov.nasa.jpf.jvm;
import java.io.File;
import java.io.IOException;
import gov.nasa.jpf.Config;
import gov.nasa.jpf.JPF;
import gov.nasa.jpf.util.JPFLogger;
import gov.nasa.jpf.vm.ClassFileContainer;
import gov.nasa.jpf.vm.ClassInfo;
import gov.nasa.jpf.vm.ClassLoaderInfo;
import gov.nasa.jpf.vm.ClassParseException;
import gov.nasa.jpf.vm.MethodInfo;
import gov.nasa.jpf.vm.SystemClassLoaderInfo;
import gov.nasa.jpf.vm.VM;
/**
* a SystemClassLoaderInfo that reads standard Java classfiles from *.class and *.jar files, and creates code using a concrete
* value JVM instruction set
*/
public class JVMSystemClassLoaderInfo extends SystemClassLoaderInfo {
static JPFLogger log = JPF.getLogger("class");
protected JVMCodeBuilder defaultCodeBuilder;
public JVMSystemClassLoaderInfo (VM vm, int appId) {
super(vm, appId);
defaultCodeBuilder = createDefaultCodeBuilder(config, appId);
// now we can notify
vm.registerClassLoader(this);
}
/**
* override this if you need a different default CodeBuilder
*/
protected JVMCodeBuilder createDefaultCodeBuilder (Config config, int appId) {
String key = config.getIndexableKey("jvm.insn_factory.class", appId);
JVMInstructionFactory insnFactory = config.getEssentialInstance(key, JVMInstructionFactory.class);
return new JVMCodeBuilder(insnFactory);
}
@Override
protected ClassFileContainer createClassFileContainer (String spec) {
int i = spec.indexOf(".jar");
if (i > 0) {
// its a jar
int j = i + 4;
int len = spec.length();
String jarPath;
String pathPrefix = null;
File jarFile;
if (j == len) {
// no path prefix, plain jar
jarPath = spec;
} else {
if (spec.charAt(j) == '/') {
pathPrefix = spec.substring(j);
jarPath = spec.substring(0, j);
} else {
return null;
}
}
jarFile = new File(jarPath);
if (jarFile.isFile()) {
try {
return new JarClassFileContainer(jarFile, pathPrefix);
} catch (IOException ix) {
return null;
}
} else {
return null;
}
} else {
// a dir
File dir = new File(spec);
if (dir.isDirectory()) {
return new DirClassFileContainer(dir);
} else {
return null;
}
}
}
protected void addSystemBootClassPath () {
String v = System.getProperty("sun.boot.class.path");
if (v != null) {
for (String pn : v.split(File.pathSeparator)) {
if (pn != null && !pn.isEmpty()) {
ClassFileContainer cfc = createClassFileContainer(pn);
if (cfc != null) {
cp.addClassFileContainer(cfc);
}
}
}
} else {
// Hmm, maybe we are not executing on OpenJDK
}
}
/**
* this is the main method to create the ClassPath, which is called from the ctor
*/
@Override
protected void initializeSystemClassPath (VM vm, int appId) {
Config conf = vm.getConfig();
File[] pathElements;
// explicit "classpath[.id]" settings have precedence
pathElements = getPathElements(conf, "classpath", appId);
if (pathElements != null) {
for (File f : pathElements) {
addClassPathElement(f.getAbsolutePath());
}
}
// we optionally append boot_classpath
pathElements = getPathElements(conf, "vm.boot_classpath", appId);
if (pathElements != null) {
for (File f : pathElements) {
if (f.getName().equals("<system>")) {
addSystemBootClassPath();
} else {
addClassPathElement( f.getAbsolutePath());
}
}
}
log.info("collected system classpath: ", cp);
}
/**
* override this if you have different CodeBuilders for different types
* NOTE - this CodeBuilder is not completely initialized yet, clients still have to call startMethod(mi) on it
*/
protected JVMCodeBuilder getCodeBuilder (String clsName) {
return defaultCodeBuilder;
}
/**
* used for automatically created code such as AnnotationProxies, direct calls, native calls and run starts
* NOTE - this cannot be called recursively or concurrently
*/
protected JVMCodeBuilder getSystemCodeBuilder (ClassFile cf, MethodInfo mi) {
defaultCodeBuilder.reset(cf, mi);
return defaultCodeBuilder;
}
@Override
protected ClassInfo createClassInfo (String clsName, String url, byte[] data, ClassLoaderInfo definingLoader) throws ClassParseException {
ClassFile cf = new ClassFile(data);
JVMCodeBuilder cb = getCodeBuilder(clsName);
return new JVMClassInfo(null, clsName, definingLoader, cf, url, cb);
}
}