protected void buildPreds() { buildPredecessor(mainPegChain); Set maps = getStartToThread().entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); List runMethodChainList = (List) entry.getValue(); Iterator it = runMethodChainList.iterator(); while (it.hasNext()) { Chain chain = (Chain) it.next(); // System.out.println("chain is null: "+(chain == null)); buildPredecessor(chain); } } }
private void buildHeadsAndTails() { List tailList = new ArrayList(); List headList = new ArrayList(); // Build the sets { Iterator unitIt = mainPegChain.iterator(); while (unitIt.hasNext()) { JPegStmt s = (JPegStmt) unitIt.next(); List succs = unitToSuccs.get(s); if (succs.size() == 0) tailList.add(s); if (!unitToPreds.containsKey(s)) { System.err.println("unitToPreds does not contain key: " + s); System.exit(1); } List preds = unitToPreds.get(s); if (preds.size() == 0) headList.add(s); // System.out.println("head is:"); } } tails = (List) tailList; heads = (List) headList; // tails = Collections.unmodifiableList(tailList); // heads = Collections.unmodifiableList(headList); Iterator tmpIt = heads.iterator(); while (tmpIt.hasNext()) { Object temp = tmpIt.next(); // System.out.println(temp); } buildPredecessor(mainPegChain); }
/* private void deleteExitToException(){ Iterator it = iterator(); while (it.hasNext()){ JPegStmt stmt = (JPegStmt)it.next(); Unit unit = stmt.getUnit(); UnitGraph unitGraph = stmt.getUnitGraph(); if (unit instanceof ExitMonitorStmt){ Iterator succIt = unitGraph.getSuccsOf(unit).iterator(); while(succIt.next && exceHandlers.contains(un) ){ System.out.println("====find it! unit: "+unit+"\n un: "+un); continue; } } } */ private void buildPredecessor(Chain pegChain) { // System.out.println("==building predcessor==="); // initialize the pred sets to empty { JPegStmt s = null; Iterator unitIt = pegChain.iterator(); while (unitIt.hasNext()) { s = (JPegStmt) unitIt.next(); unitToPreds.put(s, new ArrayList()); } } // System.out.println("==finish init of unitToPred==="); { Iterator unitIt = pegChain.iterator(); while (unitIt.hasNext()) { Object s = unitIt.next(); // System.out.println("s is: "+s); // Modify preds set for each successor for this statement if (unitToSuccs.containsKey(s)) { List succList = unitToSuccs.get(s); Iterator succIt = succList.iterator(); // System.out.println("unitToSuccs contains "+s); // System.out.println("succList is: "+succList); while (succIt.hasNext()) { // Object successor = succIt.next(); JPegStmt successor = (JPegStmt) succIt.next(); // System.out.println("successor is: "+successor); List<Object> predList = unitToPreds.get(successor); // System.out.println("predList is: "+predList); if (predList != null && !predList.contains(s)) { try { predList.add(s); /* Tag tag1 = (Tag)((JPegStmt)s).getTags().get(0); System.out.println("add "+tag1+" "+s+" to predListof"); Tag tag2 = (Tag)((JPegStmt)successor).getTags().get(0); System.out.println(tag2+" "+successor); */ } catch (NullPointerException e) { System.out.println(s + "successor: " + successor); throw e; } // if (((JPegStmt)successor).getName().equals("start")){ if (successor instanceof StartStmt) { List runMethodChainList = startToThread.get(successor); if (runMethodChainList == null) { throw new RuntimeException("null runmehtodchain: \n" + successor.getUnit()); } Iterator possibleMethodIt = runMethodChainList.iterator(); while (possibleMethodIt.hasNext()) { Chain subChain = (Chain) possibleMethodIt.next(); buildPredecessor(subChain); } } } else { System.err.println("predlist of " + s + " is null"); // System.exit(1); } // unitToPreds.put(successor, predList); } } else { System.err.println("unitToSuccs does not contains key" + s); System.exit(1); } } } }
/** * Constructs a graph for the units found in the provided Body instance. Each node in the graph * corresponds to a unit. The edges are derived from the control flow. * * @param body The underlying body we want to make a graph for. * @param addExceptionEdges If true then the control flow edges associated with exceptions are * added. * @param dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock This was added for Dava. If true, * edges are not added from statement before area of protection to catch. If false, edges ARE * added. For Dava, it should be true. For flow analyses, it should be false. * @param Hierarchy Using class hierarchy analysis to find the run method of started thread * @param PointsToAnalysis Using point to analysis (SPARK package) to improve the precision of * results */ public PegGraph( CallGraph callGraph, Hierarchy hierarchy, PAG pag, Set methodsNeedingInlining, Set allocNodes, List<List> inlineSites, Map<SootMethod, String> synchObj, Set multiRunAllocNodes, Map<AllocNode, String> allocNodeToObj, Body unitBody, String threadName, SootMethod sm, boolean addExceEdge, boolean dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock) { this.allocNodeToObj = allocNodeToObj; this.multiRunAllocNodes = multiRunAllocNodes; this.synchObj = synchObj; this.inlineSites = inlineSites; this.allocNodes = allocNodes; this.methodsNeedingInlining = methodsNeedingInlining; logFile = new File("log.txt"); try { fileWriter = new FileWriter(logFile); } catch (IOException io) { System.err.println("Errors occur during create FileWriter !"); // throw io; } body = unitBody; synch = new HashSet<List>(); exceHandlers = new HashSet<Unit>(); needInlining = true; monitorObjs = new HashSet<Object>(); startToBeginNodes = new HashMap(); unitChain = body.getUnits(); int size = unitChain.size(); // initial unitToSuccs, unitToPreds, unitToPegMap, and startToThread unitToSuccs = new HashMap(size * 2 + 1, 0.7f); unitToPreds = new HashMap(size * 2 + 1, 0.7f); // unitToPegMap is the map of a chain to its corresponding (cfg node --> peg node ) map. unitToPegMap = new HashMap(size * 2 + 1, 0.7f); startToThread = new HashMap(size * 2 + 1, 0.7f); startToAllocNodes = new HashMap(size * 2 + 1, 0.7f); waitingNodes = new HashMap<String, FlowSet>(size * 2 + 1, 0.7f); joinStmtToThread = new HashMap<JPegStmt, Chain>(); threadNo = new HashMap(); threadNameToStart = new HashMap(); this.allocNodeToObj = new HashMap<AllocNode, String>(size * 2 + 1, 0.7f); allocNodeToThread = new HashMap<AllocNode, PegChain>(size * 2 + 1, 0.7f); notifyAll = new HashMap<String, Set<JPegStmt>>(size * 2 + 1, 0.7f); methodsNeedingInlining = new HashSet(); allNodes = new ArraySparseSet(); canNotBeCompacted = new HashSet(); threadAllocSites = new HashSet(); specialJoin = new HashSet<JPegStmt>(); // if(Main.isVerbose) // System.out.println(" Constructing PegGraph..."); // if(Main.isProfilingOptimization) // Main.graphTimer.start(); // make a peg for debug /* mainPegChain = new HashChain(); specialTreatment1(); */ // end make a peg UnitGraph mainUnitGraph = new CompleteUnitGraph(body); // mainPegChain = new HashChain(); mainPegChain = new PegChain( callGraph, hierarchy, pag, threadAllocSites, methodsNeedingInlining, allocNodes, inlineSites, synchObj, multiRunAllocNodes, allocNodeToObj, body, sm, threadName, true, this); // testPegChain(); // System.out.println("finish building chain"); // testStartToThread(); // buildSuccessor(mainUnitGraph, mainPegChain,addExceptionEdges); // buildSuccessorForExtendingMethod(mainPegChain); // testSet(exceHandlers, "exceHandlers"); buildSuccessor(mainPegChain); // System.out.println("finish building successors"); // unmodifiableSuccs(mainPegChain); // testUnitToSucc ); buildPredecessor(mainPegChain); // System.out.println("finish building predcessors"); // unmodifiablePreds(mainPegChain); // testSynch(); addMonitorStmt(); addTag(); // System.out.println(this.toString()); buildHeadsAndTails(); // testIterator(); // testWaitingNodes(); // System.out.println("finish building heads and tails"); // testSet(canNotBeCompacted, "canNotBeCompacted"); // computeEdgeAndThreadNo(); // testExtendingPoints(); // testUnitToSucc(); // testPegChain(); /* if (print) { PegToDotFile printer1 = new PegToDotFile(this, false, sm.getName()); } */ try { fileWriter.flush(); fileWriter.close(); } catch (IOException io) { System.err.println("Errors occur during close file " + logFile.getName()); // throw io; } // System.out.println("==threadAllocaSits==\n"+threadAllocSites.toString()); }