repair ssa

shared-test-resources/bugfixes/ForLoopSSA.java

@@ -0,0 +1,9 @@
+class ForLoopSSA {
+    public static void main(String[] args) {
+        String input = "";
+        for (int i = 0; i < args.length; i++) {
+            input = input + args[i];
+        }
+        System.out.println(input);
+    }
+}

shared-test-resources/bugfixes/TrapSSA.java

@@ -0,0 +1,11 @@
+import java.io.*;
+class TrapSSA {
+    public static void main(String[] args) throws IOException {
+        byte[] data;
+        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
+            output.write(args[0].getBytes("UTF-8"));
+            data = output.toByteArray();
+        }
+        System.out.println(new String(data, "UTF-8"));
+    }
+}

sootup.core/src/main/java/sootup/core/graph/BlockAnalysisDirection.java

@@ -0,0 +1,63 @@
+package sootup.core.graph;
+/*-
+ * #%L
+ * Soot - a J*va Optimization Framework
+ * %%
+ * Copyright (C) 2024 Junjie Shen
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ *
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nonnull;
+
+public enum BlockAnalysisDirection {
+  POSTORDERBACKWARD {
+    @Override
+    @Nonnull
+    List<BasicBlock<?>> getPredecessors(BasicBlock<?> block) {
+      // todo: Blocks in PostOrderBackward contain no exceptional blocks!!
+      return (List<BasicBlock<?>>) block.getSuccessors();
+    }
+
+    @Nonnull
+    @Override
+    List<BasicBlock<?>> getSortedBlocks(StmtGraph<?> blockGraph) {
+      return Collections.unmodifiableList(PostOrderBlockTraversal.getBlocksSorted(blockGraph));
+    }
+  },
+  REVERSEPOSTORDERFORWARD {
+    @Override
+    @Nonnull
+    List<BasicBlock<?>> getPredecessors(BasicBlock<?> block) {
+      return (List<BasicBlock<?>>) block.getPredecessors();
+    }
+
+    @Nonnull
+    @Override
+    List<BasicBlock<?>> getSortedBlocks(StmtGraph<?> blockGraph) {
+      return Collections.unmodifiableList(
+          ReversePostOrderBlockTraversal.getBlocksSorted(blockGraph));
+    }
+  };
+
+  @Nonnull
+  abstract List<BasicBlock<?>> getPredecessors(BasicBlock<?> block);
+
+  @Nonnull
+  abstract List<BasicBlock<?>> getSortedBlocks(StmtGraph<?> blockGraph);
+}

sootup.core/src/main/java/sootup/core/graph/BlockIterator.java

@@ -0,0 +1,25 @@
+package sootup.core.graph;
+/*-
+ * #%L
+ * Soot - a J*va Optimization Framework
+ * %%
+ * Copyright (C) 2024 Junjie Shen
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ *
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+import java.util.Iterator;
+
+public interface BlockIterator extends Iterator<BasicBlock<?>> {}

sootup.core/src/main/java/sootup/core/graph/BlockTraversal.java

@@ -0,0 +1,23 @@
+package sootup.core.graph;
+/*-
+ * #%L
+ * Soot - a J*va Optimization Framework
+ * %%
+ * Copyright (C) 2024 Junjie Shen
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ *
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+public interface BlockTraversal {}

sootup.core/src/main/java/sootup/core/graph/DominanceFinder.java

@@ -24,78 +24,55 @@
 
 import java.util.*;
 import javax.annotation.Nonnull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author Zun Wang
  * @see <a
  *     href="https://www.researchgate.net/publication/2569680_A_Simple_Fast_Dominance_Algorithm">
  *     https://www.researchgate.net/publication/2569680_A_Simple_Fast_Dominance_Algorithm </a>
  */
 public class DominanceFinder {
 
+  private static Logger LOGGER = LoggerFactory.getLogger(DominanceFinder.class);
+
   private List<BasicBlock<?>> blocks;
   private Map<BasicBlock<?>, Integer> blockToIdx = new HashMap<>();
   private int[] doms;
   private ArrayList<Integer>[] domFrontiers;
+  private BlockAnalysisDirection direction;
 
-  protected AnalysisDirection direction;
-
-  public enum AnalysisDirection {
-    BACKWARD {
-      @Override
-      @Nonnull
-      List<? extends BasicBlock<?>> getPredecessors(BasicBlock<?> block) {
-        return block.getSuccessors();
-      }
-
-      @Nonnull
-      @Override
-      List<BasicBlock<?>> getSortedBlocks(StmtGraph<?> blockGraph) {
-        return Collections.unmodifiableList(new BackwardsStmtGraph(blockGraph).getBlocksSorted());
-      }
-    },
-    FORWARD {
-      @Override
-      @Nonnull
-      List<? extends BasicBlock<?>> getPredecessors(BasicBlock<?> block) {
-        return block.getPredecessors();
-      }
-
-      @Nonnull
-      @Override
-      List<BasicBlock<?>> getSortedBlocks(StmtGraph<?> blockGraph) {
-        return Collections.unmodifiableList(blockGraph.getBlocksSorted());
-      }
-    };
-
-    @Nonnull
-    abstract List<? extends BasicBlock<?>> getPredecessors(BasicBlock<?> block);
-
-    @Nonnull
-    abstract List<BasicBlock<?>> getSortedBlocks(StmtGraph<?> blockGraph);
+  public DominanceFinder(StmtGraph<?> blockGraph) {
+    // normal DominanceFinder should be in reverse post order
+    this(blockGraph, BlockAnalysisDirection.REVERSEPOSTORDERFORWARD);
   }
 
-  public DominanceFinder(@Nonnull StmtGraph<?> blockGraph) {
-    this(blockGraph, AnalysisDirection.FORWARD);
-  }
+  protected DominanceFinder(@Nonnull StmtGraph<?> blockGraph, BlockAnalysisDirection direction) {
 
-  protected DominanceFinder(@Nonnull StmtGraph<?> blockGraph, AnalysisDirection direction) {
+    // define the blocks' order
     this.direction = direction;
-
-    // we're locked into providing a List<BasicBlock<?>>, not a List<? extends BasicBlock<?>>, so
-    // we'll use the block iterator directly (which provides this type) rather than
-    // #getBlocksSorted.
     blocks = direction.getSortedBlocks(blockGraph);
-
-    // assign each block a integer id. The starting block must have id 0; rely on
-    // getBlocksSorted to have put the starting block first.
     for (int i = 0; i < blocks.size(); i++) {
       BasicBlock<?> block = blocks.get(i);
       blockToIdx.put(block, i);
     }
-    final BasicBlock<?> startingStmtBlock = blocks.get(0);
 
     // initialize doms
+    final BasicBlock<?> startBlock;
+    if (direction == BlockAnalysisDirection.REVERSEPOSTORDERFORWARD
+        || direction == BlockAnalysisDirection.POSTORDERBACKWARD) {
+      startBlock = blocks.get(0);
+      if (direction == BlockAnalysisDirection.POSTORDERBACKWARD) {
+        // todo: Postdominantor (POSTORDERBACKWARD) doesn't work for with multiple tail-blocks.
+        List<BasicBlock<?>> tails = blockGraph.getTailStmtBlocks();
+        if (tails.size() > 1) {
+          LOGGER.warn(
+              "BlockGraph has multiple tail-blocks, the Post-Dominators Computation could be incorrect!");
+        }
+      }
+    } else {
+      throw new RuntimeException("Invalid BlockAnalysisDirection!");
+    }
     doms = new int[blocks.size()];
     Arrays.fill(doms, -1);
     doms[0] = 0;
@@ -105,12 +82,11 @@ protected DominanceFinder(@Nonnull StmtGraph<?> blockGraph, AnalysisDirection di
     while (isChanged) {
       isChanged = false;
       for (BasicBlock<?> block : blocks) {
-        if (block.equals(startingStmtBlock)) {
+        if (block.equals(startBlock)) {
           continue;
         }
         int blockIdx = blockToIdx.get(block);
         List<BasicBlock<?>> preds = new ArrayList<>(direction.getPredecessors(block));
-        // ms: should not be necessary preds.addAll(block.getExceptionalPredecessors());
         int newIdom = getFirstDefinedBlockPredIdx(preds);
         if (!preds.isEmpty() && newIdom != -1) {
           BasicBlock<?> processed = blocks.get(newIdom);
@@ -131,19 +107,16 @@ protected DominanceFinder(@Nonnull StmtGraph<?> blockGraph, AnalysisDirection di
       }
     }
 
-    // startBlockId should not have immediate dominator, actually.
-    doms[0] = -1;
-
     // initialize domFrontiers
-    domFrontiers = new ArrayList[blockGraph.getBlocks().size()];
+    domFrontiers = new ArrayList[blocks.size()];
     for (int i = 0; i < domFrontiers.length; i++) {
       domFrontiers[i] = new ArrayList<>();
     }
 
+    doms[0] = -1;
     // calculate dominance frontiers for each block
     for (BasicBlock<?> block : blocks) {
       List<BasicBlock<?>> preds = new ArrayList<>(direction.getPredecessors(block));
-      // ms: should not be necessary  preds.addAll(block.getExceptionalPredecessors());
       if (preds.size() > 1) {
         int blockId = blockToIdx.get(block);
         for (BasicBlock<?> pred : preds) {
@@ -155,6 +128,14 @@ protected DominanceFinder(@Nonnull StmtGraph<?> blockGraph, AnalysisDirection di
         }
       }
     }
+
+    if (direction == BlockAnalysisDirection.POSTORDERBACKWARD) {
+      for (int i = 0; i < domFrontiers.length; i++) {
+        if (domFrontiers[i].contains(i)) {
+          domFrontiers[i].remove(new Integer(i));
+        }
+      }
+    }
   }
 
   public void replaceBlock(@Nonnull BasicBlock<?> newBlock, BasicBlock<?> oldBlock) {

sootup.core/src/main/java/sootup/core/graph/DominanceTree.java

@@ -47,7 +47,7 @@ public DominanceTree(@Nonnull DominanceFinder dominanceFinder) {
     }
 
     for (int i = 0; i < treeSize; i++) {
-      if (iDoms[i] != i) {
+      if (iDoms[i] != -1 && iDoms[i] != i) {
         parents[i] = iDoms[i];
         children[iDoms[i]].add(i);
       }

sootup.core/src/main/java/sootup/core/graph/ForwardingStmtGraph.java

@@ -50,6 +50,11 @@ public BasicBlock<?> getStartingStmtBlock() {
     return backingGraph.getStartingStmtBlock();
   }
 
+  @Override
+  public List<BasicBlock<?>> getTailStmtBlocks() {
+    return backingGraph.getTailStmtBlocks();
+  }
+
   @Override
   public BasicBlock<?> getBlockOf(@Nonnull Stmt stmt) {
     return backingGraph.getBlockOf(stmt);

sootup.core/src/main/java/sootup/core/graph/ImmutableBlockStmtGraph.java

@@ -61,6 +61,11 @@ public BasicBlock<?> getStartingStmtBlock() {
     throw new UnsupportedOperationException("Not implemented yet!");
   }
 
+  @Override
+  public List<BasicBlock<?>> getTailStmtBlocks() {
+    throw new UnsupportedOperationException("Not implemented yet!");
+  }
+
   @Override
   public BasicBlock<ImmutableBasicBlock> getBlockOf(@Nonnull Stmt stmt) {
     throw new UnsupportedOperationException("Not implemented yet!");

sootup.core/src/main/java/sootup/core/graph/MutableBlockStmtGraph.java

@@ -25,6 +25,7 @@
 import com.google.common.collect.ComparisonChain;
 import com.google.common.collect.Lists;
 import java.util.*;
+import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.apache.commons.lang3.tuple.MutablePair;
@@ -789,7 +790,8 @@ protected boolean isMergeable(
     }
     // if we are here the datastructure should have managed that the next if is true..
     final List<MutableBasicBlock> sBlockPredecessors = followingBlock.getPredecessors();
-    if (sBlockPredecessors.size() != 1 || sBlockPredecessors.get(0) != firstBlock) {
+    if (sBlockPredecessors.size() > 1
+        || (sBlockPredecessors.size() == 1 && sBlockPredecessors.get(0) != firstBlock)) {
       return false;
     }
     // check if the same traps are applied to both blocks
@@ -1072,12 +1074,12 @@ public void validateBlocks() {
    *                   simplifies the handling of BranchingStmts)
    * @param stmts
    */
-  public void insertBefore(
+  public BasicBlock<?> insertBefore(
       @Nonnull Stmt beforeStmt,
       @Nonnull List<FallsThroughStmt> stmts,
       @Nonnull Map<ClassType, Stmt> exceptionMap) {
     if (stmts.isEmpty()) {
-      return;
+      return stmtToBlock.get(beforeStmt).getRight();
     }
     final Pair<Integer, MutableBasicBlock> beforeStmtBlockPair = stmtToBlock.get(beforeStmt);
     if (beforeStmtBlockPair == null) {
@@ -1100,7 +1102,8 @@ public void insertBefore(
         // all inserted Stmts are FallingThrough: so successorIdx = 0
         predecessorBlock.linkSuccessor(0, block);
       }
-
+      checkAndResetStartingStmt(beforeStmt, stmts);
+      return predecessorBlock;
     } else {
       // TODO: check conditions before splitting if split will be necessary instead of
       // split-and-merge
@@ -1124,8 +1127,12 @@ public void insertBefore(
         }
         blocks.add(successorBlock);
       }
+      checkAndResetStartingStmt(beforeStmt, stmts);
+      return block;
     }
+  }
 
+  private void checkAndResetStartingStmt(Stmt beforeStmt, List<FallsThroughStmt> stmts) {
     if (beforeStmt == getStartingStmt()) {
       setStartingStmt(stmts.get(0));
     }
@@ -1384,6 +1391,11 @@ public BasicBlock<?> getStartingStmtBlock() {
     return getBlockOf(startingStmt);
   }
 
+  @Override
+  public List<BasicBlock<?>> getTailStmtBlocks() {
+    return getTails().stream().map(stmt -> getBlockOf(stmt)).collect(Collectors.toList());
+  }
+
   @Override
   @Nullable
   public BasicBlock<?> getBlockOf(@Nonnull Stmt stmt) {