protected void computeEdgeAndThreadNo() { Iterator it = iterator(); int numberOfEdge = 0; while (it.hasNext()) { List succList = (List) getSuccsOf(it.next()); numberOfEdge = numberOfEdge + succList.size(); } numberOfEdge = numberOfEdge + startToThread.size(); System.err.println("**number of edges: " + numberOfEdge); System.err.println("**number of threads: " + (startToThread.size() + 1)); /* Set keySet = startToThread.keySet(); Iterator keyIt = keySet.iterator(); while (keyIt.hasNext()){ List list = (List)startToThread.get(keyIt.next()); System.out.println("********start thread:"); Iterator itit = list.iterator(); while (itit.hasNext()){ System.out.println(it.next()); } } */ }
protected void testPegChain(Chain chain) { System.out.println("******** chain********"); Iterator it = chain.iterator(); while (it.hasNext()) { /*Object o = it.next(); System.out.println(o); if (!(o instanceof JPegStmt)) System.out.println("not instanceof JPegStmt: "+o); JPegStmt s = (JPegStmt)o; */ JPegStmt stmt = (JPegStmt) it.next(); System.out.println(stmt.toString()); /*if (stmt.getName().equals("start")){ System.out.println("find start method in : " + stmt.toString() ); List list =(List)startToThread.get(stmt); Iterator chainIt = list.iterator(); while (chainIt.hasNext()){ Chain chain = (Chain)chainIt.next(); Iterator subit = chain.iterator(); while (subit.hasNext()){ System.out.println("**" + ((JPegStmt)subit.next()).toString()); } } System.out.println("$$$$$$returing to main chain"); } */ } }
private void insertAfter(JPegStmt node, JPegStmt after) { // System.out.println("node: "+node); // System.out.println("after: "+after); // System.out.println("succs of node: "+getSuccsOf(node)); // this must be done first because the succs of node will be chanaged lately List succOfAfter = new ArrayList(); succOfAfter.addAll(getSuccsOf(node)); unitToSuccs.put(after, succOfAfter); Iterator succsIt = getSuccsOf(node).iterator(); while (succsIt.hasNext()) { Object succ = succsIt.next(); List pred = getPredsOf(succ); pred.remove(node); pred.add(after); } List succOfNode = new ArrayList(); succOfNode.add(after); unitToSuccs.put(node, succOfNode); List predOfAfter = new ArrayList(); predOfAfter.add(node); unitToPreds.put(after, predOfAfter); // buildPredecessor(Chain pegChain); }
protected void testStartToThread() { System.out.println("=====test startToThread "); Set maps = startToThread.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); JPegStmt key = (JPegStmt) entry.getKey(); Tag tag = (Tag) key.getTags().get(0); System.out.println("---key= " + tag + " " + key); /* List list = (List)entry.getValue(); if (list.size()>0){ System.out.println("**thread set:"); Iterator it = list.iterator(); while (it.hasNext()){ Chain chain =(Chain)it.next(); Iterator chainIt = chain.iterator(); System.out.println("the size of chain is: "+chain.size()); while (chainIt.hasNext()){ JPegStmt stmt = (JPegStmt)chainIt.next(); System.out.println(stmt); } } } */ } System.out.println("=========startToThread--ends--------"); }
protected void testList(List list) { // System.out.println("test list"); Iterator listIt = list.iterator(); while (listIt.hasNext()) { System.out.println(listIt.next()); } }
// helper function protected void testIterator() { System.out.println("********begin test iterator*******"); Iterator testIt = iterator(); while (testIt.hasNext()) { System.out.println(testIt.next()); } System.out.println("********end test iterator*******"); System.out.println("=======size is: " + size()); }
protected void testSet(Set set, String name) { System.out.println("$test set " + name); Iterator setIt = set.iterator(); while (setIt.hasNext()) { Object s = setIt.next(); // JPegStmt s = (JPegStmt)setIt.next(); // Tag tag = (Tag)s.getTags().get(0); System.out.println(s); } }
protected void testSynch() { Iterator<List> it = synch.iterator(); System.out.println("========test synch======"); while (it.hasNext()) { // JPegStmt s = (JPegStmt)it.next(); // Tag tag = (Tag)s.getTags().get(0); // System.out.println(tag+" "+s); System.out.println(it.next()); } System.out.println("========end test synch======"); }
protected void testUnitToPeg(HashMap unitToPeg) { System.out.println("=====test unitToPeg "); Set maps = unitToPeg.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); System.out.println("---key= " + entry.getKey()); JPegStmt s = (JPegStmt) entry.getValue(); System.out.println("--value= " + s); } System.out.println("=========unitToPeg--ends--------"); }
protected void testJoinStmtToThread() { System.out.println("=====test JoinStmtToThread"); Set maps = threadNameToStart.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); Object key = entry.getKey(); System.out.println("---key= " + key); System.out.println("value: " + entry.getValue()); } System.out.println("=========JoinStmtToThread--ends--------"); }
protected void addTag() { // add tag for each stmt Iterator it = iterator(); // int count = 0; while (it.hasNext()) { JPegStmt stmt = (JPegStmt) it.next(); int count = Counter.getTagNo(); // count++; StringTag t = new StringTag(Integer.toString(count)); stmt.addTag(t); } }
protected void testThreadNameToStart() { System.out.println("=====test ThreadNameToStart"); Set maps = threadNameToStart.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); Object key = entry.getKey(); System.out.println("---key= " + key); JPegStmt stmt = (JPegStmt) entry.getValue(); Tag tag1 = (Tag) stmt.getTags().get(0); System.out.println("value: " + tag1 + " " + stmt); } System.out.println("=========ThreadNameToStart--ends--------"); }
private boolean removeBeginNode() { List heads = getHeads(); if (heads.size() != 1) { // System.out.println("heads: "+heads); // System.out.println("Error: the size of heads is not equal to 1!"); return false; // System.exit(1); } else { JPegStmt head = (JPegStmt) heads.get(0); // System.out.println("test head: "+head); if (!head.getName().equals("begin")) { System.err.println("Error: the head is not begin node!"); System.exit(1); } // remove begin node from heads list heads.remove(0); // set the preds list of the succs of head to a new list and put succs of head into heads Iterator succOfHeadIt = getSuccsOf(head).iterator(); while (succOfHeadIt.hasNext()) { JPegStmt succOfHead = (JPegStmt) succOfHeadIt.next(); unitToPreds.put(succOfHead, new ArrayList()); // put succs of head into heads heads.add(succOfHead); } // remove begin node from inlinee Peg if (!mainPegChain.remove(head)) { System.err.println("fail to remove begin node in from mainPegChain!"); System.exit(1); } if (!allNodes.contains(head)) { System.err.println("fail to find begin node in FlowSet allNodes!"); System.exit(1); } else { allNodes.remove(head); } // remove begin node from unitToSuccs if (unitToSuccs.containsKey(head)) { unitToSuccs.remove(head); } } return true; }
public String toString() { Iterator it = iterator(); StringBuffer buf = new StringBuffer(); while (it.hasNext()) { JPegStmt u = (JPegStmt) it.next(); buf.append("u is: " + u + "\n"); List l = new ArrayList(); l.addAll(getPredsOf(u)); buf.append("preds: " + l + "\n"); // buf.append(u.toString() + '\n'); l = new ArrayList(); l.addAll(getSuccsOf(u)); buf.append("succs: " + l + "\n"); } return buf.toString(); }
/** * given a DelayabilityAnalysis and the computations of each unit, calculates the latest * computation-point for each expression.<br> * the <code>equivRhsMap</code> could be calculated on the fly, but it is <b>very</b> likely that * it already exists (as similar maps are used for calculating Earliestness, Delayed,...<br> * the shared set allows more efficient set-operations, when they the computation is merged with * other analyses/computations. * * @param dg a ExceptionalUnitGraph * @param delayed the delayability-analysis of the same graph. * @param equivRhsMap all computations of the graph * @param set the shared flowSet */ public LatestComputation( UnitGraph unitGraph, DelayabilityAnalysis delayed, Map equivRhsMap, BoundedFlowSet set) { unitToLatest = new HashMap<Unit, FlowSet>(unitGraph.size() + 1, 0.7f); Iterator unitIt = unitGraph.iterator(); while (unitIt.hasNext()) { /* create a new Earliest-list for each unit */ Unit currentUnit = (Unit) unitIt.next(); /* basically the latest-set is: * (delayed) INTERSECT (comp UNION (UNION_successors ~Delayed)) = * (delayed) MINUS ((INTERSECTION_successors Delayed) MINUS comp). */ FlowSet delaySet = (FlowSet) delayed.getFlowBefore(currentUnit); /* Calculate (INTERSECTION_successors Delayed) */ FlowSet succCompSet = (FlowSet) set.topSet(); List succList = unitGraph.getSuccsOf(currentUnit); Iterator succIt = succList.iterator(); while (succIt.hasNext()) { Unit successor = (Unit) succIt.next(); succCompSet.intersection((FlowSet) delayed.getFlowBefore(successor), succCompSet); } /* remove the computation of this set: succCompSet is then: * ((INTERSECTION_successors Delayed) MINUS comp) */ if (equivRhsMap.get(currentUnit) != null) succCompSet.remove(equivRhsMap.get(currentUnit)); /* make the difference: */ FlowSet latest = (FlowSet) delaySet.emptySet(); delaySet.difference(succCompSet, latest); unitToLatest.put(currentUnit, latest); } }
/** * Computes the analysis given a UnitGraph computed from a method body. It is recommended that a * ExceptionalUnitGraph (or similar) be provided for correct results in the case of exceptional * control flow. * * @param g a graph on which to compute the analysis. * @see ExceptionalUnitGraph */ public SimpleLiveLocals(UnitGraph graph) { if (Options.v().time()) Timers.v().liveTimer.start(); if (Options.v().verbose()) G.v() .out .println( "[" + graph.getBody().getMethod().getName() + "] Constructing SimpleLiveLocals..."); SimpleLiveLocalsAnalysis analysis = new SimpleLiveLocalsAnalysis(graph); if (Options.v().time()) Timers.v().livePostTimer.start(); // Build unitToLocals map { unitToLocalsAfter = new HashMap<Unit, List>(graph.size() * 2 + 1, 0.7f); unitToLocalsBefore = new HashMap<Unit, List>(graph.size() * 2 + 1, 0.7f); Iterator unitIt = graph.iterator(); while (unitIt.hasNext()) { Unit s = (Unit) unitIt.next(); FlowSet set = (FlowSet) analysis.getFlowBefore(s); unitToLocalsBefore.put(s, Collections.unmodifiableList(set.toList())); set = (FlowSet) analysis.getFlowAfter(s); unitToLocalsAfter.put(s, Collections.unmodifiableList(set.toList())); } } if (Options.v().time()) Timers.v().livePostTimer.end(); if (Options.v().time()) Timers.v().liveTimer.end(); }
private void insertBefore(JPegStmt node, JPegStmt enter) { // build preds of before List predOfBefore = new ArrayList(); predOfBefore.addAll(getPredsOf(node)); unitToPreds.put(enter, predOfBefore); // System.out.println("put into unitToPreds enter: "+enter); // System.out.println("put into unitToPreds value: "+predOfBefore); Iterator predsIt = getPredsOf(node).iterator(); // build succs of former preds of node while (predsIt.hasNext()) { Object pred = predsIt.next(); List succ = getSuccsOf(pred); succ.remove(node); succ.add(enter); // System.out.println("in unitToPred pred: "+pred); // System.out.println("in unitToPred value is: "+succ); } List succOfBefore = new ArrayList(); succOfBefore.add(node); unitToSuccs.put(enter, succOfBefore); // System.out.println("put into unitToSuccs enter: "+enter); // System.out.println("put into unitToSuccs value: "+succOfBefore); List predOfNode = new ArrayList(); predOfNode.add(enter); unitToPreds.put(node, predOfNode); // System.out.println("put into unitToPreds enter: "+node); // System.out.println("put into unitToPreds value: "+predOfNode); // buildPreds(); }
/** Prints the given <code>JimpleBody</code> to the specified <code>PrintWriter</code>. */ private void printLocalsInBody(Body body, UnitPrinter up) { // Print out local variables { Map typeToLocals = new DeterministicHashMap(body.getLocalCount() * 2 + 1, 0.7f); // Collect locals { Iterator localIt = body.getLocals().iterator(); while (localIt.hasNext()) { Local local = (Local) localIt.next(); List localList; Type t = local.getType(); if (typeToLocals.containsKey(t)) localList = (List) typeToLocals.get(t); else { localList = new ArrayList(); typeToLocals.put(t, localList); } localList.add(local); } } // Print locals { Iterator typeIt = typeToLocals.keySet().iterator(); while (typeIt.hasNext()) { Type type = (Type) typeIt.next(); List localList = (List) typeToLocals.get(type); Object[] locals = localList.toArray(); up.type(type); up.literal(" "); for (int k = 0; k < locals.length; k++) { if (k != 0) up.literal(", "); up.local((Local) locals[k]); } up.literal(";"); up.newline(); } } if (!typeToLocals.isEmpty()) { up.newline(); } } }
public void testMonitor() { System.out.println("=====test monitor size: " + monitor.size()); Set maps = monitor.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); String key = (String) entry.getKey(); System.out.println("---key= " + key); FlowSet list = (FlowSet) entry.getValue(); if (list.size() > 0) { System.out.println("**set: " + list.size()); Iterator it = list.iterator(); while (it.hasNext()) { Object obj = it.next(); if (obj instanceof JPegStmt) { JPegStmt stmt = (JPegStmt) obj; Tag tag1 = (Tag) stmt.getTags().get(0); System.out.println(tag1 + " " + stmt); } else { System.out.println("---list---"); Iterator listIt = ((List) obj).iterator(); while (listIt.hasNext()) { Object oo = listIt.next(); if (oo instanceof JPegStmt) { JPegStmt unit = (JPegStmt) oo; Tag tag = (Tag) unit.getTags().get(0); System.out.println(tag + " " + unit); } else System.out.println(oo); } System.out.println("---list--end-"); } } } } System.out.println("=========monitor--ends--------"); }
public void computeMonitorObjs() { Set maps = monitor.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); FlowSet fs = (FlowSet) entry.getValue(); Iterator it = fs.iterator(); while (it.hasNext()) { Object obj = it.next(); if (!monitorObjs.contains(obj)) monitorObjs.add(obj); } } }
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); } } }
public void testWaitingNodes() { System.out.println("------waiting---begin"); Set maps = waitingNodes.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); System.out.println("---key= " + entry.getKey()); FlowSet fs = (FlowSet) entry.getValue(); if (fs.size() > 0) { System.out.println("**waiting nodes set:"); Iterator it = fs.iterator(); while (it.hasNext()) { JPegStmt unit = (JPegStmt) it.next(); System.out.println(unit.toString()); } } } System.out.println("------------waitingnodes---ends--------"); }
public boolean addPeg(PegGraph pg, Chain chain) { if (!pg.removeBeginNode()) return false; // System.out.println("adding one peg into another"); // System.out.println("after removeBeginNode==="); // pg.testPegChain(); // System.out.println(pg); // put every node of peg into this Iterator mainIt = pg.mainIterator(); while (mainIt.hasNext()) { JPegStmt s = (JPegStmt) mainIt.next(); // System.out.println("add to mainPegChain: "+s); mainPegChain.addLast(s); // if (chain.contains(s)){ // System.err.println("error! chain contains: "+s); // System.exit(1); // } // else // chain.addLast(s); } Iterator it = pg.iterator(); while (it.hasNext()) { JPegStmt s = (JPegStmt) it.next(); // System.out.println("add to allNodes: "+s); if (allNodes.contains(s)) { System.err.println("error! allNodes contains: " + s); System.exit(1); } else allNodes.add(s); } // testPegChain(); // testIterator(); unitToSuccs.putAll(pg.getUnitToSuccs()); unitToPreds.putAll(pg.getUnitToPreds()); // testUnitToSucc(); // testUnitToPred(); // buildMaps(pg); // RLH return true; }
protected void testUnitToSucc() { System.out.println("=====test unitToSucc "); Set maps = unitToSuccs.entrySet(); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); JPegStmt key = (JPegStmt) entry.getKey(); Tag tag = (Tag) key.getTags().get(0); System.out.println("---key= " + tag + " " + key); List list = (List) entry.getValue(); if (list.size() > 0) { System.out.println("**succ set: size: " + list.size()); Iterator it = list.iterator(); while (it.hasNext()) { JPegStmt stmt = (JPegStmt) it.next(); Tag tag1 = (Tag) stmt.getTags().get(0); System.out.println(tag1 + " " + stmt); } } } System.out.println("=========unitToSucc--ends--------"); }
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); }
SimpleLiveLocalsAnalysis(UnitGraph g) { super(g); if (Options.v().time()) Timers.v().liveSetupTimer.start(); emptySet = new ArraySparseSet(); // Create kill sets. { unitToKillSet = new HashMap<Unit, FlowSet>(g.size() * 2 + 1, 0.7f); Iterator unitIt = g.iterator(); while (unitIt.hasNext()) { Unit s = (Unit) unitIt.next(); FlowSet killSet = emptySet.clone(); Iterator boxIt = s.getDefBoxes().iterator(); while (boxIt.hasNext()) { ValueBox box = (ValueBox) boxIt.next(); if (box.getValue() instanceof Local) killSet.add(box.getValue(), killSet); } unitToKillSet.put(s, killSet); } } // Create generate sets { unitToGenerateSet = new HashMap<Unit, FlowSet>(g.size() * 2 + 1, 0.7f); Iterator unitIt = g.iterator(); while (unitIt.hasNext()) { Unit s = (Unit) unitIt.next(); FlowSet genSet = emptySet.clone(); Iterator boxIt = s.getUseBoxes().iterator(); while (boxIt.hasNext()) { ValueBox box = (ValueBox) boxIt.next(); if (box.getValue() instanceof Local) genSet.add(box.getValue(), genSet); } unitToGenerateSet.put(s, genSet); } } if (Options.v().time()) Timers.v().liveSetupTimer.end(); if (Options.v().time()) Timers.v().liveAnalysisTimer.start(); doAnalysis(); if (Options.v().time()) Timers.v().liveAnalysisTimer.end(); }
/** * This method pushes all newExpr down to be the stmt directly before every invoke of the init * only if they are in the types list */ public void internalTransform(Body b, String phaseName, Map options) { JimpleBody body = (JimpleBody) b; if (Options.v().verbose()) G.v().out.println("[" + body.getMethod().getName() + "] Folding Jimple constructors..."); Chain units = body.getUnits(); List<Unit> stmtList = new ArrayList<Unit>(); stmtList.addAll(units); Iterator<Unit> it = stmtList.iterator(); Iterator<Unit> nextStmtIt = stmtList.iterator(); // start ahead one nextStmtIt.next(); SmartLocalDefs localDefs = SmartLocalDefsPool.v().getSmartLocalDefsFor(body); UnitGraph graph = localDefs.getGraph(); LocalUses localUses = new SimpleLocalUses(graph, localDefs); /* fold in NewExpr's with specialinvoke's */ while (it.hasNext()) { Stmt s = (Stmt) it.next(); if (!(s instanceof AssignStmt)) continue; /* this should be generalized to ArrayRefs */ // only deal with stmts that are an local = newExpr Value lhs = ((AssignStmt) s).getLeftOp(); if (!(lhs instanceof Local)) continue; Value rhs = ((AssignStmt) s).getRightOp(); if (!(rhs instanceof NewExpr)) continue; // check if very next statement is invoke --> // this indicates there is no control flow between // new and invoke and should do nothing if (nextStmtIt.hasNext()) { Stmt next = (Stmt) nextStmtIt.next(); if (next instanceof InvokeStmt) { InvokeStmt invoke = (InvokeStmt) next; if (invoke.getInvokeExpr() instanceof SpecialInvokeExpr) { SpecialInvokeExpr invokeExpr = (SpecialInvokeExpr) invoke.getInvokeExpr(); if (invokeExpr.getBase() == lhs) { break; } } } } // check if new is in the types list - only process these if (!types.contains(((NewExpr) rhs).getType())) continue; List lu = localUses.getUsesOf(s); Iterator luIter = lu.iterator(); boolean MadeNewInvokeExpr = false; while (luIter.hasNext()) { Unit use = ((UnitValueBoxPair) (luIter.next())).unit; if (!(use instanceof InvokeStmt)) continue; InvokeStmt is = (InvokeStmt) use; if (!(is.getInvokeExpr() instanceof SpecialInvokeExpr) || lhs != ((SpecialInvokeExpr) is.getInvokeExpr()).getBase()) continue; // make a new one here AssignStmt constructStmt = Jimple.v() .newAssignStmt(((DefinitionStmt) s).getLeftOp(), ((DefinitionStmt) s).getRightOp()); constructStmt.setRightOp(Jimple.v().newNewExpr(((NewExpr) rhs).getBaseType())); MadeNewInvokeExpr = true; // redirect jumps use.redirectJumpsToThisTo(constructStmt); // insert new one here units.insertBefore(constructStmt, use); constructStmt.addTag(s.getTag("SourceLnPosTag")); } if (MadeNewInvokeExpr) { units.remove(s); } } }
protected void buildSuccsForInlining(JPegStmt stmt, Chain chain, PegGraph inlinee) { // System.out.println("entering buildSuccsForInlining..."); Tag tag = (Tag) stmt.getTags().get(0); // System.out.println("stmt is: "+tag+" "+stmt); /*connect heads of inlinee with the preds of invokeStmt and * delete stmt from the succs list from the preds */ Iterator predIt = getPredsOf(stmt).iterator(); // System.out.println("preds list: "+getPredsOf(stmt)); // System.out.println("preds size: "+getPredsOf(stmt).size()); Iterator headsIt = inlinee.getHeads().iterator(); { // System.out.println("heads: "+inlinee.getHeads()); while (predIt.hasNext()) { JPegStmt pred = (JPegStmt) predIt.next(); // System.out.println("pred: "+pred); List succList = (List) getSuccsOf(pred); // System.out.println("succList of pred: "+succList); int pos = succList.indexOf(stmt); // System.out.println("remove : "+stmt + " from succList: \n"+succList+ "\n of pred" ); // remove invokeStmt succList.remove(pos); while (headsIt.hasNext()) { succList.add(headsIt.next()); } unitToSuccs.put(pred, succList); } { while (headsIt.hasNext()) { Object head = headsIt.next(); List predsOfHeads = new ArrayList(); predsOfHeads.addAll(getPredsOf(head)); unitToPreds.put(head, predsOfHeads); } } /* { predIt = getPredsOf(stmt).iterator(); while (predIt.hasNext()){ JPegStmt s = (JPegStmt)predIt.next(); if (unitToSuccs.containsKey(s)){ Iterator succIt = ((List) unitToSuccs.get(s)).iterator(); while(succIt.hasNext()){ //Object successor = succIt.next(); JPegStmt successor = (JPegStmt)succIt.next(); List predList = (List) unitToPreds.get(successor); if (predList != null) { try { predList.add(s); } catch(NullPointerException e) { System.out.println(s + "successor: " + successor); throw e; } } } } } }*/ } /*connect tails of inlinee with the succ of invokeStmt and * delete stmt from the */ Iterator tailsIt = inlinee.getTails().iterator(); { // System.out.println("tails: "+inlinee.getTails()); while (tailsIt.hasNext()) { Iterator succIt = getSuccsOf(stmt).iterator(); JPegStmt tail = (JPegStmt) tailsIt.next(); List succList = null; if (unitToSuccs.containsKey(tail)) { // System.out.println("error: unitToSucc containsKey: "+tail); succList = (List) getSuccsOf(tail); // System.out.println("succList: "+succList); } else { succList = new ArrayList(); } while (succIt.hasNext()) { JPegStmt succ = (JPegStmt) succIt.next(); succList.add(succ); // System.out.println("succ: "+succ); // remove stmt from the preds list of the succs of itself. List predListOfSucc = getPredsOf(succ); if (predListOfSucc == null) { System.err.println("Error: predListOfSucc is null!"); System.exit(1); } else { if (predListOfSucc.size() != 0) { int pos = predListOfSucc.indexOf(stmt); if (pos > 0 || pos == 0) { // System.out.println("remove stmt: "+stmt+" from the preds list"+predListOfSucc+" // of the succ"); predListOfSucc.remove(pos); } // System.out.println("remove(from PRED): "); } } unitToPreds.put(succ, predListOfSucc); } unitToSuccs.put(tail, succList); // System.out.println("put: "+tail); // System.out.println("succList: "+succList+ "into unitToSucc"); } } // add Nov 1 { tailsIt = inlinee.getTails().iterator(); while (tailsIt.hasNext()) { JPegStmt s = (JPegStmt) tailsIt.next(); if (unitToSuccs.containsKey(s)) { Iterator succIt = unitToSuccs.get(s).iterator(); while (succIt.hasNext()) { // Object successor = succIt.next(); JPegStmt successor = (JPegStmt) succIt.next(); List<JPegStmt> predList = unitToPreds.get(successor); if (predList != null && !predList.contains(s)) { try { predList.add(s); /* Tag tag = (Tag)successor.getTags().get(0); System.out.println("add "+s+" to predlist of "+tag+" "+successor); */ } catch (NullPointerException e) { System.out.println(s + "successor: " + successor); throw e; } } } } } } // end add Nov 1 // System.out.println("stmt: "+stmt); // remove stmt from allNodes and mainPegChain // System.out.println("mainPegChain contains stmt: "+mainPegChain.contains(stmt)); // testPegChain(); if (!allNodes.contains(stmt)) { System.err.println("fail to find begin node in allNodes!"); System.exit(1); } else { allNodes.remove(stmt); // System.out.println("remove from allNode: "+stmt); } if (!chain.contains(stmt)) { System.err.println("Error! Chain does not contains stmt (extending point)!"); System.exit(1); } else { if (!chain.remove(stmt)) { System.err.println("fail to remove invoke stmt in from Chain!"); System.exit(1); } } /* if (!mainPegChain.contains(stmt)){ boolean find = false; //System.out.println("main chain does not contain AFTER"); Set maps = startToThread.entrySet(); for(Iterator iter=maps.iterator(); iter.hasNext();){ Map.Entry entry = (Map.Entry)iter.next(); Object startNode = entry.getKey(); Iterator runIt = ((List)entry.getValue()).iterator(); while (runIt.hasNext()){ Chain chain=(Chain)runIt.next(); if (chain.contains(stmt)) { find = true; if (!chain.remove(stmt)){ System.err.println("fail to remove begin node in from mainPegChain!"); System.exit(1); } break; } } if (find == false){ System.err.println("fail to find stmt: "+stmt+" in chains!"); System.exit(1); } } //this.toString(); } else{ if (!mainPegChain.remove(stmt)) { System.err.println("fail to remove begin node in from mainPegChain!"); System.exit(1); } else{ // System.out.println("remove(from mainchain): "+stmt); } } */ // remove stmt from unitToSuccs and unitToPreds if (unitToSuccs.containsKey(stmt)) { unitToSuccs.remove(stmt); } if (unitToPreds.containsKey(stmt)) { unitToPreds.remove(stmt); } }
/* 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); } } } }
private void buildSuccessor(Chain pegChain) { // Add regular successors { HashMap unitToPeg = (HashMap) unitToPegMap.get(pegChain); Iterator pegIt = pegChain.iterator(); JPegStmt currentNode, nextNode; currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; // June 19 add for begin node if (currentNode != null) { // System.out.println("currentNode: "+currentNode); // if the unit is "begin" node nextNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; if (currentNode.getName().equals("begin")) { List<JPegStmt> successors = new ArrayList<JPegStmt>(); successors.add(nextNode); unitToSuccs.put(currentNode, successors); currentNode = nextNode; } // end June 19 add for begin node while (currentNode != null) { // System.out.println("currentNode: "+currentNode); /* If unitToSuccs contains currentNode, it is the point to inline methods, * we need not compute its successors again */ if (unitToSuccs.containsKey(currentNode) && !currentNode.getName().equals("wait")) { currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; continue; } List<JPegStmt> successors = new ArrayList<JPegStmt>(); Unit unit = currentNode.getUnit(); UnitGraph unitGraph = currentNode.getUnitGraph(); List unitSucc = unitGraph.getSuccsOf(unit); Iterator succIt = unitSucc.iterator(); while (succIt.hasNext()) { Unit un = (Unit) succIt.next(); // Don't build the edge from "monitor exit" to exception handler if (unit instanceof ExitMonitorStmt && exceHandlers.contains(un)) { // System.out.println("====find it! unit: "+unit+"\n un: "+un); continue; } else if (unitToPeg.containsKey(un)) { JPegStmt pp = (JPegStmt) (unitToPeg.get(un)); if (pp != null && !successors.contains(pp)) successors.add(pp); } } // end while if (currentNode.getName().equals("wait")) { while (!(currentNode.getName().equals("notified-entry"))) { currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; } unitToSuccs.put(currentNode, successors); // System.out.println("put key: "+currentNode+" into unitToSucc"); } else { unitToSuccs.put(currentNode, successors); } if (currentNode.getName().equals("start")) { // System.out.println("-----build succ for start----"); if (startToThread.containsKey(currentNode)) { List runMethodChainList = startToThread.get(currentNode); Iterator possibleMethodIt = runMethodChainList.iterator(); while (possibleMethodIt.hasNext()) { Chain subChain = (Chain) possibleMethodIt.next(); if (subChain != null) { // System.out.println("build succ for subChain"); // buildSuccessor(subGraph, subChain, addExceptionEdges); buildSuccessor(subChain); } else System.out.println("*********subgraph is null!!!"); } } } currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; } // while // June 19 add for begin node } // end June 19 add for begin node } }