binary tree llvm - consistent block termination and implicit returns

Author: yangdanny97

compiler/llvm_backend.py

@@ -20,7 +20,6 @@
 class LlvmBackend(Visitor):
     locals: List[defaultdict]
     externs: Dict[str, ir.Function]
-    constructors: Dict[str, ir.Function]
     methods: Dict[str, Dict[str, ir.Function]]
     structs: Dict[str, ir.LiteralStructType]
     # (class name, method name) -> idx in vtable, type
@@ -58,14 +57,16 @@ def initializeOffsets(self):
             self.methods[cls] = {}
             orderedMethods = self.ts.getOrderedMethods(cls)
             vtable = []
-            for idx, (methName, methType, _) in enumerate(orderedMethods):
+            for idx, (methName, methType, defCls) in enumerate(orderedMethods):
                 funcType = methType.getLLVMType()
                 self.methodOffsets[(cls, methName)] = (idx, funcType)
-                func = ir.Function(self.module, funcType,
-                                   cls + "__" + methName)
+                if defCls == cls:
+                    func = ir.Function(self.module, funcType,
+                                       cls + "__" + methName)
+                    self.methods[cls][methName] = func
+            for methName, _, defCls in orderedMethods:
+                func = self.methods[defCls][methName]
                 self.methods[cls][methName] = func
-            for methName, _, _ in orderedMethods:
-                func = self.methods[cls][methName]
                 vtable.append(func)
             t = self.getClassVtableType(cls)
             self.global_constant('__' + cls + '__vtable',
@@ -220,8 +221,8 @@ def Program(self, node: Program):
         self.visitStmtList(node.statements)
 
         self.builder.branch(end_program)
-        program_block = self.builder.block
         self.builder.position_at_start(end_program)
+        assert not end_program.is_terminated
         self.builder.ret_void()
         self.exitScope()
 
@@ -255,13 +256,14 @@ def declareFunc(self, node: FuncDef):
         ir.Function(self.module, funcType, funcname)
 
     def FuncDef(self, node: FuncDef):
+        fname = node.getIdentifier().name
         if node.isMethod:
             func = self.module.get_global(
-                self.currentClass + "__" + node.getIdentifier().name)
+                self.currentClass + "__" + fname)
         else:
-            func = self.module.get_global(node.getIdentifier().name)
+            func = self.module.get_global(fname)
         self.returnType = node.type.returnType
-        shouldReturnValue = not self.returnType.isNone()
+        implicitReturn = self.returnType not in {IntType(), BoolType(), StrType(), NoneType()}
         self.enterScope()
         bb_entry = func.append_basic_block('entry')
         self.builder = ir.IRBuilder(bb_entry)
@@ -274,12 +276,14 @@ def FuncDef(self, node: FuncDef):
         for d in node.declarations:
             self.visit(d)
         self.visitStmtList(node.statements)
-        # implicitly return None if possible
-        if shouldReturnValue is not None and (
-            len(node.statements) == 0 or
-            not isinstance(node.statements[-1], ReturnStmt)
-        ):
-            self.builder.ret(self.NoneLiteral(None))
+        # implicitly return None if needed, close all blocks
+        for block in func.blocks:
+            self.builder.position_at_end(block)
+            if not block.is_terminated:
+                if implicitReturn:
+                    self.builder.ret(self.NoneLiteral(None))
+                else:
+                    self.builder.unreachable()
         self.exitScope()
         return func
 
@@ -536,10 +540,13 @@ def visitArg(self, funcType: FuncType, paramIdx: int, arg: Expr):
             # unwrap if necessary, re-wrap
             saved_block = self.builder.block
             val = self.visit(arg)
+            # print(val)
             addr = self.builder.alloca(
-                node.var.t.getLLVMType())
+                arg.inferredType.getLLVMType())
+            # print(addr)
             wrapper = self.builder.alloca(
-                node.var.t.getLLVMType().as_pointer(), None, "wrapper")
+                arg.inferredType.getLLVMType().as_pointer(), None, "wrapper")
+            # print(wrapper)
             self.builder.position_at_end(saved_block)
             self.builder.store(val, addr)
             self.builder.store(addr, wrapper)
@@ -659,6 +666,7 @@ def whileHelper(self, condFn, bodyFn):
         self.builder.position_at_start(end_block)
 
     def ReturnStmt(self, node: ReturnStmt):
+        assert not self.builder.block.is_terminated
         if self.returnType.isNone():
             self.builder.ret(self.NoneLiteral(None))
         else:
@@ -713,14 +721,14 @@ def ifHelper(self, condFn, thenFn, elseFn=None, returnType=None):
 
         self.builder.position_at_start(then_block)
         then_val = thenFn()
-        if not self.builder.block.is_terminated:
+        if not then_block.is_terminated:
             self.builder.branch(merge_block)
         then_block = self.builder.block
 
         if elseFn is not None:
             self.builder.position_at_start(else_block)
             else_val = elseFn()
-            if not self.builder.block.is_terminated:
+            if not else_block.is_terminated:
                 self.builder.branch(merge_block)
             else_block = self.builder.block
 
