WIP implement incremental SSA construction using Braun's method

dibyendumajumdar · dibyendumajumdar · commit a456dbb5a01c · 2025-02-22T21:02:51.000Z
WIP implement incremental SSA construction using Braun's method

WIP implement incremental SSA construction using Braun's method

WIP implement incremental SSA construction using Braun's method

WIP implement incremental SSA construction using Braun's method

Small refactor to help with the incremental SSA diff

Add option to control ISSA

Add missing use replacement in Phis
Some other cleanup and comments

Bug fix

Some prep work on enabling more tests
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/BasicBlock.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/BasicBlock.java
@@ -111,10 +111,10 @@ public void deleteInstruction(Instruction instruction) {
         instructions.remove(instruction);
     }
     public void addSuccessor(BasicBlock successor) {
-        assert successors.contains(successor) == false;
-        successors.add(successor);
-        assert successor.predecessors.contains(this) == false;
-        successor.predecessors.add(this);
+        if (!successors.contains(successor)) {
+            successors.add(successor);
+            successor.predecessors.add(this);
+        }
     }
     public void removeSuccessor(BasicBlock successor) {
         successors.remove(successor);
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java
@@ -16,7 +16,7 @@ private void compile(TypeDictionary typeDictionary, EnumSet<Options> options) {
         for (Symbol symbol: typeDictionary.getLocalSymbols()) {
             if (symbol instanceof Symbol.FunctionTypeSymbol functionSymbol) {
                 Type.TypeFunction functionType = (Type.TypeFunction) functionSymbol.type;
-                var function = new CompiledFunction(functionSymbol, typeDictionary);
+                var function = new CompiledFunction(functionSymbol, typeDictionary, options);
                 if (options.contains(Options.DUMP_INITIAL_IR))
                     function.dumpIR(false, "Initial IR");
                 functionType.code = function;
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Instruction.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Instruction.java
@@ -426,6 +426,22 @@ public StringBuilder toStr(StringBuilder sb) {
             sb.append(")");
             return sb;
         }
+        public void addInput(Register register) {
+            var newUses = new Operand[uses.length + 1];
+            System.arraycopy(uses, 0, newUses, 0, uses.length);
+            newUses[newUses.length-1] = new Operand.RegisterOperand(register);
+            this.uses = newUses;
+        }
+        public void replaceInput(Register oldReg, Register newReg) {
+            for (int i = 0; i < numInputs(); i++) {
+                if (isRegisterInput(i)) {
+                    Register in = inputAsRegister(i);
+                    if (in.equals(oldReg)) {
+                        replaceInput(i, newReg);
+                    }
+                }
+            }
+        }
     }
 
     public static class ArgInstruction extends Instruction {
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Operand.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Operand.java
@@ -1,5 +1,6 @@
 package com.compilerprogramming.ezlang.compiler;
 
+import com.compilerprogramming.ezlang.types.Symbol;
 import com.compilerprogramming.ezlang.types.Type;
 
 public class Operand {
@@ -48,12 +49,14 @@ public String toString() {
     }
 
     public static class LocalRegisterOperand extends RegisterOperand {
-        public LocalRegisterOperand(Register reg) {
+        Symbol.VarSymbol variable;
+        public LocalRegisterOperand(Register reg, Symbol.VarSymbol variable) {
             super(reg);
+            this.variable = variable;
         }
         @Override
         public RegisterOperand copy(Register register) {
-            return new LocalRegisterOperand(register);
+            return new LocalRegisterOperand(register, variable);
         }
     }
 
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Optimizer.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Optimizer.java
@@ -6,7 +6,8 @@ public class Optimizer {
 
     public void optimize(CompiledFunction function, EnumSet<Options> options) {
         if (options.contains(Options.OPTIMIZE)) {
-            new EnterSSA(function, options);
+            if (!function.isSSA)
+                new EnterSSA(function, options);
             if (options.contains(Options.SCCP)) {
                 new SparseConditionalConstantPropagation().constantPropagation(function).apply(options);
                 if (new ConstantComparisonPropagation(function).apply(options)) {
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Options.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Options.java
@@ -3,6 +3,7 @@
 import java.util.EnumSet;
 
 public enum Options {
+    ISSA, // Incremental SSA
     OPTIMIZE,
     SCCP,
     CCP, // constant comparison propagation
@@ -22,5 +23,6 @@ public enum Options {
 
     public static final EnumSet<Options> NONE = EnumSet.noneOf(Options.class);
     public static final EnumSet<Options> OPT = EnumSet.of(Options.OPTIMIZE,Options.SCCP,Options.CCP,Options.REGALLOC);
-    public static final EnumSet<Options> OPT_VERBOSE = EnumSet.allOf(Options.class);
+    public static final EnumSet<Options> VERBOSE = EnumSet.range(DUMP_INITIAL_IR, DUMP_POST_CHAITIN_IR);
+    public static final EnumSet<Options> OPT_VERBOSE = EnumSet.range(OPTIMIZE, DUMP_POST_CHAITIN_IR);
 }
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Register.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/Register.java
@@ -106,4 +106,6 @@ public int nonSSAId() {
             return originalRegNumber;
         }
     }
+
+
 }
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/RegisterPool.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/RegisterPool.java
@@ -24,6 +24,12 @@ public Register newReg(String baseName, Type type) {
         registers.add(reg);
         return reg;
     }
+    public Register newISSAReg(String baseName, Type type) {
+        var id = registers.size();
+        var reg = new Register(id, baseName + "_" + id, type);
+        registers.add(reg);
+        return reg;
+    }
     public Register newTempReg(Type type) {
         var id = registers.size();
         var name = "%t"+id;
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/SSAEdges.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/SSAEdges.java
@@ -83,12 +83,16 @@ private static void recordUses(CompiledFunction function, Map<Register, SSADef>
 
     private static void recordUses(Map<Register, SSADef> defUseChains, Register[] inputs, BasicBlock block, Instruction instruction) {
         for (Register register : inputs) {
-            SSADef def = defUseChains.get(register);
-            def.useList.add(instruction);
+            recordUse(defUseChains, instruction, register);
         }
     }
 
-    private static void recordDef(Map<Register, SSADef> defUseChains, Register value, Instruction instruction) {
+    public static void recordUse(Map<Register, SSADef> defUseChains, Instruction instruction, Register register) {
+        SSADef def = defUseChains.get(register);
+        def.useList.add(instruction);
+    }
+
+    public static void recordDef(Map<Register, SSADef> defUseChains, Register value, Instruction instruction) {
         if (defUseChains.containsKey(value))
             throw new CompilerException("Register already defined, invalid multiple definition in SSA");
         defUseChains.put(value, new SSADef(instruction));
diff --git a/optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestIncrementalSSA.java b/optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestIncrementalSSA.java
@@ -0,0 +1,107 @@
+package com.compilerprogramming.ezlang.compiler;
+
+import org.junit.Test;
+
+import java.util.EnumSet;
+
+public class TestIncrementalSSA {
+    String compileSrc(String src) {
+        var compiler = new Compiler();
+        var typeDict = compiler.compileSrc(src, EnumSet.of(Options.ISSA));
+        return compiler.dumpIR(typeDict);
+    }
+
+    @Test
+    public void test1() {
+        String src = """
+                func foo(d: Int) {
+                    var a = 42;
+                    var b = a;
+                    var c = a + b;
+                    a = c + 23;
+                    c = a + d;
+                }
+                """;
+        String result = compileSrc(src);
+        System.out.println(result);
+    }
+
+    @Test
+    public void test2() {
+        String src = """
+                func foo(d: Int)->Int {
+                    var a = 42
+                    if (d)
+                    {
+                      a = a + 1
+                    }
+                    else
+                    {
+                      a = a - 1
+                    }
+                    return a
+                }
+                """;
+        String result = compileSrc(src);
+        System.out.println(result);
+    }
+
+    @Test
+    public void test3() {
+        String src = """
+                func factorial(num: Int)->Int {
+                    var result = 1
+                    while (num > 1)
+                    {
+                      result = result * num
+                      num = num - 1
+                    }
+                    return result
+                }
+                """;
+        String result = compileSrc(src);
+        System.out.println(result);
+    }
+
+
+    @Test
+    public void test4() {
+        String src = """
+                func print(a: Int, b: Int, c:Int, d:Int) {}
+                func example14_66(p: Int, q: Int, r: Int, s: Int, t: Int) {
+                    var i = 1
+                    var j = 1
+                    var k = 1
+                    var l = 1
+                    while (1) {
+                        if (p) {
+                            j = i
+                            if (q) {
+                                l = 2
+                            }
+                            else {
+                                l = 3
+                            }
+                            k = k + 1
+                        }
+                        else {
+                            k = k + 2
+                        }
+                        print(i,j,k,l)
+                        while (1) {
+                            if (r) {
+                                l = l + 4
+                            }
+                            if (!s)
+                                break
+                        }
+                        i = i + 6
+                        if (!t)
+                            break
+                    }
+                }
+                """;
+        String result = compileSrc(src);
+        System.out.println(result);
+    }
+}
diff --git a/optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestInterferenceGraph.java b/optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestInterferenceGraph.java
@@ -11,15 +11,16 @@ public class TestInterferenceGraph {
     private CompiledFunction buildTest1() {
         TypeDictionary typeDictionary = new TypeDictionary();
         Type.TypeFunction functionType = new Type.TypeFunction("foo");
-        functionType.addArg(new Symbol.ParameterSymbol("a", typeDictionary.INT));
+        var argSymbol = new Symbol.ParameterSymbol("a", typeDictionary.INT);
+        functionType.addArg(argSymbol);
         functionType.setReturnType(typeDictionary.INT);
         CompiledFunction function = new CompiledFunction(functionType, typeDictionary);
         RegisterPool regPool = function.registerPool;
         Register a = regPool.newReg("a", typeDictionary.INT);
         Register b = regPool.newReg("b", typeDictionary.INT);
         Register c = regPool.newReg("c", typeDictionary.INT);
         Register d = regPool.newReg("d", typeDictionary.INT);
-        function.code(new Instruction.ArgInstruction(new Operand.LocalRegisterOperand(a)));
+        function.code(new Instruction.ArgInstruction(new Operand.LocalRegisterOperand(a, argSymbol)));
         function.code(new Instruction.Binary(
                 "+",
                 new Operand.RegisterOperand(a),
diff --git a/optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestSSATransform.java b/optvm/src/test/java/com/compilerprogramming/ezlang/compiler/TestSSATransform.java
@@ -638,13 +638,14 @@ func bar(arg: Int)->Int {
     static CompiledFunction buildLostCopyTest() {
         TypeDictionary typeDictionary = new TypeDictionary();
         Type.TypeFunction functionType = new Type.TypeFunction("foo");
-        functionType.addArg(new Symbol.ParameterSymbol("p", typeDictionary.INT));
+        var argSymbol = new Symbol.ParameterSymbol("p", typeDictionary.INT);
+        functionType.addArg(argSymbol);
         functionType.setReturnType(typeDictionary.INT);
         CompiledFunction function = new CompiledFunction(functionType, typeDictionary);
         RegisterPool regPool = function.registerPool;
         Register p = regPool.newReg("p", typeDictionary.INT);
         Register x1 = regPool.newReg("x1", typeDictionary.INT);
-        function.code(new Instruction.ArgInstruction(new Operand.LocalRegisterOperand(p)));
+        function.code(new Instruction.ArgInstruction(new Operand.LocalRegisterOperand(p, argSymbol)));
         function.code(new Instruction.Move(
                 new Operand.ConstantOperand(1, typeDictionary.INT),
                 new Operand.RegisterOperand(x1)));
@@ -706,7 +707,8 @@ public void testLostCopyProblem() {
     static CompiledFunction buildSwapTest() {
         TypeDictionary typeDictionary = new TypeDictionary();
         Type.TypeFunction functionType = new Type.TypeFunction("foo");
-        functionType.addArg(new Symbol.ParameterSymbol("p", typeDictionary.INT));
+        var argSymbol = new Symbol.ParameterSymbol("p", typeDictionary.INT);
+        functionType.addArg(argSymbol);
         functionType.setReturnType(typeDictionary.VOID);
         CompiledFunction function = new CompiledFunction(functionType, typeDictionary);
         RegisterPool regPool = function.registerPool;
@@ -715,7 +717,7 @@ static CompiledFunction buildSwapTest() {
         Register a2 = regPool.newReg("a2", typeDictionary.INT);
         Register b1 = regPool.newReg("b1", typeDictionary.INT);
         Register b2 = regPool.newReg("b2", typeDictionary.INT);
-        function.code(new Instruction.ArgInstruction(new Operand.LocalRegisterOperand(p)));
+        function.code(new Instruction.ArgInstruction(new Operand.LocalRegisterOperand(p, argSymbol)));
         function.code(new Instruction.Move(
                 new Operand.ConstantOperand(42, typeDictionary.INT),
                 new Operand.RegisterOperand(a1)));
diff --git a/types/src/main/java/com/compilerprogramming/ezlang/types/Symbol.java b/types/src/main/java/com/compilerprogramming/ezlang/types/Symbol.java
@@ -39,6 +39,18 @@ public static class VarSymbol extends Symbol {
         public VarSymbol(String name, Type type) {
             super(name, type);
         }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            VarSymbol varSymbol = (VarSymbol) o;
+            return regNumber == varSymbol.regNumber;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hashCode(regNumber);
+        }
     }
 
     public static class ParameterSymbol extends VarSymbol {

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`package com.compilerprogramming.ezlang.compiler;`
`2`	`2`
	`3`	`+import com.compilerprogramming.ezlang.types.Symbol;`
`3`	`4`	`import com.compilerprogramming.ezlang.types.Type;`
`4`	`5`
`5`	`6`	`public class Operand {`
`@@ -48,12 +49,14 @@ public String toString() {`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`public static class LocalRegisterOperand extends RegisterOperand {`
`51`		`- public LocalRegisterOperand(Register reg) {`
	`52`	`+ Symbol.VarSymbol variable;`
	`53`	`+ public LocalRegisterOperand(Register reg, Symbol.VarSymbol variable) {`
`52`	`54`	`super(reg);`
	`55`	`+ this.variable = variable;`
`53`	`56`	`}`
`54`	`57`	`@Override`
`55`	`58`	`public RegisterOperand copy(Register register) {`
`56`		`- return new LocalRegisterOperand(register);`
	`59`	`+ return new LocalRegisterOperand(register, variable);`
`57`	`60`	`}`
`58`	`61`	`}`
`59`	`62`
Original file line number	Diff line number	Diff line change
`@@ -106,4 +106,6 @@ public int nonSSAId() {`
`106`	`106`	`return originalRegNumber;`
`107`	`107`	`}`
`108`	`108`	`}`
	`109`	`+`
	`110`	`+`
`109`	`111`	`}`