phi vars must also be SSA values

When temps are used for creating arrays and structs ensure they get processed in the same way as all temps.

Author: dibyendumajumdar

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

@@ -627,17 +627,30 @@ else if (indexed instanceof Operand.LoadFieldOperand loadFieldOperand) {
     }
 
     private void codeNew(Type type) {
-        var temp = createTemp(type);
-        if (type instanceof Type.TypeArray typeArray) {
-            code(new Instruction.NewArray(typeArray, temp));
-        }
-        else if (type instanceof Type.TypeStruct typeStruct) {
-            code(new Instruction.NewStruct(typeStruct, temp));
-        }
+        if (type instanceof Type.TypeArray typeArray)
+            codeNewArray(typeArray);
+        else if (type instanceof Type.TypeStruct typeStruct)
+            codeNewStruct(typeStruct);
         else
             throw new CompilerException("Unexpected type: " + type);
     }
 
+    private void codeNewArray(Type.TypeArray typeArray) {
+        var temp = createTemp(typeArray);
+        var target = (Operand.RegisterOperand) issa.write(temp);
+        var insn = new Instruction.NewArray(typeArray, target);
+        issa.recordDef(target, insn);
+        code(insn);
+    }
+
+    private void codeNewStruct(Type.TypeStruct typeStruct) {
+        var temp = createTemp(typeStruct);
+        var target = (Operand.RegisterOperand) issa.write(temp);
+        var insn = new Instruction.NewStruct(typeStruct, target);
+        issa.recordDef(target, insn);
+        code(insn);
+    }
+
     private void codeStoreAppend() {
         var operand = issa.read(pop());
         Operand.RegisterOperand arrayOperand = (Operand.RegisterOperand) issa.read(top());
@@ -879,10 +892,8 @@ private Register readVariableRecursive(Register variable, BasicBlock block) {
             Register val;
             if (!sealedBlocks.get(block.bid)) {
                 // incomplete CFG
-                val = function.registerPool.newISSAReg("phi_" + variable.name(), variable.type);
-                Instruction.Phi phi = new Instruction.Phi(val, new ArrayList<>());
-                recordDef(val, phi);
-                block.add(0, phi);
+                val = makeVersion(variable);
+                Instruction.Phi phi = makePhi(val, block);
                 incompletePhis.computeIfAbsent(block, k -> new HashMap<>()).put(variable, phi);
             }
             else if (block.predecessors.size() == 1) {
@@ -891,17 +902,22 @@ else if (block.predecessors.size() == 1) {
             }
             else {
                 // Break potential cycles with operandless phis
-                val = function.registerPool.newISSAReg("phi_" + variable.name(), variable.type);
-                Instruction.Phi phi = new Instruction.Phi(val, new ArrayList<>());
-                recordDef(val, phi);
-                block.add(0, phi);
+                val = makeVersion(variable);
+                Instruction.Phi phi = makePhi(val, block);
                 writeVariable(variable, block, val);
                 val = addPhiOperands(variable,phi);
             }
             writeVariable(variable, block, val);
             return val;
         }
 
+        private Instruction.Phi makePhi(Register val, BasicBlock block) {
+            Instruction.Phi phi = new Instruction.Phi(val, new ArrayList<>());
+            recordDef(val, phi);
+            block.add(0, phi);
+            return phi;
+        }
+
         /**
          * Populate the members of a phi instruction
          */
@@ -999,23 +1015,29 @@ public Operand write(Operand operand) {
             // where temps are not SSA
             if (operand instanceof Operand.RegisterOperand localRegisterOperand) {
                 var variable = localRegisterOperand.reg;
-                Register newValue;
-                Integer version = versioned.get(variable.nonSSAId());
-                // Avoid creating a new value first time because we already
-                // have a pre-created register we can use
-                if (version == null) {
-                    newValue = variable;
-                    versioned.put(variable.nonSSAId(), 1);
-                }
-                else {
-                    versioned.put(variable.nonSSAId(), version + 1);
-                    newValue = function.registerPool.ssaReg(variable, version);
-                }
+                Register newValue = makeVersion(variable);
                 writeVariable(variable, function.currentBlock, newValue);
                 operand = new Operand.RegisterOperand(newValue);
             }
             return operand;
         }
+
+        private Register makeVersion(Register variable) {
+            Register newValue;
+            Integer version = versioned.get(variable.nonSSAId());
+            // Avoid creating a new value first time because we already
+            // have a pre-created register we can use
+            if (version == null) {
+                newValue = variable;
+                versioned.put(variable.nonSSAId(), 1);
+            }
+            else {
+                versioned.put(variable.nonSSAId(), version + 1);
+                newValue = function.registerPool.ssaReg(variable, version);
+            }
+            return newValue;
+        }
+
         @Override
         public void recordUse(Operand operand, Instruction instruction) {
             if (operand instanceof Operand.RegisterOperand registerOperand) {