| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.jetbrains.java.decompiler.modules.decompiler; |
| |
| import org.jetbrains.java.decompiler.code.cfg.BasicBlock; |
| import org.jetbrains.java.decompiler.main.DecompilerContext; |
| import org.jetbrains.java.decompiler.main.collectors.CounterContainer; |
| import org.jetbrains.java.decompiler.modules.decompiler.exps.ExitExprent; |
| import org.jetbrains.java.decompiler.modules.decompiler.exps.Exprent; |
| import org.jetbrains.java.decompiler.modules.decompiler.stats.*; |
| import org.jetbrains.java.decompiler.struct.gen.MethodDescriptor; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Set; |
| |
| public class ExitHelper { |
| |
| |
| public static boolean condenseExits(RootStatement root) { |
| |
| int changed = integrateExits(root); |
| |
| if (changed > 0) { |
| |
| cleanUpUnreachableBlocks(root); |
| |
| SequenceHelper.condenseSequences(root); |
| } |
| |
| return (changed > 0); |
| } |
| |
| |
| private static void cleanUpUnreachableBlocks(Statement stat) { |
| |
| boolean found; |
| do { |
| |
| found = false; |
| |
| for (int i = 0; i < stat.getStats().size(); i++) { |
| |
| Statement st = stat.getStats().get(i); |
| |
| cleanUpUnreachableBlocks(st); |
| |
| if (st.type == Statement.TYPE_SEQUENCE && st.getStats().size() > 1) { |
| |
| Statement last = st.getStats().getLast(); |
| Statement secondlast = st.getStats().get(st.getStats().size() - 2); |
| |
| if (last.getExprents() == null || !last.getExprents().isEmpty()) { |
| if (!secondlast.hasBasicSuccEdge()) { |
| |
| Set<Statement> set = last.getNeighboursSet(Statement.STATEDGE_DIRECT_ALL, Statement.DIRECTION_BACKWARD); |
| set.remove(secondlast); |
| |
| if (set.isEmpty()) { |
| last.setExprents(new ArrayList<Exprent>()); |
| found = true; |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| while (found); |
| } |
| |
| |
| private static int integrateExits(Statement stat) { |
| |
| int ret = 0; |
| Statement dest = null; |
| |
| if (stat.getExprents() == null) { |
| |
| while (true) { |
| |
| int changed = 0; |
| |
| for (Statement st : stat.getStats()) { |
| changed = integrateExits(st); |
| if (changed > 0) { |
| ret = 1; |
| break; |
| } |
| } |
| |
| if (changed == 0) { |
| break; |
| } |
| } |
| |
| |
| switch (stat.type) { |
| case Statement.TYPE_IF: |
| IfStatement ifst = (IfStatement)stat; |
| if (ifst.getIfstat() == null) { |
| StatEdge ifedge = ifst.getIfEdge(); |
| dest = isExitEdge(ifedge); |
| if (dest != null) { |
| BasicBlockStatement bstat = new BasicBlockStatement(new BasicBlock( |
| DecompilerContext.getCounterContainer().getCounterAndIncrement(CounterContainer.STATEMENT_COUNTER))); |
| bstat.setExprents(DecHelper.copyExprentList(dest.getExprents())); |
| |
| ifst.getFirst().removeSuccessor(ifedge); |
| StatEdge newedge = new StatEdge(StatEdge.TYPE_REGULAR, ifst.getFirst(), bstat); |
| ifst.getFirst().addSuccessor(newedge); |
| ifst.setIfEdge(newedge); |
| ifst.setIfstat(bstat); |
| ifst.getStats().addWithKey(bstat, bstat.id); |
| bstat.setParent(ifst); |
| |
| StatEdge oldexitedge = dest.getAllSuccessorEdges().get(0); |
| StatEdge newexitedge = new StatEdge(StatEdge.TYPE_BREAK, bstat, oldexitedge.getDestination()); |
| bstat.addSuccessor(newexitedge); |
| oldexitedge.closure.addLabeledEdge(newexitedge); |
| ret = 1; |
| } |
| } |
| } |
| } |
| |
| |
| if (stat.getAllSuccessorEdges().size() == 1 && |
| stat.getAllSuccessorEdges().get(0).getType() == StatEdge.TYPE_BREAK && |
| stat.getLabelEdges().isEmpty()) { |
| Statement parent = stat.getParent(); |
| if (stat != parent.getFirst() || (parent.type != Statement.TYPE_IF && |
| parent.type != Statement.TYPE_SWITCH)) { |
| |
| StatEdge destedge = stat.getAllSuccessorEdges().get(0); |
| dest = isExitEdge(destedge); |
| if (dest != null) { |
| stat.removeSuccessor(destedge); |
| |
| BasicBlockStatement bstat = new BasicBlockStatement(new BasicBlock( |
| DecompilerContext.getCounterContainer().getCounterAndIncrement(CounterContainer.STATEMENT_COUNTER))); |
| bstat.setExprents(DecHelper.copyExprentList(dest.getExprents())); |
| |
| StatEdge oldexitedge = dest.getAllSuccessorEdges().get(0); |
| StatEdge newexitedge = new StatEdge(StatEdge.TYPE_BREAK, bstat, oldexitedge.getDestination()); |
| bstat.addSuccessor(newexitedge); |
| oldexitedge.closure.addLabeledEdge(newexitedge); |
| |
| SequenceStatement block = new SequenceStatement(Arrays.asList(stat, bstat)); |
| block.setAllParent(); |
| |
| parent.replaceStatement(stat, block); |
| // LabelHelper.lowContinueLabels not applicable because of forward continue edges |
| // LabelHelper.lowContinueLabels(block, new HashSet<StatEdge>()); |
| // do it by hand |
| for (StatEdge prededge : block.getPredecessorEdges(StatEdge.TYPE_CONTINUE)) { |
| |
| block.removePredecessor(prededge); |
| prededge.getSource().changeEdgeNode(Statement.DIRECTION_FORWARD, prededge, stat); |
| stat.addPredecessor(prededge); |
| |
| stat.addLabeledEdge(prededge); |
| } |
| |
| |
| stat.addSuccessor(new StatEdge(StatEdge.TYPE_REGULAR, stat, bstat)); |
| |
| for (StatEdge edge : dest.getAllPredecessorEdges()) { |
| if (!edge.explicit && stat.containsStatementStrict(edge.getSource()) && |
| MergeHelper.isDirectPath(edge.getSource().getParent(), bstat)) { |
| |
| dest.removePredecessor(edge); |
| edge.getSource().changeEdgeNode(Statement.DIRECTION_FORWARD, edge, bstat); |
| bstat.addPredecessor(edge); |
| |
| if (!stat.containsStatementStrict(edge.closure)) { |
| stat.addLabeledEdge(edge); |
| } |
| } |
| } |
| |
| ret = 2; |
| } |
| } |
| } |
| |
| return ret; |
| } |
| |
| private static Statement isExitEdge(StatEdge edge) { |
| |
| Statement dest = edge.getDestination(); |
| |
| if (edge.getType() == StatEdge.TYPE_BREAK && dest.type == Statement.TYPE_BASICBLOCK |
| && edge.explicit && (edge.labeled || isOnlyEdge(edge))) { |
| List<Exprent> data = dest.getExprents(); |
| |
| if (data != null && data.size() == 1) { |
| if (data.get(0).type == Exprent.EXPRENT_EXIT) { |
| return dest; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private static boolean isOnlyEdge(StatEdge edge) { |
| |
| Statement stat = edge.getDestination(); |
| |
| for (StatEdge ed : stat.getAllPredecessorEdges()) { |
| if (ed != edge) { |
| if (ed.getType() == StatEdge.TYPE_REGULAR) { |
| Statement source = ed.getSource(); |
| |
| if (source.type == Statement.TYPE_BASICBLOCK || (source.type == Statement.TYPE_IF && |
| ((IfStatement)source).iftype == IfStatement.IFTYPE_IF) || |
| (source.type == Statement.TYPE_DO && ((DoStatement)source).getLooptype() != DoStatement.LOOP_DO)) { |
| return false; |
| } |
| } |
| else { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| public static boolean removeRedundantReturns(RootStatement root) { |
| |
| boolean res = false; |
| |
| for (StatEdge edge : root.getDummyExit().getAllPredecessorEdges()) { |
| if (!edge.explicit) { |
| Statement source = edge.getSource(); |
| List<Exprent> lstExpr = source.getExprents(); |
| if (lstExpr != null && !lstExpr.isEmpty()) { |
| Exprent expr = lstExpr.get(lstExpr.size() - 1); |
| if (expr.type == Exprent.EXPRENT_EXIT) { |
| ExitExprent ex = (ExitExprent)expr; |
| if (ex.getExittype() == ExitExprent.EXIT_RETURN && ex.getValue() == null) { |
| // remove redundant return |
| lstExpr.remove(lstExpr.size() - 1); |
| res = true; |
| } |
| } |
| } |
| } |
| } |
| |
| return res; |
| } |
| |
| public static boolean handleReturnFromInitializer(RootStatement root) { |
| |
| boolean res = false; |
| |
| Statement exit = root.getDummyExit(); |
| Statement top = root.getFirst(); |
| Statement newret = null; |
| |
| boolean sharedcreated = false; |
| |
| for (StatEdge edge : exit.getAllPredecessorEdges()) { |
| if (edge.explicit) { |
| |
| if (!sharedcreated) { |
| newret = addSharedInitializerReturn(root); |
| sharedcreated = true; |
| } |
| |
| Statement source = edge.getSource(); |
| List<Exprent> lstExpr = source.getExprents(); |
| if (lstExpr != null && !lstExpr.isEmpty()) { |
| Exprent expr = lstExpr.get(lstExpr.size() - 1); |
| if (expr.type == Exprent.EXPRENT_EXIT) { |
| ExitExprent ex = (ExitExprent)expr; |
| if (ex.getExittype() == ExitExprent.EXIT_RETURN && ex.getValue() == null) { |
| lstExpr.remove(lstExpr.size() - 1); |
| |
| source.removeSuccessor(edge); |
| source.addSuccessor(new StatEdge(StatEdge.TYPE_BREAK, source, newret, top)); |
| |
| res = true; |
| } |
| } |
| } |
| } |
| } |
| |
| return res; |
| } |
| |
| private static Statement addSharedInitializerReturn(RootStatement root) { |
| |
| Statement exit = root.getDummyExit(); |
| Statement top = root.getFirst(); |
| |
| // build a new statement with the single instruction 'return' |
| BasicBlockStatement bstat = new BasicBlockStatement(new BasicBlock( |
| DecompilerContext.getCounterContainer().getCounterAndIncrement(CounterContainer.STATEMENT_COUNTER))); |
| |
| ExitExprent retexpr = new ExitExprent(ExitExprent.EXIT_RETURN, null, |
| ((MethodDescriptor)DecompilerContext |
| .getProperty(DecompilerContext.CURRENT_METHOD_DESCRIPTOR)).ret); |
| // a changeable list needed |
| bstat.setExprents(new ArrayList<Exprent>(Arrays.asList(new Exprent[]{retexpr}))); |
| |
| // build sequence to replace the former top statement |
| SequenceStatement seq = new SequenceStatement(Arrays.asList(top, bstat)); |
| top.setParent(seq); |
| bstat.setParent(seq); |
| seq.setParent(root); |
| |
| root.getStats().removeWithKey(top.id); |
| root.getStats().addWithKeyAndIndex(0, seq, seq.id); |
| root.setFirst(seq); |
| |
| for (StatEdge succedge : top.getAllSuccessorEdges()) { |
| top.removeSuccessor(succedge); |
| } |
| |
| top.addSuccessor(new StatEdge(StatEdge.TYPE_REGULAR, top, bstat)); |
| bstat.addSuccessor(new StatEdge(StatEdge.TYPE_BREAK, bstat, exit, seq)); |
| |
| return bstat; |
| } |
| } |
