Document the order of traversal for liveness and make it also more explicit in the method names.

Author: dibyendumajumdar

optvm/src/main/java/com/compilerprogramming/ezlang/compiler/BBHelper.java

@@ -11,17 +11,51 @@ public class BBHelper {
      */
     public static List<BasicBlock> findAllBlocks(BasicBlock root) {
         List<BasicBlock> nodes = new ArrayList<>();
-        postOrderWalk(root, (n) -> nodes.add(n), new HashSet<>());
+        postOrderWalkForwardCFG(root, (n) -> nodes.add(n), new HashSet<>());
         return nodes;
     }
 
-    static void postOrderWalk(BasicBlock n, Consumer<BasicBlock> consumer, HashSet<BasicBlock> visited) {
+    public static List<BasicBlock> findAllBlocksPostOrderForwardCFG(CompiledFunction function) {
+        List<BasicBlock> nodes = new ArrayList<>();
+        postOrderWalkForwardCFG(function.entry, (n) -> nodes.add(n), new HashSet<>());
+        return nodes;
+    }
+
+    public static List<BasicBlock> findAllBlocksReversePostOrderForwardCFG(CompiledFunction function) {
+        List<BasicBlock> nodes = new ArrayList<>();
+        postOrderWalkForwardCFG(function.entry, (n) -> nodes.add(0,n), new HashSet<>());
+        return nodes;
+    }
+
+    static void postOrderWalkForwardCFG(BasicBlock n, Consumer<BasicBlock> consumer, HashSet<BasicBlock> visited) {
         visited.add(n);
         /* For each successor node */
         for (BasicBlock s : n.successors) {
             if (!visited.contains(s))
-                postOrderWalk(s, consumer, visited);
+                postOrderWalkForwardCFG(s, consumer, visited);
         }
         consumer.accept(n);
     }
+
+    static void postOrderWalkReverseCFG(BasicBlock n, Consumer<BasicBlock> consumer, HashSet<BasicBlock> visited) {
+        visited.add(n);
+        /* For each successor node */
+        for (BasicBlock s : n.predecessors) {
+            if (!visited.contains(s))
+                postOrderWalkReverseCFG(s, consumer, visited);
+        }
+        consumer.accept(n);
+    }
+
+    public static List<BasicBlock> findAllBlocksPostOrderReverseCFG(CompiledFunction function) {
+        List<BasicBlock> nodes = new ArrayList<>();
+        postOrderWalkReverseCFG(function.exit, (n) -> nodes.add(n), new HashSet<>());
+        return nodes;
+    }
+
+    public static List<BasicBlock> findAllBlocksReversePostOrderReverseCFG(CompiledFunction function) {
+        List<BasicBlock> nodes = new ArrayList<>();
+        postOrderWalkReverseCFG(function.exit, (n) -> nodes.add(0,n), new HashSet<>());
+        return nodes;
+    }
 }

optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Liveness.java

@@ -22,15 +22,21 @@
  * Computing Liveness Sets for SSA-Form Programs
  * Florian Brandner, Benoit Boissinot, Alain Darte, Benoît Dupont de Dinechin, Fabrice Rastello
  *
- * The implementation is the unoptimized simple one.
+ * The implementation is the unoptimized simple data analysis form.
  * However, we have a modification to ensure that if we see a block
  * which loops to itself and has Phi cycles, then the Phi is only added to
  * PhiDefs.
  */
 public class Liveness {
 
     public Liveness(CompiledFunction function) {
-        List<BasicBlock> blocks = BBHelper.findAllBlocks(function.entry);
+        // EaC states that it is most efficient to do RPO on reverse CFG.
+        // The problem is that if there are infinite loops, we will not visit all basic blocks
+        // if we started at the exit block (this could be solved by adding artificial edges from infinite loop
+        // to exit block, but we do not do that yet).
+        // For a forward CFG traversal, we cannot do RPO as this is a backward dataflow
+        // problem, i.e. successors must be processed first.
+        List<BasicBlock> blocks = BBHelper.findAllBlocksPostOrderForwardCFG(function);
         RegisterPool regPool = function.registerPool;
         initBlocks(regPool, blocks);
         init(blocks);
@@ -110,7 +116,6 @@ private void computeLiveness(List<BasicBlock> blocks) {
         boolean changed = true;
         while (changed) {
             changed = false;
-            // TODO we should process in RPO order
             for (BasicBlock block : blocks) {
                 if (recomputeLiveOut(block))
                     changed = true;