Implement second method of building DOM Frontiers based on Appel's Modern Compiler Implementation in C.

Set the IDOM of root node to null rather than itself, post Dom Tree calculation.
Add option to dump out the DOM Tree Pre-SSA

Author: dibyendumajumdar

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

@@ -213,6 +213,14 @@ public StringBuilder toDot(StringBuilder sb, boolean verbose) {
         sb.append("</TABLE>");
         return sb;
     }
+    public StringBuilder listDomFrontiers(StringBuilder sb) {
+        sb.append("L").append(this.bid).append(":");
+        for (BasicBlock bb: dominationFrontier) {
+            sb.append(" L").append(bb.bid);
+        }
+        sb.append("\n");
+        return sb;
+    }
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

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

@@ -1,10 +1,8 @@
 package com.compilerprogramming.ezlang.compiler;
 
-import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
-import java.util.function.Consumer;
 
 /**
  * The dominator tree construction algorithm is based on figure 9.24,
@@ -34,14 +32,15 @@ public DominatorTree(BasicBlock entry) {
         populateTree();
         setDepth();
         calculateDominanceFrontiers();
+        //calculateDominanceFrontiersMethod2();
     }
 
     private void calculateDominatorTree() {
         resetDomInfo();
         annotateBlocksWithRPO();
         sortBlocksByRPO();
 
-        // Set IDom entry for root to itself
+        // Set IDom entry for root to itself (see note below)
         entry.idom = entry;
         boolean changed = true;
         while (changed) {
@@ -68,6 +67,11 @@ private void calculateDominatorTree() {
                 }
             }
         }
+        // There is a contradiction between what is described in the book
+        // and the algo - as the book says the IDOM for root is undefined
+        // But we set this to itself when calculating. So after calculations
+        // are done, set this to null. This is technically more correct IMO.
+        entry.idom = null;
     }
 
     private void resetDomInfo() {
@@ -146,7 +150,7 @@ private BasicBlock findFirstPredecessorWithIdom(BasicBlock n) {
     private void populateTree() {
         for (BasicBlock block : blocks) {
             BasicBlock idom = block.idom;
-            if (idom == block) // root
+            if (idom == null) // root
                 continue;
             // add edge from idom to n
             idom.dominatedChildren.add(block);
@@ -166,12 +170,13 @@ private void setDepth() {
      */
     private void setDepth_(BasicBlock block) {
         BasicBlock idom = block.idom;
-        if (idom != block) {
+        if (idom != null) {
             assert idom.domDepth > 0;
             block.domDepth = idom.domDepth + 1;
-        } else {
-            assert idom.domDepth == 1;
-            assert idom.domDepth == block.domDepth;
+        }
+        else {
+            // root (entry) block's idom is null
+            assert block.domDepth == 1;
         }
         for (BasicBlock child : block.dominatedChildren)
             setDepth_(child);
@@ -189,6 +194,8 @@ private void calculateDominanceFrontiers() {
         //          while runner != doms[b]
         //              add b to runner’s dominance frontier set
         //              runner = doms[runner]
+        for (BasicBlock b: blocks)
+            b.dominationFrontier.clear();   // empty set
         for (BasicBlock b : blocks) {
             if (b.predecessors.size() >= 2) {
                 for (BasicBlock p : b.predecessors) {
@@ -204,6 +211,37 @@ private void calculateDominanceFrontiers() {
         }
     }
 
+    // We have an alternative approach to calculating DOM Frontiers to
+    // allow us to validate above
+    private void calculateDominanceFrontiersMethod2()
+    {
+        for (BasicBlock b: blocks)
+            b.dominationFrontier.clear();   // empty set
+        computeDF(entry);
+    }
+
+    // Implementation based on description in pg 440 of
+    // Modern Compiler implementation in C
+    // Appel
+    private void computeDF(BasicBlock n) {
+        var S = new HashSet<BasicBlock>();
+        for (BasicBlock y: n.successors) {
+            if (y.idom != n)
+                S.add(y);
+        }
+        for (BasicBlock c: n.dominatedChildren) {
+            computeDF(c);
+            for (BasicBlock w: c.dominationFrontier) {
+                // Note that the printed book has an error below
+                // and errata gives the correct version
+                if (!n.dominates(w) || n==w) {
+                    S.add(w);
+                }
+            }
+        }
+        n.dominationFrontier.addAll(S);
+    }
+
     public String generateDotOutput() {
         StringBuilder sb = new StringBuilder();
         sb.append("digraph DomTree {\n");
@@ -212,10 +250,18 @@ public String generateDotOutput() {
         }
         for (BasicBlock n : blocks) {
             BasicBlock idom = n.idom;
-            if (idom == n) continue;
+            if (idom == null) continue;
             sb.append(idom.uniqueName()).append("->").append(n.uniqueName()).append(";\n");
         }
         sb.append("}\n");
         return sb.toString();
     }
+
+    public String listDomFrontiers() {
+        StringBuilder sb = new StringBuilder();
+        for (BasicBlock n : blocks) {
+            n.listDomFrontiers(sb);
+        }
+        return sb.toString();
+    }
 }

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

@@ -41,6 +41,10 @@ public EnterSSA(CompiledFunction bytecodeFunction, EnumSet<Options> options) {
             System.out.println("Pre SSA Dominator Tree");
             System.out.println(domTree.generateDotOutput());
         }
+        if (options.contains(Options.DUMP_PRE_SSA_DOMFRONTIERS)) {
+            System.out.println("Pre SSA Dominance Frontiers");
+            System.out.println(domTree.listDomFrontiers());
+        }
         this.blocks = domTree.blocks;   // the blocks are ordered reverse post order
         findNonLocalNames();
         new Liveness(bytecodeFunction); // EWe require liveness info to construct pruned ssa

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

@@ -10,6 +10,7 @@ public enum Options {
     REGALLOC,
     DUMP_INITIAL_IR,
     DUMP_PRE_SSA_DOMTREE,
+    DUMP_PRE_SSA_DOMFRONTIERS,
     DUMP_SSA_IR,
     DUMP_SCCP_PREAPPLY,
     DUMP_SCCP_POSTAPPLY,

optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestDominators.java

@@ -12,6 +12,8 @@ BasicBlock add(List<BasicBlock> nodes, BasicBlock node) {
         return node;
     }
 
+    // This CFG example is taken from page 473 of
+    // Engineering a Compiler 3rd ed
     BasicBlock makeGraph(List<BasicBlock> nodes) {
         BasicBlock r0 = add(nodes, new BasicBlock(1));
         BasicBlock r1 = add(nodes, new BasicBlock(2, r0));
@@ -28,15 +30,34 @@ BasicBlock makeGraph(List<BasicBlock> nodes) {
         return r0;
     }
 
+    // This DOM Tree example is taken from page 473 of
+    // Engineering a Compiler 3rd ed
     @Test
     public void testDominatorTree() {
         List<BasicBlock> nodes = new ArrayList<>();
         BasicBlock root = makeGraph(nodes);
         DominatorTree tree = new DominatorTree(root);
         System.out.println(tree.generateDotOutput());
-        long[] expectedIdoms = {0,1,1,2,2,4,2,6,6,6};
+        // expected            {_,_,0,1,1,3,1,5,5,5}
+        // Note first entry is not used
+        // Note we set idom of root to itself so the second entry
+        // does not match example
+        long[] expectedIdoms = {-1,0,1,2,2,4,2,6,6,6};
         for (BasicBlock n: nodes) {
-            Assert.assertEquals(expectedIdoms[(int)n.bid], n.idom.bid);
+            if (expectedIdoms[(int)n.bid] == 0)
+                Assert.assertNull(n.idom);
+            else
+                Assert.assertEquals(expectedIdoms[(int)n.bid], n.idom.bid);
+        }
+        // -1 means empty set
+        long[] expectedDF = {0,-1,2,4,2,-1,4,8,4,8};
+        for (BasicBlock n: nodes) {
+            if (expectedDF[(int)n.bid] == -1) {
+                Assert.assertTrue(n.dominationFrontier.isEmpty());
+            }
+            else {
+                Assert.assertEquals(1,n.dominationFrontier.size());
+            }
         }
     }
 

optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestSSATransform.java

@@ -26,6 +26,7 @@ String compileSrc(String src) {
                 BasicBlock.toStr(sb, functionBuilder.entry, new BitSet(), false);
                 //functionBuilder.toDot(sb,false);
                 new EnterSSA(functionBuilder, Options.NONE);
+                //new EnterSSA(functionBuilder, EnumSet.of(DUMP_PRE_SSA_DOMFRONTIERS));
                 sb.append("After SSA\n");
                 sb.append("=========\n");
                 BasicBlock.toStr(sb, functionBuilder.entry, new BitSet(), false);