public static Set<Statement> getUniquePredExceptions(Statement head) { Set<Statement> setHandlers = new HashSet<>(head.getNeighbours(StatEdge.TYPE_EXCEPTION, Statement.DIRECTION_FORWARD)); setHandlers.removeIf(statement -> statement.getPredecessorEdges(StatEdge.TYPE_EXCEPTION).size() > 1); return setHandlers; }
if (!stat.getPredecessorEdges(StatEdge.TYPE_EXCEPTION).isEmpty() && !handlers.contains(stat)) { return false;
public StrongConnectivityHelper(Statement stat) { components = new ArrayList<>(); setProcessed = new HashSet<>(); visitTree(stat.getFirst()); for (Statement st : stat.getStats()) { if (!setProcessed.contains(st) && st.getPredecessorEdges(Statement.STATEDGE_DIRECT_ALL).isEmpty()) { visitTree(st); } } // should not find any more nodes! FIXME: ?? for (Statement st : stat.getStats()) { if (!setProcessed.contains(st)) { visitTree(st); } } }
private static boolean isSequenceDisbandable(Statement block, Statement next) { Statement last = block.getStats().getLast(); List<StatEdge> lstSuccs = last.getAllSuccessorEdges(); if (!lstSuccs.isEmpty()) { if (lstSuccs.get(0).getDestination() != next) { return false; } } for (StatEdge edge : next.getPredecessorEdges(StatEdge.TYPE_BREAK)) { if (last != edge.getSource() && !last.containsStatementStrict(edge.getSource())) { return false; } } return true; }
public static Statement isHead2Block(Statement head) { if (head.getLastBasicType() != Statement.LASTBASICTYPE_GENERAL) { return null; } // at most one outgoing edge StatEdge edge = null; List<StatEdge> lstSuccs = head.getSuccessorEdges(STATEDGE_DIRECT_ALL); if (!lstSuccs.isEmpty()) { edge = lstSuccs.get(0); } if (edge != null && edge.getType() == StatEdge.TYPE_REGULAR) { Statement stat = edge.getDestination(); if (stat != head && stat.getPredecessorEdges(StatEdge.TYPE_REGULAR).size() == 1 && !stat.isMonitorEnter()) { if (stat.getLastBasicType() == Statement.LASTBASICTYPE_GENERAL) { if (DecHelper.checkStatementExceptions(Arrays.asList(head, stat))) { return new SequenceStatement(head, stat); } } } } return null; }
List<FastFixedSet<Integer>> lstPredSets = new ArrayList<>(); for (StatEdge prededge : node.getPredecessorEdges(StatEdge.TYPE_REGULAR)) { FastFixedSet<Integer> setPred = mapSets.get(prededge.getSource().id); if (setPred == null) { if (stat.getPredecessorEdges(Statement.STATEDGE_DIRECT_ALL).isEmpty() && !stat.getPredecessorEdges(StatEdge.TYPE_EXCEPTION).isEmpty()) { // exception handler setHandlers.add(stat.id); handlerfound = true;
for (StatEdge edge : stat.getPredecessorEdges(StatEdge.TYPE_REGULAR)) { if (edge.getSource() == first) { lst.add(mapEdgeIndex.get(edge));
List<StatEdge> lstSucc1 = elsestat.getSuccessorEdges(StatEdge.TYPE_REGULAR); if (ifstat.getPredecessorEdges(StatEdge.TYPE_REGULAR).size() > 1 || lstSucc.size() > 1) { post = ifstat; else if (elsestat.getPredecessorEdges(StatEdge.TYPE_REGULAR).size() > 1 || lstSucc1.size() > 1) { post = elsestat;
public static boolean splitIrreducibleNode(Statement statement) { Statement splitnode = getCandidateForSplitting(statement); if (splitnode == null) { return false; } StatEdge enteredge = splitnode.getPredecessorEdges(StatEdge.TYPE_REGULAR).iterator().next(); // copy the smallest statement Statement splitcopy = copyStatement(splitnode, null, new HashMap<>()); initCopiedStatement(splitcopy); // insert the copy splitcopy.setParent(statement); statement.getStats().addWithKey(splitcopy, splitcopy.id); // switch input edges for (StatEdge prededge : splitnode.getPredecessorEdges(Statement.STATEDGE_DIRECT_ALL)) { if (prededge.getSource() == enteredge.getSource() || prededge.closure == enteredge.getSource()) { splitnode.removePredecessor(prededge); prededge.getSource().changeEdgeNode(Statement.DIRECTION_FORWARD, prededge, splitcopy); splitcopy.addPredecessor(prededge); } } // connect successors for (StatEdge succ : splitnode.getSuccessorEdges(Statement.STATEDGE_DIRECT_ALL)) { splitcopy.addSuccessor(new StatEdge(succ.getType(), splitcopy, succ.getDestination(), succ.closure)); } return true; }
private static boolean isInlineable(SequenceStatement seq, int index) { Statement first = seq.getStats().get(index); Statement pre = seq.getStats().get(index - 1); if (pre.hasBasicSuccEdge()) { return false; } List<StatEdge> lst = first.getPredecessorEdges(StatEdge.TYPE_BREAK); if (lst.size() == 1) { StatEdge edge = lst.get(0); if (sameCatchRanges(edge)) { if (!edge.explicit) { for (int i = index; i < seq.getStats().size(); i++) { if (!noExitLabels(seq.getStats().get(i), seq)) { return false; } } } return true; } // FIXME: count labels properly } return false; }
public static void replaceContinueWithBreak(Statement stat) { if (stat.type == Statement.TYPE_DO) { List<StatEdge> lst = stat.getPredecessorEdges(StatEdge.TYPE_CONTINUE); for (StatEdge edge : lst) { if (edge.explicit) { Statement minclosure = getMinContinueClosure(edge); if (minclosure != edge.closure && !InlineSingleBlockHelper.isBreakEdgeLabeled(edge.getSource(), minclosure)) { edge.getSource().changeEdgeType(Statement.DIRECTION_FORWARD, edge, StatEdge.TYPE_BREAK); edge.labeled = false; minclosure.addLabeledEdge(edge); } } } } for (Statement st : stat.getStats()) { replaceContinueWithBreak(st); } }
public static void lowContinueLabels(Statement stat, HashSet<StatEdge> edges) { boolean ok = (stat.type != Statement.TYPE_DO); if (!ok) { DoStatement dostat = (DoStatement)stat; ok = dostat.getLooptype() == DoStatement.LOOP_DO || dostat.getLooptype() == DoStatement.LOOP_WHILE || (dostat.getLooptype() == DoStatement.LOOP_FOR && dostat.getIncExprent() == null); } if (ok) { edges.addAll(stat.getPredecessorEdges(StatEdge.TYPE_CONTINUE)); } if (ok && stat.type == Statement.TYPE_DO) { for (StatEdge edge : edges) { if (stat.containsStatementStrict(edge.getSource())) { edge.getDestination().removePredecessor(edge); edge.getSource().changeEdgeNode(Statement.DIRECTION_FORWARD, edge, stat); stat.addPredecessor(edge); stat.addLabeledEdge(edge); } } } for (Statement st : stat.getStats()) { if (st == stat.getFirst()) { lowContinueLabels(st, edges); } else { lowContinueLabels(st, new HashSet<>()); } } }
for (StatEdge edge : current.getPredecessorEdges(Statement.STATEDGE_DIRECT_ALL)) { current.removePredecessor(edge); edge.getSource().changeEdgeNode(Statement.DIRECTION_FORWARD, edge, nextDirect);
List<StatEdge> lstBreaks = st.getPredecessorEdges(StatEdge.TYPE_BREAK);
pre.removeSuccessor(pre.getAllSuccessorEdges().get(0)); // single regular edge StatEdge edge = first.getPredecessorEdges(StatEdge.TYPE_BREAK).get(0); Statement source = edge.getSource(); Statement parent = source.getParent();
for (StatEdge prededge : elseedge.getDestination().getPredecessorEdges(StatEdge.TYPE_BREAK)) { if (stat.containsStatementStrict(prededge.closure)) { stat.addLabeledEdge(prededge);
public static HashSet<Statement> getUniquePredExceptions(Statement head) { HashSet<Statement> setHandlers = new HashSet<>(head.getNeighbours(StatEdge.TYPE_EXCEPTION, Statement.DIRECTION_FORWARD)); Iterator<Statement> it = setHandlers.iterator(); while (it.hasNext()) { if (it.next().getPredecessorEdges(StatEdge.TYPE_EXCEPTION).size() > 1) { it.remove(); } } return setHandlers; }
public List<List<Statement>> findComponents(Statement stat) { components = new ArrayList<>(); setProcessed = new HashSet<>(); visitTree(stat.getFirst()); for (Statement st : stat.getStats()) { if (!setProcessed.contains(st) && st.getPredecessorEdges(Statement.STATEDGE_DIRECT_ALL).isEmpty()) { visitTree(st); } } // should not find any more nodes! FIXME: ?? for (Statement st : stat.getStats()) { if (!setProcessed.contains(st)) { visitTree(st); } } return components; }
private static boolean isSequenceDisbandable(Statement block, Statement next) { Statement last = block.getStats().getLast(); List<StatEdge> lstSuccs = last.getAllSuccessorEdges(); if (!lstSuccs.isEmpty()) { if (lstSuccs.get(0).getDestination() != next) { return false; } } for (StatEdge edge : next.getPredecessorEdges(StatEdge.TYPE_BREAK)) { if (last != edge.getSource() && !last.containsStatementStrict(edge.getSource())) { return false; } } return true; }
public static void replaceContinueWithBreak(Statement stat) { if (stat.type == Statement.TYPE_DO) { List<StatEdge> lst = stat.getPredecessorEdges(StatEdge.TYPE_CONTINUE); for (StatEdge edge : lst) { if (edge.explicit) { Statement minclosure = getMinContinueClosure(edge); if (minclosure != edge.closure && !InlineSingleBlockHelper.isBreakEdgeLabeled(edge.getSource(), minclosure)) { edge.getSource().changeEdgeType(Statement.DIRECTION_FORWARD, edge, StatEdge.TYPE_BREAK); edge.labeled = false; minclosure.addLabeledEdge(edge); } } } } for (Statement st : stat.getStats()) { replaceContinueWithBreak(st); } }