/** * builds a call graph, and sets the corresponding heap model for analysis * * @param scope * @param cha * @param options * @return * @throws CancelException * @throws IllegalArgumentException */ private static Pair<CallGraph, PointerAnalysis> buildCallGraph( AnalysisScope scope, ClassHierarchy cha, AnalysisOptions options) throws IllegalArgumentException, CancelException { CallGraph retCG = null; PointerAnalysis retPA = null; final AnalysisCache cache = new AnalysisCache(); CallGraphBuilder builder; if (CHEAP_CG) { builder = Util.makeZeroCFABuilder(options, cache, cha, scope); // we want vanilla 0-1 CFA, which has one abstract loc per allocation heapModel = Util.makeVanillaZeroOneCFABuilder(options, cache, cha, scope); } else { builder = Util.makeZeroOneContainerCFABuilder(options, cache, cha, scope); heapModel = (HeapModel) builder; } ProgressMaster master = ProgressMaster.make(new NullProgressMonitor(), 360000, false); master.beginTask("runSolver", 1); try { retCG = builder.makeCallGraph(options, master); retPA = builder.getPointerAnalysis(); } catch (CallGraphBuilderCancelException e) { System.err.println("TIMED OUT!!"); retCG = e.getPartialCallGraph(); retPA = e.getPartialPointerAnalysis(); } return Pair.make(retCG, retPA); }
@Test public void testZeroOneContainerCopyOf() throws IOException, ClassHierarchyException, IllegalArgumentException, CancelException { AnalysisScope scope = CallGraphTestUtil.makeJ2SEAnalysisScope( TestConstants.WALA_TESTDATA, CallGraphTestUtil.REGRESSION_EXCLUSIONS); ClassHierarchy cha = ClassHierarchy.make(scope); Iterable<Entrypoint> entrypoints = Util.makeMainEntrypoints(scope, cha, "Ldemandpa/TestArraysCopyOf"); AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints); AnalysisCache cache = new AnalysisCache(); CallGraphBuilder builder = Util.makeZeroOneContainerCFABuilder(options, cache, cha, scope); CallGraph cg = builder.makeCallGraph(options, null); PointerAnalysis pa = builder.getPointerAnalysis(); CGNode mainMethod = AbstractPtrTest.findMainMethod(cg); PointerKey keyToQuery = AbstractPtrTest.getParam(mainMethod, "testThisVar", pa.getHeapModel()); OrdinalSet<? extends InstanceKey> pointsToSet = pa.getPointsToSet(keyToQuery); Assert.assertEquals(1, pointsToSet.size()); }
public static ExceptionPruneAnalysis create(String methodSig) throws WalaException, IOException, IllegalArgumentException, CallGraphBuilderCancelException { AnalysisScope scope = AnalysisScopeReader.makePrimordialScope(null); SetOfClasses exclusions = new FileOfClasses(new ByteArrayInputStream(exclusionRegExp.getBytes())); scope.setExclusions(exclusions); ClassLoaderReference loader = scope.getLoader(AnalysisScope.APPLICATION); AnalysisScopeReader.addClassPathToScope(classPath, scope, loader); // Klassenhierarchie berechnen ClassHierarchy cha = ClassHierarchy.make(scope); AnalysisCache cache = new AnalysisCache(); MethodReference mr = StringStuff.makeMethodReference(Language.JAVA, methodSig); IMethod m = cha.resolveMethod(mr); if (m == null) { throw new IllegalStateException("Could not resolve " + mr); } Set<Entrypoint> entries = HashSetFactory.make(); entries.add(new DefaultEntrypoint(m, cha)); AnalysisOptions options = new AnalysisOptions(); options.getSSAOptions().setPiNodePolicy(SSAOptions.getAllBuiltInPiNodes()); options.setEntrypoints(entries); CallGraphBuilder builder = Util.makeZeroOneContainerCFABuilder(options, cache, cha, scope); CallGraph cg = builder.makeCallGraph(options, null); PointerAnalysis pta = builder.getPointerAnalysis(); ExceptionPruneAnalysis mCFG = new ExceptionPruneAnalysis(cg, pta, cache); return mCFG; }