Examples with Node soot.jimple.spark.pag.Node used on opensource projects

Example 46 with Node

use of soot.jimple.spark.pag.Node in project soot by Sable.

the class OfflineProcessor method buildImpactGraph.

/**
 * The dependence graph will be destroyed and the impact graph will be built.
 * p = q means q impacts p. Therefore, we add en edge q -> p in impact graph.
 */
protected void buildImpactGraph() {
    for (int i = 0; i < n_var; ++i) {
        varGraph.set(i, null);
    }
    queue.clear();
    for (PlainConstraint cons : geomPTA.constraints) {
        if (!cons.isActive)
            continue;
        final IVarAbstraction lhs = cons.getLHS();
        final IVarAbstraction rhs = cons.getRHS();
        final SparkField field = cons.f;
        IVarAbstraction rep;
        switch(cons.type) {
            case Constants.NEW_CONS:
                // We enqueue the pointers that are allocation result receivers
                queue.add(rhs.id);
                break;
            case Constants.ASSIGN_CONS:
                add_graph_edge(lhs.id, rhs.id);
                break;
            case Constants.LOAD_CONS:
                rep = lhs.getRepresentative();
                if (rep.hasPTResult() == false) {
                    lhs.getWrappedNode().getP2Set().forall(new P2SetVisitor() {

                        @Override
                        public void visit(Node n) {
                            IVarAbstraction padf = geomPTA.findInstanceField((AllocNode) n, field);
                            if (padf == null || padf.reachable() == false)
                                return;
                            add_graph_edge(padf.id, rhs.id);
                        }
                    });
                } else {
                    // use geomPA
                    for (AllocNode o : rep.get_all_points_to_objects()) {
                        IVarAbstraction padf = geomPTA.findInstanceField((AllocNode) o, field);
                        if (padf == null || padf.reachable() == false)
                            continue;
                        add_graph_edge(padf.id, rhs.id);
                    }
                }
                break;
            case Constants.STORE_CONS:
                rep = rhs.getRepresentative();
                if (rep.hasPTResult() == false) {
                    rhs.getWrappedNode().getP2Set().forall(new P2SetVisitor() {

                        @Override
                        public void visit(Node n) {
                            IVarAbstraction padf = geomPTA.findInstanceField((AllocNode) n, field);
                            if (padf == null || padf.reachable() == false)
                                return;
                            add_graph_edge(lhs.id, padf.id);
                        }
                    });
                } else {
                    // use geomPA
                    for (AllocNode o : rep.get_all_points_to_objects()) {
                        IVarAbstraction padf = geomPTA.findInstanceField((AllocNode) o, field);
                        if (padf == null || padf.reachable() == false)
                            continue;
                        add_graph_edge(lhs.id, padf.id);
                    }
                }
                break;
        }
    }
}

Example 47 with Node

use of soot.jimple.spark.pag.Node in project soot by Sable.

the class HeapInsNode method do_before_propagation.

@Override
public void do_before_propagation() {
    // if ( complex_cons == null )
    do_pts_interval_merge();
    // if ( !(me instanceof LocalVarNode) )
    do_flow_edge_interval_merge();
    // This pointer filter, please read the comments at this line in file FullSensitiveNode.java
    Node wrappedNode = getWrappedNode();
    if (wrappedNode instanceof LocalVarNode && ((LocalVarNode) wrappedNode).isThisPtr()) {
        SootMethod func = ((LocalVarNode) wrappedNode).getMethod();
        if (!func.isConstructor()) {
            // We don't process the specialinvoke call edge
            SootClass defClass = func.getDeclaringClass();
            Hierarchy typeHierarchy = Scene.v().getActiveHierarchy();
            for (Iterator<AllocNode> it = new_pts.keySet().iterator(); it.hasNext(); ) {
                AllocNode obj = it.next();
                if (obj.getType() instanceof RefType) {
                    SootClass sc = ((RefType) obj.getType()).getSootClass();
                    if (defClass != sc) {
                        try {
                            SootMethod rt_func = typeHierarchy.resolveConcreteDispatch(sc, func);
                            if (rt_func != func) {
                                it.remove();
                                // Also preclude it from propagation again
                                pt_objs.put(obj, (HeapInsIntervalManager) deadManager);
                            }
                        } catch (RuntimeException e) {
                        // If the input program has a wrong type cast, resolveConcreteDispatch fails and it goes here
                        // We simply ignore this error
                        }
                    }
                }
            }
        }
    }
}

Example 48 with Node

use of soot.jimple.spark.pag.Node in project soot by Sable.

the class EvalResults method estimateHeapDefuseGraph.

/**
 * Estimate the size of the def-use graph for the heap memory. The heap
 * graph is estimated without context information.
 */