@@ -749,7 +757,8 @@ def MethodCallExpr(self, node: MethodCallExpr):
 
         call_args = [self.builder.bitcast(obj, voidptr_t)]
         for i in range(len(node.args)):
-            call_args.append(self.visitArg(node.method.inferredType, i, node.args[i]))
+            call_args.append(self.visitArg(
+                node.method.inferredType, i, node.args[i]))
         return self.builder.call(callee_func, call_args, 'callmethodtmp')
 
     # LITERALS

foobar.py

@@ -1,59 +1,87 @@
-class A:
-    y: int = 1
-
-    def __init__(self: A):
-        pass
-
-    def t(self: A):
-        global x
-        x = 1
-
-
-class B(A):
-    z: int = 0
-
-    def __init__(self: B):
-        self.z = 5
-        self.y = 5
-
-    def t(self: B):
-        global x
-        x = 2
-
-    def setZ(self: B, z: int):
-        self.z = z
-
-
-x: int = 0
-c1: A = None
-c2: B = None
-c3: A = None
-
-# constructors, getters, setters
-c1 = A()
-assert c1.y == 1
-c2 = B()
-assert c2.y == 5
-assert c2.z == 5
-c3 = B()
-assert c3.y == 5
-
-c2.y = 0
-assert c2.y == 0
-
-# methods, dynamic dispatch
-
-c2.setZ(2)
-assert c2.z == 2
-
-x = 0
-c1.t()
-assert x == 1
-
-x = 0
-c2.t()
-assert x == 2
-
-x = 0
-c3.t()
-assert x == 2
+# Binary-search trees
+class TreeNode(object):
+    value: int = 0
+    left: "TreeNode" = None
+    right: "TreeNode" = None
+
+    def insert(self: "TreeNode", x: int) -> bool:
+        if x < self.value:
+            if self.left is None:
+                self.left = makeNode(x)
+                return True
+            else:
+                return self.left.insert(x)
+        elif x > self.value:
+            if self.right is None:
+                self.right = makeNode(x)
+                return True
+            else:
+                return self.right.insert(x)
+        return False
+
+    def contains(self: "TreeNode", x: int) -> bool:
+        if x < self.value:
+            if self.left is None:
+                return False
+            else:
+                return self.left.contains(x)
+        elif x > self.value:
+            if self.right is None:
+                return False
+            else:
+                return self.right.contains(x)
+        else:
+            return True
+
+
+class Tree(object):
+    root: TreeNode = None
+    size: int = 0
+
+    def insert(self: "Tree", x: int) -> object:
+        if self.root is None:
+            self.root = makeNode(x)
+            self.size = 1
+        else:
+            if self.root.insert(x):
+                self.size = self.size + 1
+
+    def contains(self: "Tree", x: int) -> bool:
+        if self.root is None:
+            return False
+        else:
+            return self.root.contains(x)
+
+
+def makeNode(x: int) -> TreeNode:
+    b: TreeNode = None
+    b = TreeNode()
+    b.value = x
+    return b
+
+
+# Input parameters
+n: int = 100
+c: int = 4
+
+# Data
+t: Tree = None
+i: int = 0
+k: int = 37813
+
+# Crunch
+t = Tree()
+while i < n:
+    t.insert(k)
+    k = (k * 37813) % 37831
+    if i % c != 0:
+        t.insert(i)
+    i = i + 1
+
+assert t.size == 175
+assert t.contains(15)
+assert t.contains(23)
+assert t.contains(42)
+assert not t.contains(4)
+assert not t.contains(8)
+assert not t.contains(16)

test.py

@@ -17,10 +17,7 @@
 
 
 disabled_llvm_tests = [
-    "/binary_tree.",
-    "/doubling_vector.",
     "/nonlocal.",
-    "/exponent."
 ]
 
 disabled_jvm_tests = []
@@ -41,15 +38,15 @@ def should_skip(disabled_tests: List[str], test: Path) -> bool:
 
 
 def run_all_tests():
-    run_parse_tests()
-    run_typecheck_tests()
-    run_python_backend_tests()
-    run_closure_tests()
-    run_jvm_tests()
-    run_cil_tests()
-    run_wasm_tests()
-    run_llvm_tests()
-    # test_eval_llvm()
+    # run_parse_tests()
+    # run_typecheck_tests()
+    # run_python_backend_tests()
+    # run_closure_tests()
+    # run_jvm_tests()
+    # run_cil_tests()
+    # run_wasm_tests()
+    # run_llvm_tests()
+    test_eval_llvm()
 
 
 def run_parse_tests():
@@ -647,7 +644,7 @@ def eval_llvm(module):
 
 
 def test_eval_llvm():
-    run_llvm_test("foobar.py", True)
+    run_llvm_test("foobar.py", "foobar.ll")
 
 
 def run_llvm_test(test, debug):
@@ -665,8 +662,8 @@ def run_llvm_test(test, debug):
             assert len(compiler.typechecker.errors) == 0
         module = compiler.emitLLVM(chocopy_ast)
         if debug:
-            print("Module output:")
-            print(str(module))
+            with open(debug, "w") as f:
+                f.write(str(module))
         eval_llvm(module)
         return True
     except Exception as e: