Examples with PointsToSetInternal soot.jimple.spark.sets.PointsToSetInternal used on opensource projects

Example 16 with PointsToSetInternal

use of soot.jimple.spark.sets.PointsToSetInternal in project soot by Sable.

the class MergeChecker method checkNode.

protected void checkNode(Node container, Node n, Node upstream) {
    if (container.getReplacement() != container)
        throw new RuntimeException("container " + container + " is illegal");
    if (upstream.getReplacement() != upstream)
        throw new RuntimeException("upstream " + upstream + " is illegal");
    PointsToSetInternal p2set = container.getP2Set();
    FastHierarchy fh = pag.getTypeManager().getFastHierarchy();
    if (!p2set.contains(n) && (fh == null || container.getType() == null || fh.canStoreType(n.getType(), container.getType()))) {
        logger.debug("Check failure: " + container + " does not have " + n + "; upstream is " + upstream);
    }
}

Example 17 with PointsToSetInternal

use of soot.jimple.spark.sets.PointsToSetInternal in project soot by Sable.

the class PropAlias method handleVarNode.

/**
 * Propagates new points-to information of node src to all its successors.
 */
protected final boolean handleVarNode(final VarNode src) {
    boolean ret = false;
    if (src.getReplacement() != src)
        throw new RuntimeException("Got bad node " + src + " with rep " + src.getReplacement());
    final PointsToSetInternal newP2Set = src.getP2Set().getNewSet();
    if (newP2Set.isEmpty())
        return false;
    if (ofcg != null) {
        QueueReader<Node> addedEdges = pag.edgeReader();
        ofcg.updatedNode(src);
        ofcg.build();
        while (addedEdges.hasNext()) {
            Node addedSrc = (Node) addedEdges.next();
            Node addedTgt = (Node) addedEdges.next();
            ret = true;
            if (addedSrc instanceof VarNode) {
                VarNode edgeSrc = (VarNode) addedSrc;
                if (addedTgt instanceof VarNode) {
                    VarNode edgeTgt = (VarNode) addedTgt;
                    if (edgeTgt.makeP2Set().addAll(edgeSrc.getP2Set(), null))
                        addToWorklist(edgeTgt);
                } else if (addedTgt instanceof NewInstanceNode) {
                    NewInstanceNode edgeTgt = (NewInstanceNode) addedTgt.getReplacement();
                    if (edgeTgt.makeP2Set().addAll(edgeSrc.getP2Set(), null)) {
                        for (Node element : pag.assignInstanceLookup(edgeTgt)) {
                            addToWorklist((VarNode) element);
                        }
                    }
                }
            } else if (addedSrc instanceof AllocNode) {
                AllocNode edgeSrc = (AllocNode) addedSrc;
                VarNode edgeTgt = (VarNode) addedTgt;
                if (edgeTgt.makeP2Set().add(edgeSrc))
                    addToWorklist(edgeTgt);
            } else if (addedSrc instanceof NewInstanceNode && addedTgt instanceof VarNode) {
                final NewInstanceNode edgeSrc = (NewInstanceNode) addedSrc.getReplacement();
                final VarNode edgeTgt = (VarNode) addedTgt.getReplacement();
                addedSrc.getP2Set().forall(new P2SetVisitor() {

                    @Override
                    public void visit(Node n) {
                        if (n instanceof ClassConstantNode) {
                            ClassConstantNode ccn = (ClassConstantNode) n;
                            Type ccnType = ccn.getClassConstant().toSootType();
                            // If the referenced class has not been loaded,
                            // we do this now
                            SootClass targetClass = ((RefType) ccnType).getSootClass();
                            if (targetClass.resolvingLevel() == SootClass.DANGLING)
                                Scene.v().forceResolve(targetClass.getName(), SootClass.SIGNATURES);
                            edgeTgt.makeP2Set().add(pag.makeAllocNode(edgeSrc.getValue(), ccnType, ccn.getMethod()));
                            addToWorklist(edgeTgt);
                        }
                    }
                });
            }
            FieldRefNode frn = null;
            if (addedSrc instanceof FieldRefNode)
                frn = (FieldRefNode) addedSrc;
            if (addedTgt instanceof FieldRefNode)
                frn = (FieldRefNode) addedTgt;
            if (frn != null) {
                VarNode base = frn.getBase();
                if (fieldToBase.put(frn.getField(), base)) {
                    aliasWorkList.add(base);
                }
            }
        }
    }
    Node[] simpleTargets = pag.simpleLookup(src);
    for (Node element : simpleTargets) {
        if (element.makeP2Set().addAll(newP2Set, null)) {
            addToWorklist((VarNode) element);
            ret = true;
        }
    }
    Node[] storeTargets = pag.storeLookup(src);
    for (Node element : storeTargets) {
        final FieldRefNode fr = (FieldRefNode) element;
        if (fr.makeP2Set().addAll(newP2Set, null)) {
            fieldRefWorkList.add(fr);
            ret = true;
        }
    }
    src.getP2Set().flushNew();
    return ret;
}

Example 18 with PointsToSetInternal

use of soot.jimple.spark.sets.PointsToSetInternal in project soot by Sable.

the class PropAlias method propagate.

/**
 * Actually does the propagation.
 */
