public static void clearStatements(RootStatement root) { LinkedList<Statement> stack = new LinkedList<>(); stack.add(root); while (!stack.isEmpty()) { Statement stat = stack.removeFirst(); stat.clearTempInformation(); stack.addAll(stat.getStats()); } } }
private void buildExceptionRanges() { for (Statement stat : statement.getStats()) { List<Statement> lstPreds = stat.getNeighbours(StatEdge.TYPE_EXCEPTION, Statement.DIRECTION_BACKWARD); if (!lstPreds.isEmpty()) { Set<Integer> set = new HashSet<>(); for (Statement st : lstPreds) { set.add(st.id); } mapExceptionRanges.put(stat.id, set); } } mapExceptionDoms = buildExceptionDoms(statement.getFirst().id); }
public static void removeSynchronizedHandler(Statement stat) { for (Statement st : stat.getStats()) { removeSynchronizedHandler(st); } if (stat.type == Statement.TYPE_SYNCRONIZED) { ((SynchronizedStatement)stat).removeExc(); } }
private static void resetAllEdges(Statement stat) { for (Statement st : stat.getStats()) { resetAllEdges(st); } for (StatEdge edge : stat.getAllSuccessorEdges()) { edge.explicit = true; edge.labeled = true; } }
private static void initStatementExprents(Statement stat) { stat.initExprents(); for (Statement st : stat.getStats()) { initStatementExprents(st); } }
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 int getStatementSize(Statement statement) { int res; if (statement.type == Statement.TYPE_BASICBLOCK) { res = ((BasicBlockStatement)statement).getBlock().getSeq().length(); } else { res = statement.getStats().stream().mapToInt(IrreducibleCFGDeobfuscator::getStatementSize).sum(); } return res; }
private static Statement getLastDirectData(Statement stat) { if (stat.getExprents() != null) { return stat; } if (stat.type == Statement.TYPE_SEQUENCE) { for (int i = stat.getStats().size() - 1; i >= 0; i--) { Statement tmp = getLastDirectData(stat.getStats().get(i)); if (tmp == null || !tmp.getExprents().isEmpty()) { return tmp; } } } return null; } }
private void calcDefaultReachableSets() { int edgetype = StatEdge.TYPE_REGULAR | StatEdge.TYPE_EXCEPTION; calcReachabilitySuppPoints(edgetype); for (Statement stat : statement.getStats()) { mapExtPostdominators.put(stat.id, factory.spawnEmptySet()); } iterateReachability((node, mapSets) -> { Integer nodeid = node.id; FastFixedSet<Integer> setReachability = mapSets.get(nodeid); for (Integer id : setReachability) { mapExtPostdominators.get(id).add(nodeid); } return false; }, edgetype); }
private static boolean enhanceLoopsRec(Statement stat) { boolean res = false; for (Statement st : stat.getStats()) { if (st.getExprents() == null) { res |= enhanceLoopsRec(st); } } if (stat.type == Statement.TYPE_DO) { res |= enhanceLoop((DoStatement)stat); } return res; }
private static void removeNonImmediateEdges(Statement stat) { for (Statement st : stat.getStats()) { removeNonImmediateEdges(st); } if (!stat.hasBasicSuccEdge()) { for (StatEdge edge : stat.getSuccessorEdges(StatEdge.TYPE_CONTINUE | StatEdge.TYPE_BREAK)) { stat.removeSuccessor(edge); } } }
public static void lowClosures(Statement stat) { for (StatEdge edge : new ArrayList<>(stat.getLabelEdges())) { if (edge.getType() == StatEdge.TYPE_BREAK) { // FIXME: ? for (Statement st : stat.getStats()) { if (st.containsStatementStrict(edge.getSource())) { if (MergeHelper.isDirectPath(st, edge.getDestination())) { st.addLabeledEdge(edge); } } } } } for (Statement st : stat.getStats()) { lowClosures(st); } }
private static void initCopiedStatement(Statement statement) { statement.initSimpleCopy(); statement.setCopied(true); for (Statement st : statement.getStats()) { st.setParent(statement); initCopiedStatement(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; }
private static boolean inlineSingleBlocksRec(Statement stat) { boolean res = false; for (Statement st : stat.getStats()) { res |= inlineSingleBlocksRec(st); } if (stat.type == Statement.TYPE_SEQUENCE) { SequenceStatement seq = (SequenceStatement)stat; for (int i = 1; i < seq.getStats().size(); i++) { if (isInlineable(seq, i)) { inlineBlock(seq, i); return true; } } } return res; }
private static boolean isExternStatement(DoStatement loop, Statement block, Statement stat) { for (StatEdge edge : stat.getAllSuccessorEdges()) { if (loop.containsStatement(edge.getDestination()) && !block.containsStatement(edge.getDestination())) { return false; } } for (Statement st : stat.getStats()) { if (!isExternStatement(loop, block, st)) { return false; } } return true; }
private static boolean noExitLabels(Statement block, Statement sequence) { for (StatEdge edge : block.getAllSuccessorEdges()) { if (edge.getType() != StatEdge.TYPE_REGULAR && edge.getDestination().type != Statement.TYPE_DUMMYEXIT) { if (!sequence.containsStatementStrict(edge.getDestination())) { return false; } } } for (Statement st : block.getStats()) { if (!noExitLabels(st, sequence)) { 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); } }
private static void removeLastEmptyStatement(DoStatement dostat, Statement stat) { if (stat == dostat.getFirst()) { BasicBlockStatement bstat = new BasicBlockStatement(new BasicBlock( DecompilerContext.getCounterContainer().getCounterAndIncrement(CounterContainer.STATEMENT_COUNTER))); bstat.setExprents(new ArrayList<>()); dostat.replaceStatement(stat, bstat); } else { for (StatEdge edge : stat.getAllPredecessorEdges()) { edge.getSource().changeEdgeType(Statement.DIRECTION_FORWARD, edge, StatEdge.TYPE_CONTINUE); stat.removePredecessor(edge); edge.getSource().changeEdgeNode(Statement.DIRECTION_FORWARD, edge, dostat); dostat.addPredecessor(edge); dostat.addLabeledEdge(edge); } // parent is a sequence statement stat.getParent().getStats().removeWithKey(stat.id); } }