more work on boolean binary expressions

Fix bug in EnterSSA caused by mutable operands shared across instructions, replacing the phi register cause other instructions to change inadvertantly.

Ensure SSA tests check output

Author: dibyendumajumdar

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

@@ -412,42 +412,28 @@ private boolean compileSymbolExpr(AST.NameExpr symbolExpr) {
     }
 
     private boolean codeBoolean(AST.BinaryExpr binaryExpr) {
-        BasicBlock l1;
-        BasicBlock l2;
-        BasicBlock l3;
-        boolean indexed;
-        boolean isAnd;
-
-        l1 = createBlock();
-        l2 = createBlock();
-        l3 = createBlock();
-        indexed = compileExpr(binaryExpr.expr1);
-        if (indexed) {
+        boolean isAnd = binaryExpr.op.str.equals("&&");
+        BasicBlock l1 = createBlock();
+        BasicBlock l2 = createBlock();
+        BasicBlock l3 = createBlock();
+        boolean indexed = compileExpr(binaryExpr.expr1);
+        if (indexed)
             codeIndexedLoad();
-        }
-        isAnd = binaryExpr.op.str.equals("&&");
-        // FIXME ensure temp
-        var operand = pop();
-        var temp = createTemp(typeDictionary.INT);
-        code(new Instruction.Move(operand, temp));
         if (isAnd) {
             code(new Instruction.ConditionalBranch(currentBlock, pop(), l1, l2));
         } else {
             code(new Instruction.ConditionalBranch(currentBlock, pop(), l2, l1));
         }
         startBlock(l1);
-        indexed = compileExpr(binaryExpr.expr2);
-        if (indexed) {
-            codeIndexedLoad();
-        }
-        operand = pop();
-        temp = createTemp(typeDictionary.INT);
-        code(new Instruction.Move(operand, temp));
+        compileExpr(binaryExpr.expr2);
+        var temp = ensureTemp();
         jumpTo(l3);
         startBlock(l2);
+        // Below we must write to the same temp
         code(new Instruction.Move(new Operand.ConstantOperand(isAnd ? 0 : 1, typeDictionary.INT), temp));
         jumpTo(l3);
         startBlock(l3);
+        // leave temp on virtual stack
         return false;
     }
 
@@ -549,6 +535,36 @@ private Operand.TempRegisterOperand createTemp(Type type) {
         return tempRegister;
     }
 
+    Type typeOfOperand(Operand operand) {
+        if (operand instanceof Operand.ConstantOperand constant)
+            return constant.type;
+        else if (operand instanceof Operand.NullConstantOperand nullConstantOperand)
+            return nullConstantOperand.type;
+        else if (operand instanceof Operand.RegisterOperand registerOperand)
+            return registerOperand.type;
+        else throw new CompilerException("Invalid operand");
+    }
+
+    private Operand.TempRegisterOperand createTempAndMove(Operand src) {
+        Type type = typeOfOperand(src);
+        var temp = createTemp(type);
+        code(new Instruction.Move(src, temp));
+        return temp;
+    }
+
+    private Operand.RegisterOperand ensureTemp() {
+        Operand top = top();
+        if (top instanceof Operand.ConstantOperand
+                || top instanceof Operand.NullConstantOperand
+                || top instanceof Operand.LocalRegisterOperand) {
+            return createTempAndMove(pop());
+        } else if (top instanceof Operand.IndexedOperand) {
+            return codeIndexedLoad();
+        } else if (top instanceof Operand.TempRegisterOperand tempRegisterOperand) {
+            return tempRegisterOperand;
+        } else throw new CompilerException("Cannot convert to temporary register");
+    }
+
     private void pushLocal(int regnum, String varName) {
         pushOperand(new Operand.LocalRegisterOperand(regnum, varName));
     }
@@ -565,7 +581,7 @@ private Operand top() {
         return virtualStack.getLast();
     }
 
-    private void codeIndexedLoad() {
+    private Operand.TempRegisterOperand codeIndexedLoad() {
         Operand indexed = pop();
         var temp = createTemp(indexed.type);
         if (indexed instanceof Operand.LoadIndexedOperand loadIndexedOperand) {
@@ -576,6 +592,7 @@ else if (indexed instanceof Operand.LoadFieldOperand loadFieldOperand) {
         }
         else
             code(new Instruction.Move(indexed, temp));
+        return temp;
     }
 
     private void codeIndexedStore() {

registervm/src/test/java/com/compilerprogramming/ezlang/interpreter/TestInterpreter.java

@@ -176,4 +176,72 @@ func foo()->Int
                 integerValue.value == 1);
     }
 
+    @Test
+    public void testFunction104() {
+        String src = """
+                func foo()->Int 
+                {
+                    return 1 == 1 && 2 == 2
+                }
+
+                """;
+        var value = compileAndRun(src, "foo");
+        Assert.assertNotNull(value);
+        Assert.assertTrue(value instanceof Value.IntegerValue integerValue &&
+                integerValue.value == 1);
+    }
+
+    @Test
+    public void testFunction105() {
+        String src = """
+                func bar(a: Int, b: Int)->Int 
+                {
+                    return a+1 == b-1 && b / a == 2
+                }
+                func foo()->Int
+                {
+                    return bar(3,5)
+                }
+                """;
+        var value = compileAndRun(src, "foo");
+        Assert.assertNotNull(value);
+        Assert.assertTrue(value instanceof Value.IntegerValue integerValue &&
+                integerValue.value == 0);
+    }
+
+    @Test
+    public void testFunction106() {
+        String src = """
+                func bar(a: Int, b: Int)->Int 
+                {
+                    return a+1 == b-1 || b / a == 2
+                }
+                func foo()->Int
+                {
+                    return bar(3,5)
+                }
+                """;
+        var value = compileAndRun(src, "foo");
+        Assert.assertNotNull(value);
+        Assert.assertTrue(value instanceof Value.IntegerValue integerValue &&
+                integerValue.value == 1);
+    }
+
+    @Test
+    public void testFunction107() {
+        String src = """
+                func bar(a: [Int])->Int 
+                {
+                    return a[0]+a[2] == a[1]-a[2] || a[1] / a[0] == 2
+                }
+                func foo()->Int
+                {
+                    return bar(new [Int] {3,5,1})
+                }
+                """;
+        var value = compileAndRun(src, "foo");
+        Assert.assertNotNull(value);
+        Assert.assertTrue(value instanceof Value.IntegerValue integerValue &&
+                integerValue.value == 1);
+    }
 }