/**
* 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;
}