#53 When a phi goes dead all references to its def in the memoized set of defs must be removed

Author: dibyendumajumdar

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

@@ -965,6 +965,32 @@ private Register addPhiOperands(Register variable, Instruction.Phi phi) {
             return tryRemovingPhi(phi);
         }
 
+        // The Phi's def is dead so we need to remove
+        // all occurrences of this def from the memoized defs
+        // per Basic Block
+        private void clearDefs(Instruction.Phi phi) {
+            // TODO rethink the data structure for currentDef
+            var def = phi.value();
+            var defs = currentDef.get(def.nonSSAId());
+            // Make a list of block/reg that we need to delete
+            var bbList = new ArrayList<BasicBlock>();
+            var regList = new ArrayList<Register>();
+            for (var entries : defs.entrySet()) {
+                var bb = entries.getKey();
+                var reg = entries.getValue();
+                if (reg.equals(def)) {
+                    bbList.add(bb);
+                    regList.add(reg);
+                }
+            }
+            // Now delete them
+            for (int i = 0; i < bbList.size(); i++) {
+                var bb = bbList.get(i);
+                var reg = regList.get(i);
+                defs.remove(bb, reg);
+            }
+        }
+
         private Register tryRemovingPhi(Instruction.Phi phi) {
             Register same = null;
             // Check if phi has distinct inputs
@@ -991,6 +1017,9 @@ private Register tryRemovingPhi(Instruction.Phi phi) {
             // remove all uses of phi to same and remove phi
             replacePhiValueAndUsers(phi, same);
             phi.block.deleteInstruction(phi);
+            // Since the phi is dead any references to its def
+            // must be removed; this is not mentioned in the paper
+            clearDefs(phi);
             // try to recursively remove all phi users, which might have become trivial
             for (var use: users) {
                 if (use instanceof Instruction.Phi phiuser)
@@ -1003,25 +1032,28 @@ private Register tryRemovingPhi(Instruction.Phi phi) {
          * Reroute all uses of phi to new value
          */
         private void replacePhiValueAndUsers(Instruction.Phi phi, Register newValue) {
-            var oldDefUseChain = ssaDefUses.get(phi.value());
+            var oldValue = phi.value();
+            var oldDefUseChain = ssaDefUses.get(oldValue);
             var newDefUseChain = ssaDefUses.get(newValue);
             if (newDefUseChain == null) {
-                // Can be null because this may be existing def
-                newDefUseChain = SSAEdges.addDef(ssaDefUses, newValue, phi);
+                throw new CompilerException("Expected error: undefined var " + newValue);
             }
             if (oldDefUseChain != null) {
                 for (Instruction instruction: oldDefUseChain.useList) {
+                    boolean replaced;
                     if (instruction instanceof Instruction.Phi somePhi) {
-                        somePhi.replaceInput(phi.value(), newValue);
+                        replaced = somePhi.replaceInput(oldValue, newValue);
                     }
                     else {
-                        instruction.replaceUse(phi.value(), newValue);
+                        replaced = instruction.replaceUse(oldValue, newValue);
+                    }
+                    if (!replaced) {
+                        throw new CompilerException("Discrepancy between var use list and var definition");
                     }
                 }
                 // Users of phi old value become users of the new value
                 newDefUseChain.useList.addAll(oldDefUseChain.useList);
                 oldDefUseChain.useList.clear();
-                // FIXME remove old def from def-use chains
             }
         }
 

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

@@ -431,15 +431,18 @@ public void addInput(Register register) {
             newUses[newUses.length-1] = new Operand.RegisterOperand(register);
             this.uses = newUses;
         }
-        public void replaceInput(Register oldReg, Register newReg) {
+        public boolean replaceInput(Register oldReg, Register newReg) {
+            boolean replaced = false;
             for (int i = 0; i < numInputs(); i++) {
                 if (isRegisterInput(i)) {
                     Register in = inputAsRegister(i);
                     if (in.equals(oldReg)) {
                         replaceInput(i, newReg);
+                        replaced = true;
                     }
                 }
             }
+            return replaced;
         }
     }
 

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

@@ -40,7 +40,7 @@ public class Register {
      *
      * Not unique.
      */
-    private final String name;
+    protected final String name;
     /**
      * The type of the register
      */
@@ -50,7 +50,7 @@ public class Register {
      * of the executing function. Multiple registers may share the same
      * frame slot because of different non-overlapping life times.
      */
-    private int frameSlot;
+    protected int frameSlot;
 
     public Register(int id, String name, Type type) {
         this(id,name,type,id);  // Initially frame slot is set to the unique ID
@@ -107,7 +107,15 @@ public SSARegister(Register original, int id, int version) {
         public int nonSSAId() {
             return originalRegNumber;
         }
-    }
 
+        @Override
+        public String toString() {
+            return "SSARegister{name=" + name + ", id=" + id + ", frameSlot=" + frameSlot + ", ssaVersion=" + ssaVersion + ", originalRegNumber=" + originalRegNumber + '}';
+        }
+    }
 
+    @Override
+    public String toString() {
+        return "Register{name=" + name + ", id=" + id + ", frameSlot=" + frameSlot + "}";
+    }
 }

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

@@ -89,6 +89,8 @@ private static void recordUses(Map<Register, SSADef> defUseChains, Register[] in
 
     public static void recordUse(Map<Register, SSADef> defUseChains, Instruction instruction, Register register) {
         SSADef def = defUseChains.get(register);
+        if (def == null)
+            throw new CompilerException("No def found for " + register);
         def.useList.add(instruction);
     }