m-labs · Aug 27, 2015 · Aug 27, 2015 · Aug 27, 2015 · Aug 27, 2015
Showing with 38 additions and 14 deletions.

+28 −5 artiq/compiler/embedding.py

+3 −2 artiq/compiler/transforms/llvm_ir_generator.py

+7 −7 artiq/compiler/types.py
diff --git a/artiq/compiler/embedding.py b/artiq/compiler/embedding.py
@@ -8,7 +8,7 @@
 import os, re, linecache, inspect, textwrap
 from collections import OrderedDict, defaultdict
 
-from pythonparser import ast, source, diagnostic, parse_buffer
+from pythonparser import ast, algorithm, source, diagnostic, parse_buffer
 
 from . import types, builtins, asttyped, prelude
 from .transforms import ASTTypedRewriter, Inferencer, IntMonomorphizer
@@ -101,6 +101,7 @@ def quote(self, value):
 
                 constructor_type = types.TConstructor(instance_type)
                 constructor_type.attributes['__objectid__'] = builtins.TInt(types.TValue(32))
+                instance_type.constructor = constructor_type
 
                 self.type_map[typ] = instance_type, constructor_type
 
@@ -253,6 +254,24 @@ def proxy_diagnostic(diag):
 
         super().visit_AttributeT(node)
 
+class TypedtreeHasher(algorithm.Visitor):
+    def generic_visit(self, node):
+        def freeze(obj):
+            if isinstance(obj, ast.AST):
+                return self.visit(obj)
+            elif isinstance(obj, types.Type):
+                return hash(obj.find())
+            elif isinstance(obj, list):
+                return tuple(obj)
+            else:
+                assert obj is None or isinstance(obj, (bool, int, float, str))
+                return obj
+
+        fields = node._fields
+        if hasattr(node, '_types'):
+            fields = fields + node._types
+        return hash(tuple(freeze(getattr(node, field_name)) for field_name in fields))
+
 class Stitcher:
     def __init__(self, engine=None):
         if engine is None:
@@ -275,12 +294,17 @@ def finalize(self):
         inferencer = StitchingInferencer(engine=self.engine,
                                          value_map=self.value_map,
                                          quote=self._quote)
+        hasher = TypedtreeHasher()
 
         # Iterate inference to fixed point.
-        self.inference_finished = False
-        while not self.inference_finished:
-            self.inference_finished = True
+        old_typedtree_hash = None
+        while True:
             inferencer.visit(self.typedtree)
+            typedtree_hash = hasher.visit(self.typedtree)
+
+            if old_typedtree_hash == typedtree_hash:
+                break
+            old_typedtree_hash = typedtree_hash
 
         # After we have found all functions, synthesize a module to hold them.
         source_buffer = source.Buffer("", "<synthesized>")
@@ -488,7 +512,6 @@ def _quote_function(self, function, loc):
                 # the final call.
                 function_node = self._quote_embedded_function(function)
                 self.typedtree.insert(0, function_node)
-                self.inference_finished = False
                 return function_node.name
             elif function.artiq_embedded.syscall is not None:
                 # Insert a storage-less global whose type instructs the compiler

diff --git a/artiq/compiler/transforms/llvm_ir_generator.py b/artiq/compiler/transforms/llvm_ir_generator.py
@@ -270,6 +270,9 @@ def llty_of_type(self, typ, bare=False, for_return=False):
 
             llty = self.llcontext.get_identified_type(name)
             if llty.elements is None:
+                # First setting elements to [] will allow us to handle
+                # self-referential types.
+                llty.elements = []
                 llty.elements = [self.llty_of_type(attrtyp)
                                  for attrtyp in typ.attributes.values()]
 
@@ -942,8 +945,6 @@ def process_Call(self, insn):
                 llstackptr = self.llbuilder.call(self.llbuiltin("llvm.stacksave"), [])
 
                 llresultslot = self.llbuilder.alloca(llfun.type.pointee.args[0].pointee)
-                print(llfun)
-                print(llresultslot)
                 self.llbuilder.call(llfun, [llresultslot] + llargs)
                 llresult = self.llbuilder.load(llresultslot)
 

diff --git a/artiq/compiler/types.py b/artiq/compiler/types.py
@@ -78,7 +78,7 @@ def fold(self, accum, fn):
 
     def __repr__(self):
         if self.parent is self:
-            return "<py2llvm.types.TVar %d>" % id(self)
+            return "<artiq.compiler.types.TVar %d>" % id(self)
         else:
             return repr(self.find())
 
@@ -121,7 +121,7 @@ def fold(self, accum, fn):
         return fn(accum, self)
 
     def __repr__(self):
-        return "py2llvm.types.TMono(%s, %s)" % (repr(self.name), repr(self.params))
+        return "artiq.compiler.types.TMono(%s, %s)" % (repr(self.name), repr(self.params))
 
     def __getitem__(self, param):
         return self.params[param]
@@ -167,7 +167,7 @@ def fold(self, accum, fn):
         return fn(accum, self)
 
     def __repr__(self):
-        return "py2llvm.types.TTuple(%s)" % repr(self.elts)
+        return "artiq.compiler.types.TTuple(%s)" % repr(self.elts)
 
     def __eq__(self, other):
         return isinstance(other, TTuple) and \
@@ -231,7 +231,7 @@ def fold(self, accum, fn):
         return fn(accum, self)
 
     def __repr__(self):
-        return "py2llvm.types.TFunction({}, {}, {})".format(
+        return "artiq.compiler.types.TFunction({}, {}, {})".format(
             repr(self.args), repr(self.optargs), repr(self.ret))
 
     def __eq__(self, other):
@@ -311,7 +311,7 @@ def fold(self, accum, fn):
         return fn(accum, self)
 
     def __repr__(self):
-        return "py2llvm.types.{}({})".format(type(self).__name__, repr(self.name))
+        return "artiq.compiler.types.{}({})".format(type(self).__name__, repr(self.name))
 
     def __eq__(self, other):
         return isinstance(other, TBuiltin) and \
@@ -364,7 +364,7 @@ def __init__(self, name, attributes=OrderedDict()):
         self.attributes = attributes
 
     def __repr__(self):
-        return "py2llvm.types.TInstance({}, {})".format(
+        return "artiq.compiler.types.TInstance({}, {})".format(
                     repr(self.name), repr(self.attributes))
 
 class TMethod(TMono):
@@ -401,7 +401,7 @@ def fold(self, accum, fn):
         return fn(accum, self)
 
     def __repr__(self):
-        return "py2llvm.types.TValue(%s)" % repr(self.value)
+        return "artiq.compiler.types.TValue(%s)" % repr(self.value)
 
     def __eq__(self, other):
         return isinstance(other, TValue) and \