@Override public Set<CGNode> getNodes(MethodReference m) { Set<CGNode> tmp = cg.getNodes(m); Set<CGNode> ret = new HashSet<>(); for (CGNode n : tmp) { if (keep.contains(n)) { ret.add(n); } } return ret; }
@Override public Iterator<CGNode> getSuccNodes(CGNode n) { Iterator<CGNode> tmp = cg.getSuccNodes(n); Collection<CGNode> col = new LinkedList<>(); while (tmp.hasNext()) { CGNode no = tmp.next(); if (keep.contains(no) && !removedEdge(n, no)) { col.add(no); } } return col.iterator(); }
public SimpleMemoryAccessMap(CallGraph cg, HeapModel heapModel, boolean includePrimOps) { if (cg == null) { throw new IllegalArgumentException("null cg"); } this.cha = cg.getClassHierarchy(); this.heapModel = heapModel; this.includePrimOps = includePrimOps; populate(cg); }
@Override public CGNode getFakeWorldClinitNode() { if (keep.contains(cg.getFakeWorldClinitNode())) { return cg.getFakeRootNode(); } else { return null; } }
public static CGStats getCGStats(CallGraph cg) { if (cg == null) { throw new IllegalArgumentException("cg is null"); } Set<CGNode> reachableNodes = DFS.getReachableNodes(cg, Collections.singleton(cg.getFakeRootNode())); int nNodes = 0; int nEdges = 0; for (CGNode n : reachableNodes) { nNodes++; nEdges += cg.getSuccNodeCount(n); } return new CGStats(nNodes, nEdges, collectMethods(cg).size(), countBytecodeBytes(cg)); }
@Override public void check(CallGraph cg) { MethodReference mref = descriptorToMethodRef("Source#Array1#foo#()V", cg.getClassHierarchy()); int count = 0; CGNode node = cg.getNodes(mref).iterator().next(); for (SSAInstruction s : node.getIR().getInstructions()) { if (isArrayInstruction(s)) { count++; } } Assert.assertEquals("Unexpected number of array instructions in 'foo'.", count, 4); }
/** * Test that when analyzing Reflect18, the call graph includes a node for * java.lang.Integer.toString() */ @Test public void testReflect18() throws WalaException, IllegalArgumentException, CancelException, IOException { AnalysisScope scope = findOrCreateAnalysisScope(); IClassHierarchy cha = findOrCreateCHA(scope); Iterable<Entrypoint> entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha, TestConstants.REFLECT18_MAIN); AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints); CallGraph cg = CallGraphTestUtil.buildZeroOneCFA(options, new AnalysisCacheImpl(), cha, scope, false); TypeReference tr = TypeReference.findOrCreate(ClassLoaderReference.Application, "Lreflection/Helper"); MethodReference mr = MethodReference.findOrCreate(tr, "t", "(Ljava/lang/Integer;)V"); CGNode node = cg.getNode(cg.getClassHierarchy().resolveMethod(mr), Everywhere.EVERYWHERE); Assert.assertEquals(1, cg.getSuccNodeCount(node)); CGNode succ = cg.getSuccNodes(node).next(); Assert.assertEquals("Node: < Primordial, Ljava/lang/Integer, toString()Ljava/lang/String; > Context: Everywhere", succ.toString()); }
@Override public Iterator<Pair<CGNode, NewSiteReference>> getCreationSites(CallGraph CG) { MethodReference ctorRef = JavaScriptMethods.makeCtorReference(JavaScriptTypes.Function); Set<CGNode> f = CG.getNodes(ctorRef); CGNode ctor = null; for(CGNode n : f) { JavaScriptConstructor c = (JavaScriptConstructor) n.getMethod(); if (c.constructedType().equals(klass)) { ctor = n; break; } } // built in objects if (ctor == null) { return EmptyIterator.instance(); } Iterator<CGNode> callers = CG.getPredNodes(ctor); CGNode caller = callers.next(); assert !callers.hasNext(); Iterator<CallSiteReference> sites = CG.getPossibleSites(caller, ctor); CallSiteReference site = sites.next(); assert !sites.hasNext() : caller + " --> " + ctor + " @ " + site + " and " + sites.next() + '\n' + caller.getIR(); return NonNullSingletonIterator.make(Pair.make(caller, NewSiteReference.make(site.getProgramCounter(), klass.getReference()))); }
protected void checkCompareToCalls(CallGraph cg, Set<CGNode> ctnodes, String x, int expected) { // Find node corresponding to id1 TypeReference tid1 = TypeReference.findOrCreate(ClassLoaderReference.Application, "Llambda/SortingExample"); MethodReference mid1 = MethodReference.findOrCreate(tid1, x, "(I)I"); Assert.assertTrue("expect " + x + " node", cg.getNodes(mid1).iterator().hasNext()); CGNode id1node = cg.getNodes(mid1).iterator().next(); // caller of id1 is dynamic from sortForward, and has 1 compareTo CGNode sfnode = cg.getPredNodes(id1node).next(); int count = 0; for(CallSiteReference site : Iterator2Iterable.make(sfnode.iterateCallSites())) { if (ctnodes.containsAll(cg.getPossibleTargets(sfnode, site))) { count++; } } Assert.assertEquals("expected one call to compareTo", expected, count); System.err.println("found " + count + " compareTo calls in " + sfnode); } }
@Override public Iterator<MethodReference> getSuccNodes(MethodReference N) { Set<MethodReference> succ = HashSetFactory.make(10); MethodReference methodReference = N; for (CGNode node : cg.getNodes(methodReference)) for (CGNode p : Iterator2Iterable.make(cg.getSuccNodes(node))) succ.add(p.getMethod().getReference()); return succ.iterator(); }
nodes.add(cgNode); CallGraph pcg = PartialCallGraph.make(cg, cg.getEntrypointNodes(), nodes); graph = (ISupergraph) ICFGSupergraph.make(pcg); return true; } else { Iterator<CGNode> n = cg.getPredNodes(node); while (n.hasNext()) { return true; n = cg.getSuccNodes(node); while (n.hasNext()) { Iterator<CGNode> succs = cg.getSuccNodes(node); while (succs.hasNext()) { CGNode n1 = succs.next(); Iterator<CGNode> preds = cg.getPredNodes(node); while (preds.hasNext()) { CGNode n2 = preds.next();
@Override public Set<CallerSiteContext> getPotentialCallers(PointerKey formalPk) { CGNode callee = null; if (formalPk instanceof LocalPointerKey) { callee = ((LocalPointerKey) formalPk).getNode(); } else if (formalPk instanceof ReturnValueKey) { callee = ((ReturnValueKey) formalPk).getNode(); } else { throw new IllegalArgumentException("formalPk must represent a local"); } Set<CallerSiteContext> ret = callerCache.get(callee); if (ret == null) { ret = HashSetFactory.make(); for (CGNode caller : Iterator2Iterable.make(cg.getPredNodes(callee))) { for (CallSiteReference call : Iterator2Iterable.make(cg.getPossibleSites(caller, callee))) { ret.add(new CallerSiteContext(caller, call)); } } callerCache.put(callee, ret); } return ret; }
@Test public void testFinalize() throws ClassHierarchyException, IllegalArgumentException, CancelException, IOException { AnalysisScope scope = CallGraphTestUtil.makeJ2SEAnalysisScope(TestConstants.WALA_TESTDATA, CallGraphTestUtil.REGRESSION_EXCLUSIONS); ClassHierarchy cha = ClassHierarchyFactory.make(scope); Iterable<Entrypoint> entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha, "Lfinalizers/Finalizers"); AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints); CallGraph cg = CallGraphTestUtil.buildZeroCFA(options, new AnalysisCacheImpl(), cha, scope, false); // Find node corresponding to finalize TypeReference t = TypeReference.findOrCreate(ClassLoaderReference.Application, "Lfinalizers/Finalizers"); MethodReference m = MethodReference.findOrCreate(t, "finalize", "()V"); Assert.assertTrue("expect finalizer node", cg.getNodes(m).iterator().hasNext()); CGNode node = cg.getNodes(m).iterator().next(); // Check it's reachable from root Assert.assertTrue("should have call site from root", cg.getPossibleSites(cg.getFakeRootNode(), node).hasNext()); } }
@Override public Iterator<MethodReference> getPredNodes(MethodReference N) { Set<MethodReference> pred = HashSetFactory.make(10); MethodReference methodReference = N; for (CGNode cgNode : cg.getNodes(methodReference)) for (CGNode p : Iterator2Iterable.make(cg.getPredNodes(cgNode))) pred.add(p.getMethod().getReference()); return pred.iterator(); }
protected void checkEdges(CallGraph staticCG, Predicate<MethodReference> filter) throws IOException { final Set<Pair<CGNode,CGNode>> edges = HashSetFactory.make(); check(staticCG, (staticCG1, caller, calleeRef) -> { Set<CGNode> nodes = staticCG1.getNodes(calleeRef); Assert.assertEquals("expected one node for " + calleeRef, 1, nodes.size()); CGNode callee = nodes.iterator().next(); Assert.assertTrue("no edge for " + caller + " --> " + callee, staticCG1.getPossibleSites(caller, callee).hasNext()); Pair<CGNode,CGNode> x = Pair.make(caller, callee); if (edges.add(x)) { System.err.println("found expected edge " + caller + " --> " + callee); } }, filter); }
private static IR getIR(CallGraph cg, String fullyQualifiedTypeName, String methodName, String methodParameter, String methodReturnType) { IClassHierarchy classHierarchy = cg.getClassHierarchy(); MethodReference methodRef = IRTests .descriptorToMethodRef( String.format("Source#%s#%s#(%s)%s", fullyQualifiedTypeName, methodName, methodParameter, methodReturnType), classHierarchy); IMethod method = classHierarchy.resolveMethod(methodRef); CGNode node = cg.getNode(method, Everywhere.EVERYWHERE); return node.getIR(); }
Iterator<CGNode> nodes = this.callgraph.iterator(); CGNode srcnode = null, tgtnode = null; com.sap.psr.vulas.shared.json.model.ConstructId src_cid = null, tgt_cid = null; graph.addNode(src_cid); succNodes = this.callgraph.getSuccNodes(srcnode); while (succNodes.hasNext()) { tgtnode = succNodes.next();
@Override public Set<CGNode> getPossibleTargets(CGNode node, CallSiteReference site, LocalPointerKey actualPk) { return cg.getPossibleTargets(node, site); }
public static CGNode findMainMethod(CallGraph cg) { Descriptor d = Descriptor.findOrCreateUTF8("([Ljava/lang/String;)V"); Atom name = Atom.findOrCreateUnicodeAtom("main"); for (CGNode n : Iterator2Iterable.make(cg.getSuccNodes(cg.getFakeRootNode()))) { if (n.getMethod().getName().equals(name) && n.getMethod().getDescriptor().equals(d)) { return n; } } Assertions.UNREACHABLE("failed to find method"); return null; }