Class DefaultICFG

src/main/java/pascal/taie/analysis/graph/icfg/DefaultICFG.java:47–179

import static pascal.taie.analysis.graph.icfg.ICFGBuilder.getCFGOf;

class DefaultICFG extends AbstractICFG<JMethod, Stmt> {

    private static final Logger logger = LogManager.getLogger(DefaultICFG.class);

    private final MultiMap<Stmt, ICFGEdge<Stmt>> inEdges = Maps.newMultiMap();

    private final MultiMap<Stmt, ICFGEdge<Stmt>> outEdges = Maps.newMultiMap();

    private final Map<Stmt, CFG<Stmt>> stmtToCFG = Maps.newLinkedHashMap();

    DefaultICFG(CallGraph<Stmt, JMethod> callGraph) {
        super(callGraph);
        build(callGraph);
    }

    private void build(CallGraph<Stmt, JMethod> callGraph) {
        callGraph.forEach(method -> {
            CFG<Stmt> cfg = getCFGOf(method);
            if (cfg == null) {
                logger.warn("CFG of {} is absent, try to fix this" +
                        " by adding option: -scope REACHABLE", method);
                return;
            }
            cfg.forEach(stmt -> {
                stmtToCFG.put(stmt, cfg);
                cfg.getOutEdgesOf(stmt).forEach(edge -> {
                    ICFGEdge<Stmt> local = isCallSite(stmt) ?
                            new CallToReturnEdge<>(edge) :
                            new NormalEdge<>(edge);
                    outEdges.put(stmt, local);
                    inEdges.put(edge.target(), local);
                });
                if (isCallSite(stmt)) {
                    getCalleesOf(stmt).forEach(callee -> {
                        if (getCFGOf(callee) == null) {
                            logger.warn("CFG of {} is missing", callee);
                            return;
                        }
                        // Add call edges
                        Stmt entry = getEntryOf(callee);
                        CallEdge<Stmt> call = new CallEdge<>(stmt, entry, callee);
                        outEdges.put(stmt, call);
                        inEdges.put(entry, call);
                        // Add return edges
                        Stmt exit = getExitOf(callee);
                        Set<Var> retVars = Sets.newHybridSet();
                        Set<ClassType> exceptions = Sets.newHybridSet();
                        // The exit node of CFG is mock, thus it is not
                        // a real return or excepting Stmt. We need to
                        // collect return and exception information from
                        // the real return and excepting Stmts, and attach
                        // them to the ReturnEdge.
                        getCFGOf(callee).getInEdgesOf(exit).forEach(retEdge -> {
                            if (retEdge.getKind() == CFGEdge.Kind.RETURN) {
                                Return ret = (Return) retEdge.source();
                                if (ret.getValue() != null) {
                                    retVars.add(ret.getValue());
                                }