public void estimateHeapDefuseGraph() {
    final Map<IVarAbstraction, int[]> defUseCounterForGeom = new HashMap<IVarAbstraction, int[]>();
    final Map<AllocDotField, int[]> defUseCounterForSpark = new HashMap<AllocDotField, int[]>();
    Date begin = new Date();
    for (SootMethod sm : ptsProvider.getAllReachableMethods()) {
        if (sm.isJavaLibraryMethod())
            continue;
        if (!sm.isConcrete())
            continue;
        if (!sm.hasActiveBody()) {
            sm.retrieveActiveBody();
        }
        if (!ptsProvider.isValidMethod(sm))
            continue;
        // We first gather all the memory access expressions
        for (Iterator<Unit> stmts = sm.getActiveBody().getUnits().iterator(); stmts.hasNext(); ) {
            Stmt st = (Stmt) stmts.next();
            if (!(st instanceof AssignStmt))
                continue;
            AssignStmt a = (AssignStmt) st;
            final Value lValue = a.getLeftOp();
            final Value rValue = a.getRightOp();
            InstanceFieldRef ifr = null;
            if (lValue instanceof InstanceFieldRef) {
                // Def statement
                ifr = (InstanceFieldRef) lValue;
            } else if (rValue instanceof InstanceFieldRef) {
                // Use statement
                ifr = (InstanceFieldRef) rValue;
            }
            if (ifr != null) {
                final SootField field = ifr.getField();
                LocalVarNode vn = ptsProvider.findLocalVarNode((Local) ifr.getBase());
                if (vn == null)
                    continue;
                IVarAbstraction pn = ptsProvider.findInternalNode(vn);
                if (pn == null)
                    continue;
                pn = pn.getRepresentative();
                if (!pn.hasPTResult())
                    continue;
                // Spark
                vn.getP2Set().forall(new P2SetVisitor() {

                    @Override
                    public void visit(Node n) {
                        IVarAbstraction padf = ptsProvider.findAndInsertInstanceField((AllocNode) n, field);
                        AllocDotField adf = (AllocDotField) padf.getWrappedNode();
                        int[] defUseUnit = defUseCounterForSpark.get(adf);
                        if (defUseUnit == null) {
                            defUseUnit = new int[2];
                            defUseCounterForSpark.put(adf, defUseUnit);
                        }
                        if (lValue instanceof InstanceFieldRef) {
                            defUseUnit[0]++;
                        } else {
                            defUseUnit[1]++;
                        }
                    }
                });
                // Geom
                Set<AllocNode> objsSet = pn.get_all_points_to_objects();
                for (AllocNode obj : objsSet) {
                    /*
						 * We will create a lot of instance fields. Because in
						 * points-to analysis, we concern only the reference
						 * type fields. But here, we concern all the fields read
						 * write including the primitive type fields.
						 */
                    IVarAbstraction padf = ptsProvider.findAndInsertInstanceField(obj, field);
                    int[] defUseUnit = defUseCounterForGeom.get(padf);
                    if (defUseUnit == null) {
                        defUseUnit = new int[2];
                        defUseCounterForGeom.put(padf, defUseUnit);
                    }
                    if (lValue instanceof InstanceFieldRef) {
                        defUseUnit[0]++;
                    } else {
                        defUseUnit[1]++;
                    }
                }
            }
        }
    }
    for (int[] defUseUnit : defUseCounterForSpark.values()) {
        evalRes.n_spark_du_pairs += ((long) defUseUnit[0]) * defUseUnit[1];
    }
    for (int[] defUseUnit : defUseCounterForGeom.values()) {
        evalRes.n_geom_du_pairs += ((long) defUseUnit[0]) * defUseUnit[1];
    }
    Date end = new Date();
    ptsProvider.ps.println();
    ptsProvider.ps.println("-----------> Heap Def Use Graph Evaluation <------------");
    ptsProvider.ps.println("The edges in the heap def-use graph is (by Geom): " + evalRes.n_geom_du_pairs);
    ptsProvider.ps.println("The edges in the heap def-use graph is (by Spark): " + evalRes.n_spark_du_pairs);
    ptsProvider.ps.printf("Using time: %dms \n", end.getTime() - begin.getTime());
    ptsProvider.ps.println();
}

Example 49 with Node

use of soot.jimple.spark.pag.Node in project soot by Sable.

the class EvalResults method checkCastsSafety.

/**
 * Count how many static casts can be determined safe.
 */
