m-labs · Apr 2, 2016 · Apr 2, 2016 · Apr 2, 2016 · Apr 2, 2016 · Apr 2, 2016
diff --git a/artiq/compiler/ir.py b/artiq/compiler/ir.py
@@ -425,6 +425,8 @@ class Function:
         the module it is contained in
     :ivar is_cold:
         (bool) if True, the function should be considered rarely called
+    :ivar is_generated:
+        (bool) if True, the function will not appear in backtraces
     :ivar flags: (set of str) Code generation flags.
         Flag ``fast-math`` is the equivalent of gcc's ``-ffast-math``.
     """
@@ -436,6 +438,7 @@ def __init__(self, typ, name, arguments, loc=None):
         self.set_arguments(arguments)
         self.is_internal = False
         self.is_cold = False
+        self.is_generated = False
         self.flags = {}
 
     def _remove_name(self, name):

diff --git a/artiq/compiler/transforms/artiq_ir_generator.py b/artiq/compiler/transforms/artiq_ir_generator.py
@@ -944,6 +944,7 @@ def _make_check(self, cond, exn_gen, loc=None, params=[]):
             func = ir.Function(typ, ".".join(self.name + [name]), args, loc=loc)
             func.is_internal = True
             func.is_cold = True
+            func.is_generated = True
             self.functions.append(func)
             old_func, self.current_function = self.current_function, func
 

diff --git a/artiq/compiler/transforms/llvm_ir_generator.py b/artiq/compiler/transforms/llvm_ir_generator.py
@@ -42,126 +42,89 @@ def memoized(self, *args):
 class DebugInfoEmitter:
     def __init__(self, llmodule):
         self.llmodule = llmodule
+        self.llsubprograms = []
         self.cache = {}
-        self.subprograms = []
 
-    def emit(self, operands):
+    def emit_metadata(self, operands):
         def map_operand(operand):
             if operand is None:
                 return ll.Constant(llmetadata, None)
             elif isinstance(operand, str):
                 return ll.MetaDataString(self.llmodule, operand)
-            elif isinstance(operand, bool):
-                return ll.Constant(lli1, operand)
             elif isinstance(operand, int):
                 return ll.Constant(lli32, operand)
             elif isinstance(operand, (list, tuple)):
-                return self.emit(operand)
-            elif isinstance(operand, ll.Value):
-                return operand
+                return self.emit_metadata(operand)
             else:
-                print(operand)
-                assert False
+                assert isinstance(operand, ll.NamedValue)
+                return operand
         return self.llmodule.add_metadata(list(map(map_operand, operands)))
 
+    def emit_debug_info(self, kind, operands, is_distinct=False):
+        return self.llmodule.add_debug_info(kind, operands, is_distinct)
+
     @memoize
-    def emit_filename(self, source_buffer):
+    def emit_file(self, source_buffer):
         source_dir, source_file = os.path.split(source_buffer.name)
-        return self.emit([source_file, source_dir])
+        return self.emit_debug_info("DIFile", {
+            "filename":        source_file,
+            "directory":       source_dir,
+        })
 
     @memoize
     def emit_compile_unit(self, source_buffer, llsubprograms):
-        return self.emit([
-            DW_TAG_compile_unit,
-            self.emit_filename(source_buffer),    # filename
-            DW_LANG_Python,                       # source language
-            "ARTIQ",                              # producer
-            False,                                # optimized?
-            "",                                   # linker flags
-            0,                                    # runtime version
-            [],                                   # enum types
-            [],                                   # retained types
-            llsubprograms,                        # subprograms
-            [],                                   # global variables
-            [],                                   # imported entities
-            "",                                   # split debug filename
-            2,                                    # kind (full=1, lines only=2)
-        ])
-
-    @memoize
-    def emit_file(self, source_buffer):
-        return self.emit([
-            DW_TAG_file_type,
-            self.emit_filename(source_buffer),    # filename
-        ])
+        return self.emit_debug_info("DICompileUnit", {
+            "language":        ll.DIToken("DW_LANG_C99"),
+            "file":            self.emit_file(source_buffer),
+            "producer":        "ARTIQ",
+            "runtimeVersion":  0,
+            "emissionKind":    2, # full=1, lines only=2
+            "subprograms":     self.emit_metadata(llsubprograms)
+        }, is_distinct=True)
 
     @memoize
     def emit_subroutine_type(self, typ):
-        return self.emit([
-            DW_TAG_subroutine_type,
-            None,                                 # filename
-            None,                                 # context descriptor
-            "",                                   # name
-            0,                                    # line number
-            0,                                    # (i64) size in bits
-            0,                                    # (i64) alignment in bits
-            0,                                    # (i64) offset in bits
-            0,                                    # flags
-            None,                                 # derived from
-            [None],                               # members
-            0,                                    # runtime languages
-            None,                                 # base type with vtable pointer
-            None,                                 # template parameters
-            None                                  # unique identifier
-        ])
+        return self.emit_debug_info("DISubroutineType", {
+            "types":           self.emit_metadata([None])
+        })
 
     @memoize
     def emit_subprogram(self, func, llfunc):
         source_buffer = func.loc.source_buffer
         display_name = "{}{}".format(func.name, types.TypePrinter().name(func.type))
-        subprogram = self.emit([
-            DW_TAG_subprogram,
-            self.emit_filename(source_buffer),    # filename
-            self.emit_file(source_buffer),        # context descriptor
-            func.name,                            # name
-            display_name,                         # display name
-            llfunc.name,                          # linkage name
-            func.loc.line(),                      # line number where defined
-            self.emit_subroutine_type(func.type), # type descriptor
-            func.is_internal,                     # local to compile unit?
-            True,                                 # global is defined in the compile unit?
-            0,                                    # virtuality
-            0,                                    # index into a virtual function
-            None,                                 # base type with vtable pointer
-            0,                                    # flags
-            False,                                # optimized?
-            llfunc,                               # LLVM function
-            None,                                 # template parameters
-            None,                                 # function declaration descriptor
-            [],                                   # function variables
-            func.loc.line(),                      # line number where scope begins
-        ])
-        self.subprograms.append(subprogram)
-        return subprogram
+        llsubprogram = self.emit_debug_info("DISubprogram", {
+            "name":            func.name,
+            "linkageName":     llfunc.name,
+            "type":            self.emit_subroutine_type(func.type),
+            "file":            self.emit_file(source_buffer),
+            "line":            func.loc.line(),
+            "scope":           self.emit_file(source_buffer),
+            "scopeLine":       func.loc.line(),
+            "isLocal":         func.is_internal,
+            "isDefinition":    True,
+            "variables":       self.emit_metadata([])
+        }, is_distinct=True)
+        self.llsubprograms.append(llsubprogram)
+        return llsubprogram
 
     @memoize
-    def emit_loc(self, loc, scope, inlined_scope=None):
-        return self.emit([
-            loc.line(),                           # line
-            loc.column(),                         # column
-            scope,                                # scope
-            inlined_scope,                        # inlined scope
-        ])
+    def emit_loc(self, loc, scope):
+        return self.emit_debug_info("DILocation", {
+            "line":            loc.line(),
+            "column":          loc.column(),
+            "scope":           scope
+        })
 
     def finalize(self, source_buffer):
         llident = self.llmodule.add_named_metadata('llvm.ident')
-        llident.add(self.emit(["ARTIQ"]))
+        llident.add(self.emit_metadata(["ARTIQ"]))
 
         llflags = self.llmodule.add_named_metadata('llvm.module.flags')
-        llflags.add(self.emit([2, "Debug Info Version", 1]))
+        llflags.add(self.emit_metadata([2, "Debug Info Version", 3]))
+        llflags.add(self.emit_metadata([2, "Dwarf Version", 4]))
 
         llcompile_units = self.llmodule.add_named_metadata('llvm.dbg.cu')
-        llcompile_units.add(self.emit_compile_unit(source_buffer, tuple(self.subprograms)))
+        llcompile_units.add(self.emit_compile_unit(source_buffer, tuple(self.llsubprograms)))
 
 
 class LLVMIRGenerator:
@@ -191,6 +154,10 @@ def __init__(self, engine, module_name, target, function_map, object_map, type_m
             self.tbaa_tree,
             ll.Constant(lli64, 1)
         ])
+        self.tbaa_now = self.llmodule.add_metadata([
+            ll.MetaDataString(self.llmodule, "timeline position"),
+            self.tbaa_tree
+        ])
 
     def needs_sret(self, lltyp, may_be_large=True):
         if isinstance(lltyp, ll.VoidType):
@@ -577,7 +544,9 @@ def process_function(self, func):
             self.llbuilder = ll.IRBuilder()
             llblock_map = {}
 
-            disubprogram = self.debug_info_emitter.emit_subprogram(func, self.llfunction)
+            if not func.is_generated:
+                lldisubprogram = self.debug_info_emitter.emit_subprogram(func, self.llfunction)
+                self.llfunction.set_metadata('dbg', lldisubprogram)
 
             # First, map arguments.
             if self.has_sret(func.type):
@@ -598,9 +567,9 @@ def process_function(self, func):
             for block in func.basic_blocks:
                 self.llbuilder.position_at_end(self.llmap[block])
                 for insn in block.instructions:
-                    if insn.loc is not None:
+                    if insn.loc is not None and not func.is_generated:
                         self.llbuilder.debug_metadata = \
-                            self.debug_info_emitter.emit_loc(insn.loc, disubprogram)
+                            self.debug_info_emitter.emit_loc(insn.loc, lldisubprogram)
 
                     llinsn = getattr(self, "process_" + type(insn).__name__)(insn)
                     assert llinsn is not None
@@ -683,15 +652,15 @@ def llptr_to_var(self, llenv, env_ty, var_name, var_type=None):
             llptr = self.llbuilder.gep(llenv, [self.llindex(0), self.llindex(outer_index)],
                                        inbounds=True)
             llouterenv = self.llbuilder.load(llptr)
-            llouterenv.metadata['invariant.load'] = self.empty_metadata
-            llouterenv.metadata['nonnull'] = self.empty_metadata
+            llouterenv.set_metadata('invariant.load', self.empty_metadata)
+            llouterenv.set_metadata('nonnull', self.empty_metadata)
             return self.llptr_to_var(llouterenv, env_ty.params["$outer"], var_name)
 
     def mark_dereferenceable(self, load):
         assert isinstance(load, ll.LoadInstr) and isinstance(load.type, ll.PointerType)
         pointee_size = load.type.pointee.get_abi_size(self.lldatalayout, context=self.llcontext)
         metadata = self.llmodule.add_metadata([ll.Constant(lli64, pointee_size)])
-        load.metadata['dereferenceable'] = metadata
+        load.set_metadata('dereferenceable', metadata)
 
     def process_GetLocal(self, insn):
         env = insn.environment()
@@ -821,7 +790,7 @@ def process_GetAttr(self, insn):
                                            inbounds=True, name="ptr.{}".format(insn.name))
                 llvalue = self.llbuilder.load(llptr, name="val.{}".format(insn.name))
                 if types.is_instance(typ) and attr in typ.constant_attributes:
-                    llvalue.metadata['invariant.load'] = self.empty_metadata
+                    llvalue.set_metadata('invariant.load', self.empty_metadata)
                 if isinstance(llvalue.type, ll.PointerType):
                     self.mark_dereferenceable(llvalue)
                 return llvalue
@@ -1065,8 +1034,8 @@ def get_outer(llenv, env_ty):
                     llptr = self.llbuilder.gep(llenv, [self.llindex(0), self.llindex(outer_index)],
                                                inbounds=True)
                     llouterenv = self.llbuilder.load(llptr)
-                    llouterenv.metadata['invariant.load'] = self.empty_metadata
-                    llouterenv.metadata['nonnull'] = self.empty_metadata
+                    llouterenv.set_metadata('invariant.load', self.empty_metadata)
+                    llouterenv.set_metadata('nonnull', self.empty_metadata)
                     return self.llptr_to_var(llouterenv, env_ty.params["$outer"], var_name)
                 else:
                     return llenv
@@ -1086,16 +1055,21 @@ def get_outer(llenv, env_ty):
             # This is an identity cast at LLVM IR level.
             return self.map(insn.operands[0])
         elif insn.op == "now_mu":
-            return self.llbuilder.load(self.llbuiltin("now"), name=insn.name)
+            llnow = self.llbuilder.load(self.llbuiltin("now"), name=insn.name)
+            llnow.set_metadata("tbaa", self.tbaa_now)
+            return llnow
         elif insn.op == "at_mu":
             time, = insn.operands
             return self.llbuilder.store(self.map(time), self.llbuiltin("now"))
         elif insn.op == "delay_mu":
             interval, = insn.operands
             llnowptr = self.llbuiltin("now")
             llnow = self.llbuilder.load(llnowptr, name="now.old")
+            llnow.set_metadata("tbaa", self.tbaa_now)
             lladjusted = self.llbuilder.add(llnow, self.map(interval), name="now.new")
-            return self.llbuilder.store(lladjusted, llnowptr)
+            llnowstore = self.llbuilder.store(lladjusted, llnowptr)
+            llnowstore.set_metadata("tbaa", self.tbaa_now)
+            return llnowstore
         elif insn.op == "watchdog_set":
             interval, = insn.operands
             return self.llbuilder.call(self.llbuiltin("watchdog_set"), [self.map(interval)])
@@ -1325,7 +1299,7 @@ def process_Call(self, insn):
             # Never add TBAA nowrite metadata to a functon with sret!
             # This leads to miscompilations.
             if types.is_c_function(functiontyp) and 'nowrite' in functiontyp.flags:
-                llcall.metadata['tbaa'] = self.tbaa_nowrite_call
+                llcall.set_metadata('tbaa', self.tbaa_nowrite_call)
 
         return llresult
 
@@ -1358,7 +1332,7 @@ def process_Invoke(self, insn):
 
             # See the comment in process_Call.
             if types.is_c_function(functiontyp) and 'nowrite' in functiontyp.flags:
-                llcall.metadata['tbaa'] = self.tbaa_nowrite_call
+                llcall.set_metadata('tbaa', self.tbaa_nowrite_call)
 
         return llcall
 

diff --git a/artiq/coredevice/exceptions.py b/artiq/coredevice/exceptions.py
@@ -38,7 +38,7 @@ def __str__(self):
             elif address == last_address:
                 formatted_address = " (inlined)"
             else:
-                formatted_address = " (RA=0x{:x})".format(address)
+                formatted_address = " (RA=+0x{:x})".format(address)
             last_address = address
 
             filename = filename.replace(artiq_dir, "<artiq>")

diff --git a/artiq/coredevice/ttl.py b/artiq/coredevice/ttl.py
@@ -10,6 +10,8 @@ class TTLOut:
 
     :param channel: channel number
     """
+    kernel_constant_attributes = {"core", "channel"}
+
     def __init__(self, dmgr, channel, core_device="core"):
         self.core = dmgr.get(core_device)
         self.channel = channel
@@ -82,6 +84,8 @@ class TTLInOut:
 
     :param channel: channel number
     """
+    kernel_constant_attributes = {"core", "channel"}
+
     def __init__(self, dmgr, channel, core_device="core"):
         self.core = dmgr.get(core_device)
         self.channel = channel
@@ -232,6 +236,8 @@ class TTLClockGen:
 
     :param channel: channel number
     """
+    kernel_constant_attributes = {"core", "channel", "acc_width"}
+
     def __init__(self, dmgr, channel, core_device="core"):
         self.core = dmgr.get(core_device)
         self.channel = channel

diff --git a/conda/artiq/meta.yaml b/conda/artiq/meta.yaml
@@ -37,7 +37,7 @@ requirements:
     - binutils-or1k-linux
   run:
     - python >=3.5.1
-    - llvmlite-artiq 0.10.0.dev py35_21
+    - llvmlite-artiq 0.10.0.dev py35_22
     - scipy
     - numpy
     - prettytable