it = ir.iterateAllInstructions(); it.hasNext();) {
+ SSAInstruction s = it.next();
+ if (s instanceof SSAInvokeInstruction) {
+ if (s.toString().indexOf(methodName) > -1) {
+ IntSet indices = ir.getCallInstructionIndices(((SSAInvokeInstruction) s).getCallSite());
+ Assertions.productionAssertion(indices.size()== 1, "expected 1 but got " + indices.size());
+ return new NormalStatement(n, indices.intIterator().next());
+ }
+ }
+ }
+ Assertions.UNREACHABLE("failed to find call to " + methodName + " in " + n);
+ return null;
+ }
+
+ private static Statement findCallToDoNothing(CGNode n) {
+ return findCallTo(n, "doNothing");
+ }
+}
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java
new file mode 100644
index 000000000..91b58e70b
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java
@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright (c) 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.core.tests.util;
+
+public interface TestConstants {
+
+ public final static String WALA_TESTDATA = "wala.testdata.xml";
+
+ public static final String CLASSCONSTANT_MAIN = "LclassConstant/ClassConstant";
+ public static final String PI_TEST_MAIN = "Lpi/PiNodeCallGraphTestCase";
+ public static final String RECURSE_MAIN = "Lrecurse/NList";
+
+ public final static String HELLO = "hello.xml";
+ public final static String HELLO_MAIN = "Lhello/Hello";
+
+ public final static String BCEL = "bcel.xml";
+ public final static String BCEL_VERIFIER_MAIN = "Lorg/apache/bcel/verifier/Verifier";
+
+ public final static String JLEX = "JLex.xml";
+ public final static String JLEX_MAIN = "LJLex/Main";
+
+ public final static String JAVA_CUP = "java_cup.xml";
+ public final static String JAVA_CUP_MAIN = "Ljava_cup/Main";
+
+ public final static String MULTI_DIM_MAIN = "LmultiDim/TestMultiDim";
+
+ public final static String REFLECT1_MAIN = "Lreflection/Reflect1";
+
+ public final static String SLICE1_MAIN = "Lslice/Slice1";
+ public final static String SLICE2_MAIN = "Lslice/Slice2";
+ public final static String SLICE3_MAIN = "Lslice/Slice3";
+ public final static String SLICE4_MAIN = "Lslice/Slice4";
+ public final static String SLICE5_MAIN = "Lslice/Slice5";
+ public final static String SLICE_TESTCD1 = "Lslice/TestCD1";
+ public final static String SLICE_TESTCD2 = "Lslice/TestCD2";
+ public final static String SLICE_TESTCD3 = "Lslice/TestCD3";
+ public final static String SLICE_TESTID = "Lslice/TestId";
+ public final static String SLICE_TESTARRAYS = "Lslice/TestArrays";
+ public final static String SLICE_TESTFIELDS = "Lslice/TestFields";
+ public final static String SLICE_TESTGLOBAL = "Lslice/TestGlobal";
+ public final static String SLICE_TESTMULTITARGET = "Lslice/TestMultiTarget";
+ public final static String SLICE_TESTRECURSION = "Lslice/TestRecursion";
+ public final static String SLICE_TESTTHIN1 = "Lslice/TestThin1";
+
+
+}
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/WalaTestCase.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/WalaTestCase.java
new file mode 100644
index 000000000..94d6891f2
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/WalaTestCase.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.core.tests.util;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.ibm.wala.util.debug.Trace;
+import com.ibm.wala.util.heapTrace.HeapTracer;
+
+/**
+ *
+ * Simple extension to JUnit test case.
+ *
+ * @author sfink
+ */
+public abstract class WalaTestCase extends TestCase {
+
+ final private static boolean ANALYZE_LEAKS = false;
+
+ public static boolean useShortProfile() {
+ String profile = System.getProperty("com.ibm.wala.junit.profile", "long");
+ if (profile.equals("short")) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private String baseTraceFile;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see junit.framework.TestCase#setUp()
+ */
+ protected void setUp() throws Exception {
+ baseTraceFile = Trace.getTraceFile();
+ if (baseTraceFile != null) {
+ Trace.setTraceFile(baseTraceFile + "." + getName());
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see junit.framework.TestCase#tearDown()
+ */
+ protected void tearDown() throws Exception {
+ if (baseTraceFile != null) {
+ Trace.setTraceFile(baseTraceFile);
+ }
+ if (ANALYZE_LEAKS) {
+ HeapTracer.analyzeLeaks();
+ }
+ }
+
+ public WalaTestCase() {
+ super("DomoTestCase");
+ }
+
+ /**
+ * Utility function: each DetoxTestCase subclass can have a main() method that
+ * calls this, to create a test suite consisting of just this test. Useful
+ * when investigating a single failing test.
+ */
+ protected static void justThisTest(Class testClass) {
+ TestSuite suite = new TestSuite(testClass.getName());
+ suite.addTestSuite(testClass);
+ junit.textui.TestRunner.run(suite);
+ }
+
+ /**
+ * @param arg0
+ */
+ public WalaTestCase(String arg0) {
+ super(arg0);
+ }
+
+ protected static void assertBound(String tag, double quantity, double bound) {
+ String msg = tag + ", quantity: " + quantity + ", bound:" + bound;
+ Trace.println(msg);
+ assertTrue(msg, quantity <= bound);
+ }
+
+ protected static void assertBound(String tag, int quantity, int bound) {
+ String msg = tag + ", quantity: " + quantity + ", bound:" + bound;
+ Trace.println(msg);
+ assertTrue(msg, quantity <= bound);
+ }
+
+}
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/analysis/SimpleThreadEscapeAnalysis.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/analysis/SimpleThreadEscapeAnalysis.java
new file mode 100644
index 000000000..1e1fc7aa9
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/analysis/SimpleThreadEscapeAnalysis.java
@@ -0,0 +1,299 @@
+/*******************************************************************************
+ * Copyright (c) 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.analysis;
+
+import com.ibm.wala.classLoader.*;
+import com.ibm.wala.client.impl.*;
+import com.ibm.wala.ipa.callgraph.*;
+import com.ibm.wala.ipa.callgraph.impl.*;
+import com.ibm.wala.ipa.callgraph.propagation.*;
+import com.ibm.wala.ipa.cha.*;
+import com.ibm.wala.types.*;
+import com.ibm.wala.util.collections.HashSetFactory;
+import com.ibm.wala.util.intset.*;
+
+import java.io.*;
+import java.util.*;
+import java.util.jar.*;
+
+/**
+ *
+ * A simple thread-level escape analysis: this code computes the set of classes
+ * of which some instance may be accessed by some thread other than the one that
+ * created it.
+ *
+ *
+ *
+ * The algorithm is not very bright; it is based on the observation that there
+ * are only three ways for an object to pass from one thread to another.
+ *
+ * - The object is stored into a static variable.
+ *
- The object is stored into an instance field of a Thread
+ *
- The object is reachable from a field of another escaping object.
+ *
+ *
+ *
+ *
+ * This observation is implemented in the obvious way:
+ *
+ * - All static fields are collected
+ *
- All Thread constructor parameters are collected
+ *
- The points-to sets of these values represent the base set of escapees.
+ *
- All object reachable from fields of these objects are added
+ *
- This process continues until a fixpoint is reached
+ *
- The abstract objects in the points-to sets are converted to types
+ *
- This set of types is returned
+ *
+ *
+ * @author Julian Dolby
+ */
+public class SimpleThreadEscapeAnalysis extends AbstractAnalysisEngine {
+ private final Set applicationJarFiles;
+
+ private final String applicationMainClass;
+
+ /**
+ * The two input parameters define the program to analyze: the jars of .class
+ * files and the main class to start from.
+ */
+ public SimpleThreadEscapeAnalysis(Set applicationJarFiles, String applicationMainClass) {
+ this.applicationJarFiles = applicationJarFiles;
+ this.applicationMainClass = applicationMainClass;
+ }
+
+ /**
+ * Given a root path, add it to the set if it is a jar, or traverse it
+ * recursively if it is a directory.
+ */
+ private void collectJars(File f, Set result) throws IOException {
+ if (f.isDirectory()) {
+ File[] files = f.listFiles();
+ for (int i = 0; i < files.length; i++) {
+ collectJars(files[i], result);
+ }
+ } else if (f.getAbsolutePath().endsWith(".jar")) {
+ result.add(new JarFile(f));
+ }
+ }
+
+ /**
+ * Collect the set of JarFiles that constitute the system libraries of the
+ * running JRE.
+ */
+ private JarFile[] getSystemJars() throws IOException {
+ Set jarFiles = HashSetFactory.make();
+
+ String javaHomePath = System.getProperty("java.home");
+
+ if (!javaHomePath.endsWith(File.separator)) {
+ javaHomePath = javaHomePath + File.separator;
+ }
+
+ collectJars(new File(javaHomePath + "lib"), jarFiles);
+
+ return jarFiles.toArray(new JarFile[jarFiles.size()]);
+ }
+
+ /**
+ * Take the given set of JarFiles that constitute the program, and return a
+ * set of Module files as expected by the WALA machinery.
+ */
+ private Set getModuleFiles() {
+ Set result = HashSetFactory.make();
+ for (Iterator jars = applicationJarFiles.iterator(); jars.hasNext();) {
+ result.add(new JarFileModule(jars.next()));
+ }
+
+ return result;
+ }
+
+ /**
+ * The heart of the analysis.
+ */
+ public Set gatherThreadEscapingClasses() throws IOException, ClassHierarchyException {
+
+ //
+ // set the application to analyze
+ //
+ setModuleFiles(getModuleFiles());
+
+ //
+ // set the system jar files to use.
+ // change this if you want to use a specific jre version
+ //
+ setJ2SELibraries(getSystemJars());
+
+ //
+ // the application and libraries are set, now build the scope...
+ //
+ buildAnalysisScope();
+
+ //
+ // ...and the class hierarchy
+ //
+ ClassHierarchy cha = buildClassHierarchy();
+ setClassHierarchy(cha);
+
+ //
+ // select the call graph construction algorithm
+ // change this if greater precision is desired
+ // (see com.ibm.wala.client.impl.*BuilderFactory)
+ //
+ setCallGraphBuilderFactory(new ZeroCFABuilderFactory());
+
+ //
+ // entrypoints are where analysis starts
+ //
+ Entrypoints roots = Util.makeMainEntrypoints(getScope(), cha, applicationMainClass);
+
+ //
+ // analysis options controls aspects of call graph construction
+ //
+ AnalysisOptions options = getDefaultOptions(roots);
+
+ //
+ // build the call graph
+ //
+ buildCallGraph(cha, options, true);
+
+ //
+ // extract data for analysis
+ //
+ CallGraph cg = getCallGraph();
+ PointerAnalysis pa = getPointerAnalysis();
+
+ //
+ // collect all places where objects can escape their creating thread:
+ // 1) all static fields
+ // 2) arguments to Thread constructors
+ //
+ Set escapeAnalysisRoots = HashSetFactory.make();
+ HeapModel heapModel = pa.getHeapModel();
+
+ // 1) static fields
+ for (Iterator clss = cha.iterateAllClasses(); clss.hasNext();) {
+ IClass cls = (IClass) clss.next();
+ Collection staticFields = cls.getDeclaredStaticFields();
+ for (Iterator sfs = staticFields.iterator(); sfs.hasNext();) {
+ IField sf = (IField) sfs.next();
+ if (sf.getFieldTypeReference().isReferenceType()) {
+ escapeAnalysisRoots.add(heapModel.getPointerKeyForStaticField(sf));
+ }
+ }
+ }
+
+ // 2) instance fields of Threads
+ // (we hack this by getting the 'this' parameter of all ctor calls;
+ // this works because the next phase will add all objects transitively
+ // reachable from fields of types in these pointer keys, and all
+ // Thread objects must be constructed somewhere)
+ Collection threads = cha.computeSubClasses(TypeReference.JavaLangThread);
+ for (Iteratorclss = threads.iterator(); clss.hasNext();) {
+ IClass cls = (IClass) clss.next();
+ for (Iterator ms = cls.getDeclaredMethods(); ms.hasNext();) {
+ IMethod m = (IMethod) ms.next();
+ if (m.isInit()) {
+ Set nodes = cg.getNodes(m.getReference());
+ for (Iterator ns = nodes.iterator(); ns.hasNext();) {
+ CGNode n = (CGNode) ns.next();
+ escapeAnalysisRoots.add(heapModel.getPointerKeyForLocal(n, 1));
+ }
+ }
+ }
+ }
+
+ //
+ // compute escaping types: all types flowing to escaping roots and
+ // all types transitively reachable through their fields.
+ //
+ Set escapingInstanceKeys = HashSetFactory.make();
+
+ //
+ // pass 1: get abstract objects (instance keys) for escaping locations
+ //
+ for (Iterator rts = escapeAnalysisRoots.iterator(); rts.hasNext();) {
+ PointerKey root = rts.next();
+ OrdinalSet objects = pa.getPointsToSet(root);
+ for (Iterator objs = objects.iterator(); objs.hasNext();) {
+ InstanceKey obj = (InstanceKey) objs.next();
+ escapingInstanceKeys.add(obj);
+ }
+ }
+
+ //
+ // passes 2+: get fields of escaping keys, and add pointed-to keys
+ //
+ Set newKeys = HashSetFactory.make();
+ do {
+ newKeys.clear();
+ for (Iterator keys = escapingInstanceKeys.iterator(); keys.hasNext();) {
+ InstanceKey key = keys.next();
+ IClass type = key.getConcreteType();
+ if (type.isReferenceType()) {
+ if (type.isArrayClass()) {
+ if (((ArrayClass) type).getElementClass() != null) {
+ PointerKey fk = heapModel.getPointerKeyForArrayContents(key);
+ OrdinalSet fobjects = pa.getPointsToSet(fk);
+ for (Iterator fobjs = fobjects.iterator(); fobjs.hasNext();) {
+ InstanceKey fobj = (InstanceKey) fobjs.next();
+ if (!escapingInstanceKeys.contains(fobj)) {
+ newKeys.add(fobj);
+ }
+ }
+ }
+ } else {
+ Collection fields = type.getAllInstanceFields();
+ for (Iterator fs = fields.iterator(); fs.hasNext();) {
+ IField f = (IField) fs.next();
+ if (f.getFieldTypeReference().isReferenceType()) {
+ PointerKey fk = heapModel.getPointerKeyForInstanceField(key, f);
+ OrdinalSet fobjects = pa.getPointsToSet(fk);
+ for (Iterator fobjs = fobjects.iterator(); fobjs.hasNext();) {
+ InstanceKey fobj = (InstanceKey) fobjs.next();
+ if (!escapingInstanceKeys.contains(fobj)) {
+ newKeys.add(fobj);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ escapingInstanceKeys.addAll(newKeys);
+ } while (!newKeys.isEmpty());
+
+ //
+ // get set of types from set of instance keys
+ //
+ Set escapingTypes = HashSetFactory.make();
+ for (Iterator keys = escapingInstanceKeys.iterator(); keys.hasNext();) {
+ InstanceKey key = keys.next();
+ escapingTypes.add(key.getConcreteType());
+ }
+
+ return escapingTypes;
+ }
+
+ public static void main(String[] args) throws IOException, ClassHierarchyException {
+ String mainClassName = args[0];
+
+ Set jars = HashSetFactory.make();
+ for (int i = 1; i < args.length; i++) {
+ jars.add(new JarFile(args[i]));
+ }
+
+ Set escapingTypes = (new SimpleThreadEscapeAnalysis(jars, mainClassName)).gatherThreadEscapingClasses();
+
+ for (Iterator types = escapingTypes.iterator(); types.hasNext();) {
+ System.out.println(types.next().getName().toString());
+ }
+ }
+}
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/ExportCallGraphToXML.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/ExportCallGraphToXML.java
new file mode 100644
index 000000000..245ce812d
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/ExportCallGraphToXML.java
@@ -0,0 +1,225 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Properties;
+
+import org.eclipse.emf.ecore.EObject;
+
+import com.ibm.wala.ecore.java.ECallSite;
+import com.ibm.wala.ecore.java.EJavaClass;
+import com.ibm.wala.ecore.java.EJavaMethod;
+import com.ibm.wala.ecore.java.callGraph.ECallGraph;
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFBridge;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.EObjectDictionary;
+import com.ibm.wala.emf.wrappers.EObjectGraph;
+import com.ibm.wala.emf.wrappers.EObjectGraphImpl;
+import com.ibm.wala.emf.wrappers.EUtil;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.CallGraph;
+import com.ibm.wala.ipa.callgraph.Entrypoints;
+import com.ibm.wala.ipa.callgraph.impl.Util;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.util.collections.Iterator2Collection;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+
+/**
+ * This simple example application builds a call graph writes it to an XML file
+ *
+ * @author sfink
+ */
+public class ExportCallGraphToXML {
+
+ /**
+ * Usage: ExportCallGraphToXML -appJar [jar file name] The "jar file name"
+ * should be something like "c:/temp/testdata/java_cup.jar"
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ run(args);
+ }
+
+ /**
+ * Usage: args = "-appJar [jar file name] " The "jar file name" should be
+ * something like "c:/temp/testdata/java_cup.jar"
+ *
+ * @param args
+ */
+ public static void run(String[] args) {
+ validateCommandLine(args);
+ run(args[1]);
+ }
+
+ /**
+ * @param appJar
+ * something like "c:/temp/testdata/java_cup.jar"
+ */
+ public static void run(String appJar) {
+ try {
+
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(appJar);
+
+ // generate a DOMO-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+
+ // TODO: return the warning set (need a CAPA type)
+ // invoke DOMO to build a DOMO class hierarchy object
+ WarningSet warnings = new WarningSet();
+ System.err.println("Build class hierarchy...");
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+
+ Entrypoints entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha);
+ AnalysisOptions options = new AnalysisOptions(scope, entrypoints);
+
+ // //
+ // build the call graph
+ // //
+ System.err.println("Build callgraph...");
+ com.ibm.wala.ipa.callgraph.CallGraphBuilder builder = Util.makeZeroCFABuilder(options, cha, scope, warnings, null, null);
+ CallGraph cg = builder.makeCallGraph(options);
+
+ System.err.println("Convert to EMF...");
+ com.ibm.wala.emf.wrappers.ECallGraphWrapper ccg = EMFBridge.makeCallGraph(cg);
+ ECallGraph ecg = (ECallGraph) ccg.export();
+
+ Properties p = null;
+ ;
+ try {
+ p = WalaProperties.loadProperties();
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String filename = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + "cg.xml";
+ System.err.println("Writing to file: " + filename);
+ write(ecg, filename);
+
+ // try and load it too
+
+ List l = EUtil.readEObjects(filename, ExportCallGraphToXML.class.getClassLoader());
+
+ // convert it to a default graph for kicks
+ ECallGraph output = (ECallGraph) l.get(0);
+ System.err.println(output.getClass());
+ EObjectGraph graph = EObjectGraphImpl.fromEMF(output);
+ System.err.println("read " + graph.getNumberOfNodes() + " nodes");
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private static void write(ECallGraph cg, String filename) throws WalaException {
+
+ // make sure every java method reachable from the call graph
+ // is a node is the call graph
+ Collection c = new Iterator2Collection(cg.getNodes().getContents().iterator());
+ for (Iterator it = c.iterator(); it.hasNext();) {
+ Object node = it.next();
+ if (node instanceof ECallSite) {
+ ECallSite site = (ECallSite) node;
+ EJavaMethod method = site.getDeclaredTarget();
+ if (!c.contains(method)) {
+ cg.getNodes().getContents().add(method);
+ }
+
+ method = site.getJavaMethod();
+ if (!c.contains(method)) {
+ cg.getNodes().getContents().add(method);
+ }
+ }
+ }
+
+ // make a canonical dictionary of all method nodes
+ EObjectDictionary methodNodes = new EObjectDictionary();
+ for (Iterator it = cg.getNodes().getContents().iterator(); it.hasNext();) {
+ Object node = it.next();
+ if (node instanceof EJavaMethod) {
+ EJavaMethod method = (EJavaMethod) node;
+ methodNodes.findOrAdd(method);
+ }
+ }
+
+ // Create a collection of EObjects to persist
+ Collection persist = new LinkedList();
+ // Persist the call graph itself
+ persist.add(cg);
+ // Persist the nodes of the call graph which are NOT contained in the
+ // ECallGraph
+ persist.add(cg.getNodes());
+
+ // Persist all Java classes reachable from the call graph,
+ // and make sure pointers are canonical
+ EObjectDictionary klasses = new EObjectDictionary();
+ for (Iterator it = cg.getNodes().getContents().iterator(); it.hasNext();) {
+ Object node = it.next();
+ if (node instanceof ECallSite) {
+ ECallSite site = (ECallSite) node;
+ EJavaMethod method = (EJavaMethod) site.getDeclaredTarget();
+ method = (EJavaMethod) methodNodes.findOrAdd(method);
+ site.setDeclaredTarget(method);
+ EJavaClass klass = (EJavaClass) klasses.findOrAdd(method.getJavaClass());
+ method.setJavaClass(klass);
+
+ method = site.getJavaMethod();
+ method = (EJavaMethod) methodNodes.findOrAdd(method);
+ site.setJavaMethod(method);
+ klass = (EJavaClass) klasses.findOrAdd(method.getJavaClass());
+ method.setJavaClass(klass);
+ } else if (node instanceof EJavaMethod) {
+ EJavaMethod method = (EJavaMethod) node;
+ EJavaClass klass = (EJavaClass) klasses.findOrAdd(method.getJavaClass());
+ method.setJavaClass(klass);
+ } else {
+ Assertions.UNREACHABLE("Unexpected type " + node.getClass());
+ }
+ }
+ persist.add(klasses.export(true));
+
+ // Save everything to a file.
+ EUtil.saveToFile(persist, filename);
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage:
+ *
+ * - args[0] : "-appJar"
+ *
- args[1] : something like "c:/temp/testdata/java_cup.jar" g = GVTypeHierarchy.typeHierarchy2Graph(th);
+ g = GVTypeHierarchy.pruneForAppLoader(g);
+ if (g.getNumberOfNodes() == 0) {
+ System.err.println("ERROR: The type hierarchy in " + ExportTypeHierarchyToXML.getFileName() + " has no nodes from the Application loader");
+ System.err.println("Probably something's wrong with the input jars being analyzed.");
+ System.err.println("check the files in the path: " + classpath);
+ System.err.println("Also look at these warning messages:");
+ System.err.println(warnings.toString());
+ System.exit(-1);
+ }
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ private static void write(ETypeHierarchy t, String filename) throws WalaException {
+
+ if (filename == null) {
+ throw new WalaException("internal error: null filename parameter");
+ }
+
+ // Create a collection of EObjects to persist
+ Collection persist = new LinkedList();
+ // Persist the type hierarchy itself
+ persist.add(t);
+ // Persist the classes as well, which are NOT contained in the ETypeHierarchy
+ persist.add(t.getClasses().getNodes());
+ // Persist the interfaces as well, which are NOT contained in the ETypeHierarchy
+ persist.add(t.getInterfaces().getNodes());
+
+ // Save everything to a file.
+ EUtil.saveToFile(persist, filename);
+ }
+
+ static String getFileName() throws WalaException {
+ Properties p = null;;
+ try {
+ p = WalaProperties.loadProperties();
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String file = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + FILENAME;
+ return file;
+ }
+
+ public static ETypeHierarchy buildTypeHierarchy(String classpath, WarningSet warnings) throws WalaException {
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(classpath);
+
+ // generate a WALA-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+
+ // invoke WALA to build a class hierarchy
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+
+ // Export the class hierarchy object to an EMF TypeHierarchy object
+ com.ibm.wala.emf.wrappers.ETypeHierarchyWrapper t1 = EMFBridge.makeTypeHierarchy(cha);
+
+ ETypeHierarchy th = (ETypeHierarchy) t1.toEMF();
+ return th;
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage: args[0] : "-classpath" args[1] : String, a ";"-delimited class path
+ *
+ * @param args
+ * @throws UnsupportedOperationException
+ * if command-line is malformed.
+ */
+ static void validateCommandLine(String[] args) {
+ if (args.length < 2) {
+ throw new UnsupportedOperationException("must have at least 2 command-line arguments");
+ }
+ if (!args[0].equals("-classpath")) {
+ throw new UnsupportedOperationException("invalid command-line, args[0] should be -classpath, but is " + args[0]);
+ }
+ }
+}
\ No newline at end of file
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVCallGraph.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVCallGraph.java
new file mode 100644
index 000000000..43d420e18
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVCallGraph.java
@@ -0,0 +1,186 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Properties;
+
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.examples.properties.WalaExamplesProperties;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.CGNode;
+import com.ibm.wala.ipa.callgraph.CallGraph;
+import com.ibm.wala.ipa.callgraph.Entrypoints;
+import com.ibm.wala.ipa.callgraph.impl.Util;
+import com.ibm.wala.ipa.callgraph.propagation.LocalPointerKey;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.types.ClassLoaderReference;
+import com.ibm.wala.util.collections.Filter;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.graph.Graph;
+import com.ibm.wala.util.io.CommandLine;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.DotUtil;
+import com.ibm.wala.viz.GVUtil;
+
+/**
+ *
+ * This simple example WALA application builds a call graph and fires off
+ * ghostview to viz a DOT representation.
+ *
+ * @author sfink
+ */
+public class GVCallGraph {
+
+ private final static String PS_FILE = "cg.ps";
+
+ /**
+ * Usage: GVCallGraph -appJar [jar file name] The "jar file name" should
+ * be something like "c:/temp/testdata/java_cup.jar"
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ run(args);
+ }
+
+ /**
+ * Usage: args = "-appJar [jar file name] " The "jar file name" should be
+ * something like "c:/temp/testdata/java_cup.jar"
+ *
+ * @param args
+ */
+ public static Process run(String[] args) {
+ Properties p = CommandLine.parse(args);
+ validateCommandLine(p);
+ return run(p.getProperty("appJar"));
+ }
+
+ /**
+ * @param appJar
+ * something like "c:/temp/testdata/java_cup.jar"
+ */
+ public static Process run(String appJar) {
+ try {
+
+ Graph g = buildPrunedCallGraph(appJar);
+
+ Properties p = null;
+ try {
+ p = WalaExamplesProperties.loadProperties();
+ p.putAll(WalaProperties.loadProperties());
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String psFile = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + PS_FILE;
+
+ String dotExe = p.getProperty(WalaExamplesProperties.DOT_EXE);
+ DotUtil.dotify(g, null, GVTypeHierarchy.DOT_FILE, psFile, dotExe);
+
+ String gvExe = p.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+ return GVUtil.launchGV(psFile, gvExe);
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * @param appJar
+ * something like "c:/temp/testdata/java_cup.jar"
+ * @return a call graph
+ * @throws WalaException
+ */
+ public static Graph buildPrunedCallGraph(String appJar) throws WalaException {
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(appJar);
+
+ // generate a DOMO-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+
+
+ // TODO: return the warning set (need a CAPA type)
+ // invoke DOMO to build a DOMO class hierarchy object
+ WarningSet warnings = new WarningSet();
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+
+ Entrypoints entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha);
+ AnalysisOptions options = new AnalysisOptions(scope, entrypoints);
+
+ // //
+ // build the call graph
+ // //
+ com.ibm.wala.ipa.callgraph.CallGraphBuilder builder = Util.makeZeroCFABuilder(options, cha, scope, warnings, null, null);
+ CallGraph cg = builder.makeCallGraph(options);
+
+ Graph g = pruneForAppLoader(cg);
+ return g;
+ }
+
+ static Graph pruneForAppLoader(CallGraph g) throws WalaException {
+ return GVTypeHierarchy.pruneGraph(g, new ApplicationLoaderFilter());
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage:
+ *
+ * - args[0] : "-appJar"
+ *
- args[1] : something like "c:/temp/testdata/java_cup.jar"
+ *
- CGNode
+ *
- LocalPointerKey
+ *
+ */
+ private static class ApplicationLoaderFilter implements Filter {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.ibm.capa.util.collections.Filter#accepts(java.lang.Object)
+ */
+ public boolean accepts(Object o) {
+ if (o instanceof CGNode) {
+ CGNode n = (CGNode) o;
+ return n.getMethod().getDeclaringClass().getClassLoader().getReference().equals(ClassLoaderReference.Application);
+ } else if (o instanceof LocalPointerKey) {
+ LocalPointerKey l = (LocalPointerKey) o;
+ return accepts(l.getNode());
+ } else {
+ return false;
+ }
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVControlDependenceGraph.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVControlDependenceGraph.java
new file mode 100644
index 000000000..967d1bb80
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVControlDependenceGraph.java
@@ -0,0 +1,159 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Properties;
+
+import com.ibm.wala.cfg.cdg.ControlDependenceGraph;
+import com.ibm.wala.classLoader.IMethod;
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.examples.properties.WalaExamplesProperties;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.impl.Everywhere;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.ssa.IR;
+import com.ibm.wala.types.MethodReference;
+import com.ibm.wala.util.StringStuff;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.DotUtil;
+import com.ibm.wala.viz.GVUtil;
+import com.ibm.wala.viz.GhostviewUtil;
+
+/**
+ *
+ * This simple example application builds a WALA CDG and fires off ghostview
+ * to viz a DOT representation.
+ *
+ * @author sfink
+ */
+public class GVControlDependenceGraph {
+
+ final public static boolean SANITIZE_CFG = false;
+
+ final public static String PS_FILE = "cdg.ps";
+
+ /**
+ * Usage: GVControlDependenceGraph -appJar [jar file name] -sig [method signature] The "jar
+ * file name" should be something like "c:/temp/testdata/java_cup.jar" The
+ * signature should be something like "java_cup.lexer.advance()V"
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+
+ run(args);
+ }
+
+ /**
+ * @param args
+ * -appJar [jar file name] -sig [method signature] The "jar file
+ * name" should be something like "c:/temp/testdata/java_cup.jar" The
+ * signature should be something like "java_cup.lexer.advance()V"
+ */
+ public static Process run(String[] args) {
+ validateCommandLine(args);
+ return run(args[1], args[3]);
+ }
+
+ /**
+ * @param appJar
+ * should be something like "c:/temp/testdata/java_cup.jar"
+ * @param methodSig
+ * should be something like "java_cup.lexer.advance()V"
+ */
+ public static Process run(String appJar, String methodSig) {
+ try {
+ if (SWTCallGraph.isDirectory(appJar)) {
+ appJar = SWTCallGraph.findJarFiles(new String[] { appJar });
+ }
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(appJar);
+
+ // generate a DOMO-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+
+ // invoke DOMO to build a DOMO class hierarchy object
+ WarningSet warnings = new WarningSet();
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+
+ MethodReference mr = StringStuff.makeMethodReference(methodSig);
+
+ IMethod m = cha.resolveMethod(mr);
+ if (m == null) {
+ Assertions.UNREACHABLE("could not resolve " + mr);
+ }
+ AnalysisOptions options = new AnalysisOptions();
+ options.getSSAOptions().setUsePiNodes(true);
+ IR ir = options.getSSACache().findOrCreateIR(m, Everywhere.EVERYWHERE, cha, options.getSSAOptions(), new WarningSet());
+
+ if (ir == null) {
+ Assertions.UNREACHABLE("Null IR for " + m);
+ }
+
+ System.err.println(ir.toString());
+ ControlDependenceGraph cdg = new ControlDependenceGraph(ir.getControlFlowGraph());
+
+ Properties wp = null;
+ try {
+ wp = WalaProperties.loadProperties();
+ wp.putAll(WalaExamplesProperties.loadProperties());
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String psFile = wp.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + GVControlDependenceGraph.PS_FILE;
+ String dotFile = wp.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar
+ + GVTypeHierarchy.DOT_FILE;
+ String dotExe = wp.getProperty(WalaExamplesProperties.DOT_EXE);
+ String gvExe = wp.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+
+ DotUtil.dotify(cdg, GhostviewUtil.makeIRDecorator(ir), dotFile, psFile, dotExe);
+
+ return GVUtil.launchGV(psFile, gvExe);
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage:
+ *
+ * - args[0] : "-appJar"
+ *
- args[1] : something like "c:/temp/testdata/java_cup.jar"
+ *
- args[2] : "-sig"
+ *
- args[3] : a method signature like "java_cup.lexer.advance()V" g = pruneSDG(sdg);
+ DotUtil.dotify(g, makeNodeDecorator(), GVTypeHierarchy.DOT_FILE, psFile, dotExe);
+
+ String gvExe = p.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+ return GVUtil.launchGV(psFile, gvExe);
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ private static Graph pruneSDG(SDG sdg) {
+ Filter f = new Filter() {
+ public boolean accepts(Object o) {
+ Statement s = (Statement)o;
+ if (s.getNode().equals(s.getNode().getCallGraph().getFakeRootNode())) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+ };
+ return GraphSlicer.prune(sdg, f);
+ }
+
+ private static NodeDecorator makeNodeDecorator() {
+ return new NodeDecorator() {
+ public String getLabel(Object o) throws WalaException {
+ Statement s = (Statement) o;
+ switch (s.getKind()) {
+ case HEAP_PARAM_CALLEE:
+ case HEAP_PARAM_CALLER:
+ case HEAP_RET_CALLEE:
+ case HEAP_RET_CALLER:
+ HeapStatement h =(HeapStatement)s;
+ return s.getKind() + "\\n" + h.getNode() + "\\n" + h.getLocation();
+ case EXC_RET_CALLEE:
+ case EXC_RET_CALLER:
+ case NORMAL:
+ case NORMAL_RET_CALLEE:
+ case NORMAL_RET_CALLER:
+ case PARAM_CALLEE:
+ case PARAM_CALLER:
+ case PHI:
+ default:
+ return s.toString();
+ }
+ }
+
+ };
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage:
+ *
+ * - args[0] : "-appJar"
+ *
- args[1] : something like "c:/temp/testdata/java_cup.jar"
+ *
- args[2] : "-mainClass"
+ *
- args[3] : something like "Lslice/TestRecursion"
+ *
+ * @throws UnsupportedOperationException
+ * if command-line is malformed.
+ */
+ static void validateCommandLine(Properties p) {
+ if (p.get("appJar") == null) {
+ throw new UnsupportedOperationException("expected command-line to include -appJar");
+ }
+ if (p.get("mainClass") == null) {
+ throw new UnsupportedOperationException("expected command-line to include -appJar");
+ }
+ }
+}
\ No newline at end of file
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVSlice.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVSlice.java
new file mode 100644
index 000000000..bfb231727
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVSlice.java
@@ -0,0 +1,259 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Properties;
+
+import com.ibm.wala.core.tests.callGraph.CallGraphTestUtil;
+import com.ibm.wala.core.tests.slicer.SlicerTest;
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.examples.properties.WalaExamplesProperties;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.CGNode;
+import com.ibm.wala.ipa.callgraph.CallGraph;
+import com.ibm.wala.ipa.callgraph.CallGraphBuilder;
+import com.ibm.wala.ipa.callgraph.Entrypoints;
+import com.ibm.wala.ipa.callgraph.impl.Util;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.ipa.slicer.HeapStatement;
+import com.ibm.wala.ipa.slicer.NormalStatement;
+import com.ibm.wala.ipa.slicer.ParamStatement;
+import com.ibm.wala.ipa.slicer.SDG;
+import com.ibm.wala.ipa.slicer.Slicer;
+import com.ibm.wala.ipa.slicer.Statement;
+import com.ibm.wala.ipa.slicer.ParamStatement.CallStatementCarrier;
+import com.ibm.wala.ipa.slicer.ParamStatement.ValueNumberCarrier;
+import com.ibm.wala.ipa.slicer.Slicer.ControlDependenceOptions;
+import com.ibm.wala.ipa.slicer.Slicer.DataDependenceOptions;
+import com.ibm.wala.ipa.slicer.Statement.Kind;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.ssa.SSAInstruction;
+import com.ibm.wala.ssa.SSAInvokeInstruction;
+import com.ibm.wala.util.collections.Filter;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.graph.Graph;
+import com.ibm.wala.util.graph.GraphIntegrity;
+import com.ibm.wala.util.graph.GraphSlicer;
+import com.ibm.wala.util.graph.NodeDecorator;
+import com.ibm.wala.util.graph.GraphIntegrity.UnsoundGraphException;
+import com.ibm.wala.util.io.CommandLine;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.DotUtil;
+import com.ibm.wala.viz.GVUtil;
+
+/**
+ *
+ * This simple example WALA application builds an SDG and fires off ghostview to
+ * viz a DOT representation of a slice in the SDG
+ *
+ * @author sfink
+ */
+public class GVSlice {
+
+ private final static String PS_FILE = "slice.ps";
+
+ /**
+ * Usage: GVSDG -appJar [jar file name] -mainclass [main class] -src [method
+ * name]
+ *
+ * The "jar file name" should be something like
+ * "c:/temp/testdata/java_cup.jar"
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ run(args);
+ }
+
+ /**
+ */
+ public static Process run(String[] args) {
+ Properties p = CommandLine.parse(args);
+ validateCommandLine(p);
+ return run(p.getProperty("appJar"), p.getProperty("mainClass"), p.getProperty("srcCaller"), p.getProperty("srcCallee"),
+ goBackward(p), GVSDG.getDataDependenceOptions(p), GVSDG.getControlDependenceOptions(p));
+ }
+
+ private static boolean goBackward(Properties p) {
+ return !p.getProperty("dir","backward").equals("forward");
+ }
+
+ /**
+ */
+ public static Process run(String appJar, String mainClass, String srcCaller, String srcCallee, boolean goBackward, DataDependenceOptions dOptions,
+ ControlDependenceOptions cOptions) {
+ try {
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(appJar);
+
+ // generate a WALA-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+ WarningSet warnings = new WarningSet();
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+ Entrypoints entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha, mainClass);
+ AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints);
+
+ CallGraphBuilder builder = Util.makeZeroOneCFABuilder(options, cha, scope, warnings);
+ CallGraph cg = builder.makeCallGraph(options);
+ SDG sdg = new SDG(cg, builder.getPointerAnalysis(), dOptions, cOptions);
+
+ CGNode main = SlicerTest.findMethod(cg, srcCaller);
+ Statement s = SlicerTest.findCallTo(main, srcCallee);
+ System.err.println("Statement: " + s);
+ Collection slice = null;
+ if (goBackward) {
+ slice = Slicer.computeBackwardSlice(s, cg, builder.getPointerAnalysis(), dOptions, cOptions);
+ } else {
+ // for forward slices ... we actually slice from the return value of calls.
+ s = getReturnStatementForCall(s);
+ slice = Slicer.computeForwardSlice(s, cg, builder.getPointerAnalysis(), dOptions, cOptions);
+ }
+ SlicerTest.dumpSlice(slice);
+
+ Graph g = pruneSDG(sdg, slice);
+ try {
+ GraphIntegrity.check(g);
+ } catch (UnsoundGraphException e1) {
+ e1.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ Assertions.productionAssertion(g.getNumberOfNodes() == slice.size(), "panic " + g.getNumberOfNodes() + " " + slice.size());
+
+ Properties p = null;
+ try {
+ p = WalaExamplesProperties.loadProperties();
+ p.putAll(WalaProperties.loadProperties());
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String psFile = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + PS_FILE;
+
+ String dotExe = p.getProperty(WalaExamplesProperties.DOT_EXE);
+
+ DotUtil.dotify(g, makeNodeDecorator(), GVTypeHierarchy.DOT_FILE, psFile, dotExe);
+
+ String gvExe = p.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+ return GVUtil.launchGV(psFile, gvExe);
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * If s is a call statement, return the statement representing the normal return from s
+ */
+ public static Statement getReturnStatementForCall(Statement s) {
+ if (s.getKind() == Kind.NORMAL) {
+ SSAInstruction st = ((NormalStatement)s).getInstruction();
+ if (st instanceof SSAInvokeInstruction) {
+ return new ParamStatement.NormalReturnCaller(s.getNode(),(SSAInvokeInstruction)st);
+ } else {
+ return s;
+ }
+ } else {
+ return s;
+ }
+ }
+
+ public static Graph pruneSDG(SDG sdg, final Collection slice) {
+ Filter f = new Filter() {
+ public boolean accepts(Object o) {
+ return slice.contains(o);
+ }
+ };
+ return GraphSlicer.prune(sdg, f);
+ }
+
+ public static NodeDecorator makeNodeDecorator() {
+ return new NodeDecorator() {
+ public String getLabel(Object o) throws WalaException {
+ Statement s = (Statement) o;
+ switch (s.getKind()) {
+ case HEAP_PARAM_CALLEE:
+ case HEAP_PARAM_CALLER:
+ case HEAP_RET_CALLEE:
+ case HEAP_RET_CALLER:
+ HeapStatement h = (HeapStatement) s;
+ return s.getKind() + "\\n" + h.getNode() + "\\n" + h.getLocation();
+ case NORMAL:
+ NormalStatement n = (NormalStatement) s;
+ return n.getNode() + "\\n" + n.getInstruction();
+ case PARAM_CALLEE:
+ case PARAM_CALLER:
+ if (s instanceof ValueNumberCarrier) {
+ ValueNumberCarrier vc = (ValueNumberCarrier) s;
+ if (s instanceof CallStatementCarrier) {
+ CallStatementCarrier cc = (CallStatementCarrier) s;
+ return s.getKind() + "\\n" + s.getNode() + "\\n" + cc.getCall() + "\\nv" + vc.getValueNumber();
+ } else {
+ return s.getKind() + "\\n" + s.getNode() + "\\nv" + vc.getValueNumber();
+ }
+ } else {
+ if (s instanceof CallStatementCarrier) {
+ CallStatementCarrier cc = (CallStatementCarrier) s;
+ return s.getKind() + "\\n" + s.getNode() + "\\n" + cc.getCall();
+ } else {
+ return s.toString();
+ }
+ }
+ case EXC_RET_CALLEE:
+ case EXC_RET_CALLER:
+ case NORMAL_RET_CALLEE:
+ case NORMAL_RET_CALLER:
+ case PHI:
+ default:
+ return s.toString();
+ }
+ }
+
+ };
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage:
+ *
+ * - args[0] : "-appJar"
+ *
- args[1] : something like "c:/temp/testdata/java_cup.jar"
+ *
- args[2] : "-mainClass"
+ *
- args[3] : something like "Lslice/TestRecursion" *
+ *
- args[4] : "-srcCallee"
+ *
- args[5] : something like "print" *
+ *
- args[4] : "-srcCaller"
+ *
- args[5] : something like "main"
+ *
+ * @throws UnsupportedOperationException
+ * if command-line is malformed.
+ */
+ static void validateCommandLine(Properties p) {
+ if (p.get("appJar") == null) {
+ throw new UnsupportedOperationException("expected command-line to include -appJar");
+ }
+ if (p.get("mainClass") == null) {
+ throw new UnsupportedOperationException("expected command-line to include -mainClass");
+ }
+ if (p.get("srcCallee") == null) {
+ throw new UnsupportedOperationException("expected command-line to include -srcCallee");
+ }
+ if (p.get("srcCaller") == null) {
+ throw new UnsupportedOperationException("expected command-line to include -srcCaller");
+ }
+ }
+}
\ No newline at end of file
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVTypeHierarchy.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVTypeHierarchy.java
new file mode 100644
index 000000000..7583f6330
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVTypeHierarchy.java
@@ -0,0 +1,156 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+
+import org.eclipse.emf.ecore.EObject;
+
+import com.ibm.wala.ecore.java.EClassLoaderName;
+import com.ibm.wala.ecore.java.EJavaClass;
+import com.ibm.wala.ecore.java.ETypeHierarchy;
+import com.ibm.wala.emf.wrappers.EObjectGraphImpl;
+import com.ibm.wala.emf.wrappers.ETypeHierarchyWrapper;
+import com.ibm.wala.emf.wrappers.EUtil;
+import com.ibm.wala.examples.properties.WalaExamplesProperties;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.util.CollectionFilter;
+import com.ibm.wala.util.collections.Filter;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.graph.Graph;
+import com.ibm.wala.util.graph.GraphSlicer;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.DotUtil;
+import com.ibm.wala.viz.GVUtil;
+
+/**
+ *
+ * This simple example WALA application builds a TypeHierarchy and fires off
+ * ghostview to viz a DOT representation.
+ *
+ * @author sfink
+ */
+public class GVTypeHierarchy {
+
+ public final static String DOT_FILE = "temp.dt";
+
+ private final static String PS_FILE = "th.ps";
+
+ public static Properties p;
+
+ static {
+ try {
+ p = WalaProperties.loadProperties();
+ p.putAll(WalaExamplesProperties.loadProperties());
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+
+ }
+
+ public static void main(String[] args) {
+ run(args, false);
+ }
+
+ public static Process run(String[] args, boolean readFromFile) {
+ try {
+ ETypeHierarchy th = null;
+ if (readFromFile) {
+ th = readTypeHierarchy();
+ } else {
+ ExportTypeHierarchyToXML.validateCommandLine(args);
+ String classpath = args[ExportTypeHierarchyToXML.CLASSPATH_INDEX];
+ th = ExportTypeHierarchyToXML.buildTypeHierarchy(classpath, new WarningSet());
+ }
+
+ Graph g = typeHierarchy2Graph(th);
+
+ g = pruneForAppLoader(g);
+ String dotFile = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + DOT_FILE;
+ String psFile = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + PS_FILE;
+ String dotExe = p.getProperty(WalaExamplesProperties.DOT_EXE);
+ String gvExe = p.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+ DotUtil.dotify(g, null, dotFile, psFile, dotExe);
+ return GVUtil.launchGV(psFile, gvExe);
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.ibm.capa.core.EAnalysisEngine#processImpl()
+ */
+ public static Graph typeHierarchy2Graph(ETypeHierarchy et) throws WalaException {
+ ETypeHierarchyWrapper t = new ETypeHierarchyWrapper(et);
+ EObjectGraphImpl dg = new EObjectGraphImpl();
+ for (Iterator it = t.getClasses().iterateNodes(); it.hasNext();) {
+ dg.addNode(it.next());
+ }
+ for (Iterator it = t.getInterfaces().iterateNodes(); it.hasNext();) {
+ dg.addNode(it.next());
+ }
+ for (Iterator it = t.getClasses().iterateNodes(); it.hasNext();) {
+ EJavaClass x = (EJavaClass) it.next();
+ for (Iterator it2 = t.getClasses().getSuccNodes(x); it2.hasNext();) {
+ dg.addEdge(x, it2.next());
+ }
+ for (Iterator it2 = t.getImplements(x).iterator(); it2.hasNext();) {
+ dg.addEdge(it2.next(), x);
+ }
+ }
+ for (Iterator it = t.getInterfaces().iterateNodes(); it.hasNext();) {
+ EJavaClass x = (EJavaClass) it.next();
+ for (Iterator it2 = t.getInterfaces().getSuccNodes(x); it2.hasNext();) {
+ dg.addEdge(x, it2.next());
+ }
+ }
+
+ return dg;
+ }
+
+ static Graph pruneForAppLoader(Graph g) throws WalaException {
+ Filter f = new Filter() {
+ public boolean accepts(Object o) {
+ if (o instanceof EJavaClass) {
+ EJavaClass klass = (EJavaClass) o;
+ return (klass.getLoader().equals(EClassLoaderName.APPLICATION_LITERAL));
+ } else {
+ return false;
+ }
+ }
+ };
+
+ return pruneGraph(g, f);
+ }
+
+ public static Graph pruneGraph(Graph g, Filter f) throws WalaException {
+
+ Collection slice = GraphSlicer.slice(g, f);
+ return GraphSlicer.prune(g, new CollectionFilter(slice));
+ }
+
+ static ETypeHierarchy readTypeHierarchy() throws WalaException {
+
+ List l = EUtil.readEObjects(ExportTypeHierarchyToXML.getFileName(), ExportTypeHierarchyToXML.class.getClassLoader());
+ return (ETypeHierarchy) l.get(0);
+ }
+}
\ No newline at end of file
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVWalaIR.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVWalaIR.java
new file mode 100644
index 000000000..ee6be019d
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/GVWalaIR.java
@@ -0,0 +1,152 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Properties;
+
+import com.ibm.wala.classLoader.IMethod;
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.examples.properties.WalaExamplesProperties;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.impl.Everywhere;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.ssa.IR;
+import com.ibm.wala.types.MethodReference;
+import com.ibm.wala.util.StringStuff;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.GhostviewUtil;
+
+/**
+ *
+ * This simple example application builds a WALA IR and fires off ghostview
+ * to viz a DOT representation.
+ *
+ * @author sfink
+ */
+public class GVWalaIR {
+
+ final public static boolean SANITIZE_CFG = false;
+
+ final public static String PS_FILE = "ir.ps";
+
+ /**
+ * Usage: GVWalaIR -appJar [jar file name] -sig [method signature] The "jar
+ * file name" should be something like "c:/temp/testdata/java_cup.jar" The
+ * signature should be something like "java_cup.lexer.advance()V"
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ run(args);
+ }
+
+ /**
+ * @param args
+ * -appJar [jar file name] -sig [method signature] The "jar file
+ * name" should be something like "c:/temp/testdata/java_cup.jar" The
+ * signature should be something like "java_cup.lexer.advance()V"
+ */
+ public static Process run(String[] args) {
+ validateCommandLine(args);
+ return run(args[1], args[3]);
+ }
+
+ /**
+ * @param appJar
+ * should be something like "c:/temp/testdata/java_cup.jar"
+ * @param methodSig
+ * should be something like "java_cup.lexer.advance()V"
+ */
+ public static Process run(String appJar, String methodSig) {
+ try {
+ if (SWTCallGraph.isDirectory(appJar)) {
+ appJar = SWTCallGraph.findJarFiles(new String[] { appJar });
+ }
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(appJar);
+
+ // generate a DOMO-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+
+ // invoke DOMO to build a DOMO class hierarchy object
+ WarningSet warnings = new WarningSet();
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+
+ MethodReference mr = StringStuff.makeMethodReference(methodSig);
+
+ IMethod m = cha.resolveMethod(mr);
+ if (m == null) {
+ Assertions.UNREACHABLE("could not resolve " + mr);
+ }
+ AnalysisOptions options = new AnalysisOptions();
+ options.getSSAOptions().setUsePiNodes(true);
+ IR ir = options.getSSACache().findOrCreateIR(m, Everywhere.EVERYWHERE, cha, options.getSSAOptions(), new WarningSet());
+
+ if (ir == null) {
+ Assertions.UNREACHABLE("Null IR for " + m);
+ }
+
+ System.err.println(ir.toString());
+
+ Properties wp = null;
+ try {
+ wp = WalaProperties.loadProperties();
+ wp.putAll(WalaExamplesProperties.loadProperties());
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String psFile = wp.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + GVWalaIR.PS_FILE;
+ String dotFile = wp.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar
+ + GVTypeHierarchy.DOT_FILE;
+ String dotExe = wp.getProperty(WalaExamplesProperties.DOT_EXE);
+ String gvExe = wp.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+
+ return GhostviewUtil.ghostviewIR(cha, ir, SANITIZE_CFG, psFile, dotFile, dotExe, gvExe);
+
+ } catch (WalaException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * Validate that the command-line arguments obey the expected usage.
+ *
+ * Usage:
+ *
+ * - args[0] : "-appJar"
+ *
- args[1] : something like "c:/temp/testdata/java_cup.jar"
+ *
- args[2] : "-sig"
+ *
- args[3] : a method signature like "java_cup.lexer.advance()V" m = Environment.readEnv();
+
+ for (Iterator> it = m.entrySet().iterator(); it.hasNext();) {
+ System.out.println(it.next());
+ }
+ } catch (WalaException e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/SWTCallGraph.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/SWTCallGraph.java
new file mode 100644
index 000000000..45a1235a1
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/SWTCallGraph.java
@@ -0,0 +1,198 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Properties;
+
+import org.eclipse.jface.window.ApplicationWindow;
+
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.examples.properties.WalaExamplesProperties;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.CallGraph;
+import com.ibm.wala.ipa.callgraph.CallGraphStats;
+import com.ibm.wala.ipa.callgraph.Entrypoints;
+import com.ibm.wala.ipa.callgraph.impl.Util;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.properties.WalaProperties;
+import com.ibm.wala.util.collections.HashSetFactory;
+import com.ibm.wala.util.debug.Assertions;
+import com.ibm.wala.util.graph.GraphIntegrity;
+import com.ibm.wala.util.graph.InferGraphRootsImpl;
+import com.ibm.wala.util.io.CommandLine;
+import com.ibm.wala.util.io.FileUtil;
+import com.ibm.wala.util.perf.EngineTimings;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.SWTTreeViewer;
+import com.ibm.wala.viz.ViewIRAction;
+
+/**
+ *
+ * This application is a WALA client: it invokes an SWT TreeViewer to visualize
+ * a Call Graph
+ *
+ * @author sfink
+ */
+public class SWTCallGraph {
+
+ private final static boolean CHECK_GRAPH = false;
+
+ /**
+ * Usage: SWTCallGraph -appJar [jar file name]
+ *
+ * The "jar file name" should be something like
+ * "c:/temp/testdata/java_cup.jar"
+ *
+ * If it's a directory, then we'll try to find all jar files under that
+ * directory.
+ *
+ * @param args
+ * @throws WalaException
+ */
+ public static void main(String[] args) throws WalaException {
+ Properties p = CommandLine.parse(args);
+ GVCallGraph.validateCommandLine(p);
+ run(p);
+ }
+
+ /**
+ * @param p
+ * should contain at least the following properties:
+ *
+ * - appJar should be something like
+ * "c:/temp/testdata/java_cup.jar"
+ *
- algorithm (optional) can be one of:
+ *
+ * - "ZERO_CFA" (default value)
+ *
- "RTA"
+ *
+ *
+ *
+ * @throws WalaException
+ */
+ public static ApplicationWindow run(Properties p) throws WalaException {
+
+ try {
+ String appJar = p.getProperty("appJar");
+ if (isDirectory(appJar)) {
+ appJar = SWTCallGraph.findJarFiles(new String[] { appJar });
+ }
+ EJavaAnalysisScope escope = JavaScopeUtil.makeAnalysisScope(appJar);
+
+ String exclusionFile = p.getProperty("exclusions");
+ if (exclusionFile != null) {
+ escope.setExclusionFileName(exclusionFile);
+ }
+
+ // generate a DOMO-consumable wrapper around the incoming scope object
+ EMFScopeWrapper scope = EMFScopeWrapper.generateScope(escope);
+
+ // TODO: return the warning set (need a CAPA type)
+ // invoke DOMO to build a DOMO class hierarchy object
+ WarningSet warnings = new WarningSet();
+ ClassHierarchy cha = ClassHierarchy.make(scope, warnings);
+
+ Entrypoints entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha);
+ AnalysisOptions options = new AnalysisOptions(scope, entrypoints);
+
+ // //
+ // build the call graph
+ // //
+ com.ibm.wala.ipa.callgraph.CallGraphBuilder builder = Util.makeZeroCFABuilder(options, cha, scope, warnings, null, null);
+ CallGraph cg = builder.makeCallGraph(options);
+
+ System.out.println(CallGraphStats.getStats(cg));
+
+ if (CHECK_GRAPH) {
+ GraphIntegrity.check(cg);
+ }
+
+ Properties wp = null;
+ try {
+ wp = WalaProperties.loadProperties();
+ wp.putAll(WalaExamplesProperties.loadProperties());
+ } catch (WalaException e) {
+ e.printStackTrace();
+ Assertions.UNREACHABLE();
+ }
+ String psFile = wp.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + GVWalaIR.PS_FILE;
+ String dotFile = wp.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + GVTypeHierarchy.DOT_FILE;
+ String dotExe = wp.getProperty(WalaExamplesProperties.DOT_EXE);
+ String gvExe = wp.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
+
+ // create and run the viewer
+ final SWTTreeViewer v = new SWTTreeViewer();
+ v.setGraphInput(cg);
+ v.setRootsInput(InferGraphRootsImpl.inferRoots(cg));
+ v.getPopUpActions().add(new ViewIRAction(v, cg, psFile, dotFile, dotExe, gvExe));
+ v.run();
+ return v.getApplicationWindow();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ } finally {
+ EngineTimings.report();
+ }
+ }
+
+ // private static CallGraphConstructionAlgorithm chooseAlgorithm(Properties p)
+ // throws CapaException {
+ // String alg = p.getProperty("algorithm", "ZERO_CFA");
+ // if (alg.equals("ZERO_CFA")) {
+ // return CallGraphConstructionAlgorithm.ZERO_CFA_LITERAL;
+ // } else if (alg.equals("RTA")) {
+ // return CallGraphConstructionAlgorithm.RTA_LITERAL;
+ // } else if (alg.equals("ZERO_ONE_CFA")) {
+ // return CallGraphConstructionAlgorithm.VANILLA_ZERO_ONE_CFA_LITERAL;
+ // } else {
+ // throw new CapaException("Unsupported algorithm: " + alg);
+ // }
+ // }
+
+ static boolean isDirectory(String appJar) {
+ return (new File(appJar).isDirectory());
+ }
+
+ static String findJarFiles(String[] directories) throws WalaException {
+ Collection result = HashSetFactory.make();
+ for (int i = 0; i < directories.length; i++) {
+ for (Iterator it = FileUtil.listFiles(directories[i], ".*\\.jar", true).iterator(); it.hasNext();) {
+ File f = (File) it.next();
+ result.add(f.getAbsolutePath());
+ }
+ }
+ return composeString(result);
+ }
+
+ /**
+ * @param s
+ * Collection
+ */
+ private static String composeString(Collection s) {
+ StringBuffer result = new StringBuffer();
+ Iterator it = s.iterator();
+ for (int i = 0; i < s.size() - 1; i++) {
+ result.append(it.next());
+ result.append(';');
+ }
+ if (it.hasNext()) {
+ result.append(it.next());
+ }
+ return result.toString();
+ }
+}
\ No newline at end of file
diff --git a/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/SWTPointsTo.java b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/SWTPointsTo.java
new file mode 100644
index 000000000..ad78d888b
--- /dev/null
+++ b/com.ibm.wala.core.tests/com.ibm.wala.core.tests/src/com/ibm/wala/examples/drivers/SWTPointsTo.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2002 - 2006 IBM Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.ibm.wala.examples.drivers;
+
+import java.util.Properties;
+
+import org.eclipse.jface.window.ApplicationWindow;
+
+import com.ibm.wala.analysis.pointers.BasicHeapGraph;
+import com.ibm.wala.ecore.java.scope.EJavaAnalysisScope;
+import com.ibm.wala.emf.wrappers.EMFScopeWrapper;
+import com.ibm.wala.emf.wrappers.JavaScopeUtil;
+import com.ibm.wala.ipa.callgraph.AnalysisOptions;
+import com.ibm.wala.ipa.callgraph.CallGraph;
+import com.ibm.wala.ipa.callgraph.Entrypoints;
+import com.ibm.wala.ipa.callgraph.impl.Util;
+import com.ibm.wala.ipa.callgraph.propagation.PointerAnalysis;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.util.graph.Graph;
+import com.ibm.wala.util.graph.InferGraphRootsImpl;
+import com.ibm.wala.util.io.CommandLine;
+import com.ibm.wala.util.warnings.WalaException;
+import com.ibm.wala.util.warnings.WarningSet;
+import com.ibm.wala.viz.SWTTreeViewer;
+
+/**
+ *
+ * This application is a WALA client: it invokes an SWT TreeViewer to visualize
+ * a Points-To solution
+ *
+ * @author sfink
+ */
+public class SWTPointsTo {
+
+ /**
+ * Usage: SWTPointsTo -appJar [jar file name] The "jar file name" should be
+ * something like "c:/temp/testdata/java_cup.jar"
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ Properties p = CommandLine.parse(args);
+ GVCallGraph.validateCommandLine(p);
+ run(p.getProperty("appJar"));
+ }
+
+ /**
+ * @param appJar
+ * should be something like "c:/temp/testdata/java_cup.jar"
+ */
+ public static ApplicationWindow run(String appJar) {
+
+ try {
+ Graph