public final void propagate() {
    ofcg = pag.getOnFlyCallGraph();
    new TopoSorter(pag, false).sort();
    for (Object object : pag.loadSources()) {
        final FieldRefNode fr = (FieldRefNode) object;
        fieldToBase.put(fr.getField(), fr.getBase());
    }
    for (Object object : pag.storeInvSources()) {
        final FieldRefNode fr = (FieldRefNode) object;
        fieldToBase.put(fr.getField(), fr.getBase());
    }
    for (Object object : pag.allocSources()) {
        handleAllocNode((AllocNode) object);
    }
    boolean verbose = pag.getOpts().verbose();
    do {
        if (verbose) {
            logger.debug("Worklist has " + varNodeWorkList.size() + " nodes.");
        }
        aliasWorkList = new HashSet<VarNode>();
        while (!varNodeWorkList.isEmpty()) {
            VarNode src = varNodeWorkList.iterator().next();
            varNodeWorkList.remove(src);
            aliasWorkList.add(src);
            handleVarNode(src);
        }
        if (verbose) {
            logger.debug("Now handling field references");
        }
        for (VarNode src : aliasWorkList) {
            for (FieldRefNode srcFr : src.getAllFieldRefs()) {
                SparkField field = srcFr.getField();
                for (VarNode dst : fieldToBase.get(field)) {
                    if (src.getP2Set().hasNonEmptyIntersection(dst.getP2Set())) {
                        FieldRefNode dstFr = dst.dot(field);
                        aliasEdges.put(srcFr, dstFr);
                        aliasEdges.put(dstFr, srcFr);
                        fieldRefWorkList.add(srcFr);
                        fieldRefWorkList.add(dstFr);
                        if (makeP2Set(dstFr).addAll(srcFr.getP2Set().getOldSet(), null)) {
                            outFieldRefWorkList.add(dstFr);
                        }
                        if (makeP2Set(srcFr).addAll(dstFr.getP2Set().getOldSet(), null)) {
                            outFieldRefWorkList.add(srcFr);
                        }
                    }
                }
            }
        }
        for (FieldRefNode src : fieldRefWorkList) {
            for (FieldRefNode dst : aliasEdges.get(src)) {
                if (makeP2Set(dst).addAll(src.getP2Set().getNewSet(), null)) {
                    outFieldRefWorkList.add(dst);
                }
            }
            src.getP2Set().flushNew();
        }
        fieldRefWorkList = new HashSet<FieldRefNode>();
        for (FieldRefNode src : outFieldRefWorkList) {
            PointsToSetInternal set = getP2Set(src).getNewSet();
            if (set.isEmpty())
                continue;
            Node[] targets = pag.loadLookup(src);
            for (Node element0 : targets) {
                VarNode target = (VarNode) element0;
                if (target.makeP2Set().addAll(set, null)) {
                    addToWorklist(target);
                }
            }
            getP2Set(src).flushNew();
        }
        outFieldRefWorkList = new HashSet<FieldRefNode>();
    } while (!varNodeWorkList.isEmpty());
}

Example 19 with PointsToSetInternal

use of soot.jimple.spark.sets.PointsToSetInternal in project soot by Sable.

the class PropIter method handleSimples.

protected final boolean handleSimples(VarNode src) {
    boolean ret = false;
    PointsToSetInternal srcSet = src.getP2Set();
    if (srcSet.isEmpty())
        return false;
    Node[] simpleTargets = pag.simpleLookup(src);
    for (Node element : simpleTargets) {
        ret = element.makeP2Set().addAll(srcSet, null) | ret;
    }
    Node[] newInstances = pag.newInstanceLookup(src);
    for (Node element : newInstances) {
        ret = element.makeP2Set().addAll(srcSet, null) | ret;
    }
    return ret;
}

Example 20 with PointsToSetInternal

use of soot.jimple.spark.sets.PointsToSetInternal in project soot by Sable.

the class PropIter method propagate.

/**
 * Actually does the propagation.
 */
public final void propagate() {
    final OnFlyCallGraph ofcg = pag.getOnFlyCallGraph();
    new TopoSorter(pag, false).sort();
    for (Object object : pag.allocSources()) {
        handleAllocNode((AllocNode) object);
    }
    int iteration = 1;
    boolean change;
    do {
        change = false;
        TreeSet<VarNode> simpleSources = new TreeSet<VarNode>(pag.simpleSources());
        if (pag.getOpts().verbose()) {
            logger.debug("Iteration " + (iteration++));
        }
        for (VarNode object : simpleSources) {
            change = handleSimples(object) | change;
        }
        if (ofcg != null) {
            QueueReader<Node> addedEdges = pag.edgeReader();
            for (VarNode src : pag.getVarNodeNumberer()) {
                ofcg.updatedNode(src);
            }
            ofcg.build();
            while (addedEdges.hasNext()) {
                Node addedSrc = (Node) addedEdges.next();
                Node addedTgt = (Node) addedEdges.next();
                change = true;
                if (addedSrc instanceof VarNode) {
                    PointsToSetInternal p2set = ((VarNode) addedSrc).getP2Set();
                    if (p2set != null)
                        p2set.unFlushNew();
                } else if (addedSrc instanceof AllocNode) {
                    ((VarNode) addedTgt).makeP2Set().add(addedSrc);
                }
            }
            if (change) {
                new TopoSorter(pag, false).sort();
            }
        }
        for (FieldRefNode object : pag.loadSources()) {
            change = handleLoads(object) | change;
        }
        for (VarNode object : pag.storeSources()) {
            change = handleStores(object) | change;
        }
        for (NewInstanceNode object : pag.assignInstanceSources()) {
            change = handleNewInstances(object) | change;
        }
    } while (change);
}