public void checkCastsSafety() {
    for (SootMethod sm : ptsProvider.getAllReachableMethods()) {
        if (sm.isJavaLibraryMethod())
            continue;
        if (!sm.isConcrete())
            continue;
        if (!sm.hasActiveBody()) {
            sm.retrieveActiveBody();
        }
        if (!ptsProvider.isValidMethod(sm))
            continue;
        // All the statements in the method
        for (Iterator<Unit> stmts = sm.getActiveBody().getUnits().iterator(); stmts.hasNext(); ) {
            Stmt st = (Stmt) stmts.next();
            if (st instanceof AssignStmt) {
                Value rhs = ((AssignStmt) st).getRightOp();
                Value lhs = ((AssignStmt) st).getLeftOp();
                if (rhs instanceof CastExpr && lhs.getType() instanceof RefLikeType) {
                    Value v = ((CastExpr) rhs).getOp();
                    VarNode node = ptsProvider.findLocalVarNode(v);
                    if (node == null)
                        continue;
                    IVarAbstraction pn = ptsProvider.findInternalNode(node);
                    if (pn == null)
                        continue;
                    pn = pn.getRepresentative();
                    if (!pn.hasPTResult())
                        continue;
                    evalRes.total_casts++;
                    final Type targetType = (RefLikeType) ((CastExpr) rhs).getCastType();
                    // We first use the geometric points-to result to
                    // evaluate
                    solved = true;
                    Set<AllocNode> set = pn.get_all_points_to_objects();
                    for (AllocNode obj : set) {
                        solved = ptsProvider.castNeverFails(obj.getType(), targetType);
                        if (solved == false)
                            break;
                    }
                    if (solved)
                        evalRes.geom_solved_casts++;
                    // Second is the SPARK result
                    solved = true;
                    node.getP2Set().forall(new P2SetVisitor() {

                        public void visit(Node arg0) {
                            if (solved == false)
                                return;
                            solved = ptsProvider.castNeverFails(arg0.getType(), targetType);
                        }
                    });
                    if (solved)
                        evalRes.spark_solved_casts++;
                }
            }
        }
    }
    ptsProvider.ps.println();
    ptsProvider.ps.println("-----------> Static Casts Safety Evaluation <------------");
    ptsProvider.ps.println("Total casts (app code): " + evalRes.total_casts);
    ptsProvider.ps.println("Safe casts: Geom = " + evalRes.geom_solved_casts + ", SPARK = " + evalRes.spark_solved_casts);
}

Example 50 with Node

use of soot.jimple.spark.pag.Node in project soot by Sable.

the class EvalResults method profileGeomBasicMetrics.

/**
 * Summarize the geometric points-to analysis and report the basic metrics.
 */
public void profileGeomBasicMetrics(boolean testSpark) {
    int n_legal_var = 0, n_alloc_dot_fields = 0;
    int[] limits = new int[] { 1, 5, 10, 25, 50, 75, 100 };
    evalRes.pts_size_bar_geom = new Histogram(limits);
    if (testSpark) {
        evalRes.total_spark_pts = 0;
        evalRes.max_pts_spark = 0;
        evalRes.pts_size_bar_spark = new Histogram(limits);
    }
    // We first count the LOC
    for (SootMethod sm : ptsProvider.getAllReachableMethods()) {
        if (!sm.isConcrete())
            continue;
        if (!sm.hasActiveBody()) {
            sm.retrieveActiveBody();
        }
        evalRes.loc += sm.getActiveBody().getUnits().size();
    }
    for (IVarAbstraction pn : ptsProvider.pointers) {
        // points-to information is equivalent to SPARK
        if (!pn.hasPTResult())
            continue;
        pn = pn.getRepresentative();
        Node var = pn.getWrappedNode();
        if (ptsProvider.isExceptionPointer(var))
            continue;
        if (var instanceof AllocDotField) {
            ++n_alloc_dot_fields;
        }
        ++n_legal_var;
        // ...spark
        int size;
        if (testSpark) {
            size = var.getP2Set().size();
            evalRes.pts_size_bar_spark.addNumber(size);
            evalRes.total_spark_pts += size;
            if (size > evalRes.max_pts_spark)
                evalRes.max_pts_spark = size;
        }
        // ...geom
        size = pn.num_of_diff_objs();
        evalRes.pts_size_bar_geom.addNumber(size);
        evalRes.total_geom_ins_pts += size;
        if (size > evalRes.max_pts_geom)
            evalRes.max_pts_geom = size;
    }
    evalRes.avg_geom_ins_pts = (double) evalRes.total_geom_ins_pts / n_legal_var;
    if (testSpark)
        evalRes.avg_spark_pts = (double) evalRes.total_spark_pts / n_legal_var;
    outputer.println("");
    outputer.println("----------Statistical Result of geomPTA <Data Format: geomPTA (SPARK)>----------");
    outputer.printf("Lines of code (jimple): %.1fK\n", (double) evalRes.loc / 1000);
    outputer.printf("Reachable Methods: %d (%d)\n", ptsProvider.getNumberOfMethods(), ptsProvider.getNumberOfSparkMethods());
    outputer.printf("Reachable User Methods: %d (%d)\n", ptsProvider.n_reach_user_methods, ptsProvider.n_reach_spark_user_methods);
    outputer.println("#All Pointers: " + ptsProvider.getNumberOfPointers());
    outputer.println("#Core Pointers: " + n_legal_var + ", in which #AllocDot Fields: " + n_alloc_dot_fields);
    outputer.printf("Total/Average Projected Points-to Tuples [core pointers]: %d (%d) / %.3f (%.3f) \n", evalRes.total_geom_ins_pts, evalRes.total_spark_pts, evalRes.avg_geom_ins_pts, evalRes.avg_spark_pts);
    outputer.println("The largest points-to set size [core pointers]: " + evalRes.max_pts_geom + " (" + evalRes.max_pts_spark + ")");
    outputer.println();
    evalRes.pts_size_bar_geom.printResult(outputer, "Points-to Set Sizes Distribution [core pointers]:", evalRes.pts_size_bar_spark);
}