Verify tmp registers

compiler/modules/bir/verify.bal

@@ -67,18 +67,69 @@ class VerifyContext {
 
 public function verifyFunctionCode(Module mod, FunctionDefn defn, FunctionCode code) returns Error? {
     VerifyContext cx = new(mod, defn);
+    boolean[] tmpRegisterUsed = [];
+    if code.registers.length() > 0 {
+        tmpRegisterUsed[code.registers.length() - 1] = false;
+    }
     foreach BasicBlock b in code.blocks {
-        check verifyBasicBlock(cx, b);
+        check verifyBasicBlock(cx, b, tmpRegisterUsed);
     }
 }
 
 type IntBinaryInsn IntArithmeticBinaryInsn|IntBitwiseBinaryInsn;
 
 type Error err:Semantic|err:Internal;
 
-function verifyBasicBlock(VerifyContext vc, BasicBlock bb) returns Error? {
+function verifyBasicBlock(VerifyContext vc, BasicBlock bb, boolean[] tmpRegisterUsed) returns Error? {
     foreach Insn insn in bb.insns {
         check verifyInsn(vc, insn);
+        check verifyInsnRegisterKinds(vc, insn, tmpRegisterUsed);
+    }
+}
+
+function verifyInsnRegisterKinds(VerifyContext vc, Insn insn, boolean[] tmpRegisterUsed) returns Error? {
+    if insn is ResultInsnBase {
+        if tmpRegisterUsed[insn.result.number] {
+            return vc.invalidErr("tmp register defined in multiple places", insn.pos);
+        }
+        else {
+            tmpRegisterUsed[insn.result.number] = true;
+        }
+    }
+
+    if insn is BranchInsn|CatchInsn {
+        return;
+    }
+    else if insn is CallInsn {
+        foreach Operand arg in insn.args {
+            check verifyRegisterKind(vc, arg, tmpRegisterUsed, insn.pos);
+        }
+    }
+    else {
+        match insn {
+            var { operand } => {
+                check verifyRegisterKind(vc, operand, tmpRegisterUsed, insn.pos);
+            }
+            var { operands } => {
+                // JBUG #35557 can't iterate operands
+                Operand[] ops = operands;
+                foreach Operand op in ops {
+                    check verifyRegisterKind(vc, op, tmpRegisterUsed, insn.pos);
+                }
+            }
+        }
+    }
+}
+
+function verifyRegisterKind(VerifyContext vc, Operand r, boolean[] tmpRegisterUsed, Position pos) returns Error? {
+    if r is TmpRegister && !tmpRegisterUsed[r.number] {
+        return vc.invalidErr("tmp register not initialized", pos);
+    }
+}
+
+function verifyNarrowRegister(VerifyContext vc, NarrowRegister r) returns Error? {
+    if !t:isSubtype(vc.typeContext(), r.semType, r.underlying.semType) {
+        return vc.invalidErr("narrow register is not a subtype of narrowed register", <Position>r.pos);
     }
 }
 
@@ -151,6 +202,13 @@ function verifyInsn(VerifyContext vc, Insn insn) returns Error? {
     else if insn is ErrorConstructInsn {
         check validOperandString(vc, name, insn.operand, insn.pos);
     }
+    else if insn is TypeMergeInsn {
+        check verifyNarrowRegister(vc, insn.result);
+    }
+    else if insn is TypeBranchInsn {
+        check verifyNarrowRegister(vc, insn.ifTrueRegister);
+        check verifyNarrowRegister(vc, insn.ifFalseRegister);
+    }
 }
 
 function verifyCall(VerifyContext vc, CallInsn insn) returns err:Internal? {
@@ -226,6 +284,9 @@ function verifyListSet(VerifyContext vc, ListSetInsn insn) returns Error? {
     if !vc.isSubtype(insn.operands[0].semType, t:LIST) {
         return vc.semanticErr("list set applied to non-list", insn.pos);
     }
+    if insn.operands[0] is FinalRegister {
+        return vc.invalidErr("invalid register kind final for ListSetInsn", insn.pos);
+    }
     t:SemType memberType = t:listMemberType(vc.typeContext(), insn.operands[0].semType, insn.operands[1].semType);
     return verifyOperandType(vc, insn.operands[2], memberType, "value assigned to member of list is not a subtype of array member type", insn.pos);
 }
@@ -251,6 +312,9 @@ function verifyMappingSet(VerifyContext vc, MappingSetInsn insn) returns Error?
     if !vc.isSubtype(insn.operands[0].semType, t:MAPPING) {
         return vc.semanticErr("mapping set applied to non-mapping", insn.pos);
     }
+    if insn.operands[0] is FinalRegister {
+        return vc.invalidErr("invalid register kind final for MappingSetInsn", insn.pos);
+    }
     t:SemType memberType = t:mappingMemberType(vc.typeContext(), insn.operands[0].semType, keyOperand.semType);
     return verifyOperandType(vc, insn.operands[2], memberType, "value assigned to member of mapping is not a subtype of map member type", insn.pos);
 }