Address bugs due to lack of linemark generation

Port `Statement.toc()` family rework from RAII PR

Don't DML linemark code injected by memoized methods

Suppress redundant line directive generation

Author: lwaern-intel

py/dml/c_backend.py

@@ -746,10 +746,9 @@ def wrap_method(meth, wrapper_name, indices=()):
         indices = tuple(mkIntegerLiteral(meth.site, i) for i in indices)
     with crep.DeviceInstanceContext():
         if retvar:
-            decl = mkDeclaration(meth.site, retvar, rettype,
-                                 init = get_initializer(meth.site, rettype,
-                                                        None, None, None))
-            decl.toc()
+            mkDeclaration(meth.site, retvar, rettype,
+                          init = get_initializer(meth.site, rettype,
+                                                 None, None, None)).toc()
 
         with LogFailure(meth.site, meth, indices):
             inargs = [mkLit(meth.site, v, t) for v, t in meth.inp]
@@ -1341,7 +1340,6 @@ def generate_reg_callback(meth, name):
         + ', '.join(params) + ')\n')
     out('{\n', postindent = 1)
     out('%s *_dev = _obj;\n' % dev_t)
-    scope = Symtab(global_scope)
     fail = ReturnFailure(meth.site)
     with fail, crep.DeviceInstanceContext():
         inargs = [mkLit(meth.site, n, t) for n, t in meth.inp]
@@ -1352,8 +1350,7 @@ def generate_reg_callback(meth, name):
                       for i in range(meth.dimensions)),
                 inargs, outargs)]
 
-    code = mkCompound(meth.site, declarations(scope) + code + [fail.nofail()])
-    code.toc()
+    mkCompound(meth.site, code + [fail.nofail()]).toc_inline()
     out('}\n', preindent = -1)
     out('\n')
 
@@ -1618,8 +1615,7 @@ def generate_finalize(device):
         else:
             code = codegen_inline_byname(device, (), '_post_init', [], [],
                                      device.site)
-    if not code.is_empty:
-        code.toc()
+    code.toc_inline()
     out('}\n\n', preindent = -1)
 
 def generate_deinit(device):
@@ -1665,8 +1661,7 @@ def generate_deinit(device):
                 device.get_component('destroy', 'method').site, device, ()):
             code = codegen_inline_byname(device, (), 'destroy', [], [],
                                          device.site)
-        if not code.is_empty:
-            code.toc()
+        code.toc()
 
         # Cancel all pending afters on hooks
         by_dims = {}
@@ -1712,14 +1707,12 @@ def generate_reset(device, hardness):
     out('{\n', postindent = 1)
     out(crep.structtype(device) + ' *_dev UNUSED = ('
         + crep.structtype(device) + ' *)_obj;\n\n')
-    scope = Symtab(global_scope)
     method_name = hardness + '_reset'
     method = device.get_component(method_name, 'method')
     with LogFailure(method.site, device, ()), crep.DeviceInstanceContext():
         code = codegen_call_byname(method.site, device, (),
                                    method_name, [], [])
-    code = mkCompound(method.site, declarations(scope) + [code])
-    code.toc()
+    code.toc_inline()
     out('}\n\n', preindent = -1)
 
 # {(B, C): A} means that a static array 'const uint32 _indices_B_C[A][B][C][3]'
@@ -2039,14 +2032,6 @@ def generate_extern_trampoline_dml12(exported_name, func):
                          ", ".join(n for (n, t) in func.cparams)))
     out("}\n", preindent=-1)
 
-def som_linemark(site):
-    if dml.globals.linemarks:
-        out('#line %d "%s"\n' % (site.lineno, quote_filename(site.filename())))
-
-def eom_linemark(site):
-    if dml.globals.linemarks:
-        out('#line %d "%s"\n' % (site.lineno, quote_filename(site.filename())))
-
 def generate_each_in_table(trait, instances):
     items = []
     for (node, subnodes) in instances:
@@ -2167,9 +2152,12 @@ def generate_trait_method(m):
     code = m.codegen_body()
     out('/* %s */\n' % (str(m),))
     start_function_definition(m.declaration())
-    out('{\n', postindent=1)
-    code.toc_inline()
-    out('}\n', preindent=-1)
+    with allow_linemarks():
+        site_linemark(m.site)
+        out('{\n', postindent=1)
+        code.toc_inline()
+        site_linemark(m.rbrace_site)
+        out('}\n', preindent=-1)
 
 def generate_adjustor_thunk(traitname, name, inp, outp, throws, independent,
                             vtable_path, def_path, hardcoded_impl=None):
@@ -3337,15 +3325,15 @@ def generate_cfile_body(device, footers, full_module, filename_prefix):
 
     for t in list(dml.globals.traits.values()):
         for m in list(t.method_impls.values()):
-            with allow_linemarks():
-                if gather_size_statistics:
-                    ctx = StrOutput()
-                    with ctx:
-                        generate_trait_method(m)
-                    size_statistics[m.site.loc()] = [len(ctx.buf)]
-                    out(ctx.buf)
-                else:
+            if gather_size_statistics:
+                ctx = StrOutput(filename=output.current().filename,
+                                lineno=output.current().lineno)
+                with ctx:
                     generate_trait_method(m)
+                size_statistics[m.site.loc()] = [len(ctx.buf)]
+                out(ctx.buf)
+            else:
+                generate_trait_method(m)
     # Note: methods may be added to method_queue while doing this,
     # so don't try to be too smart
     generated_funcs = set()
@@ -3360,23 +3348,24 @@ def generate_cfile_body(device, footers, full_module, filename_prefix):
                            for (n, v) in func.inp
                            if isinstance(v, Expression)]
 
-        with allow_linemarks():
-            if gather_size_statistics:
-                ctx = StrOutput()
+        if gather_size_statistics:
+            ctx = StrOutput(lineno=output.current().lineno,
+                            filename=output.current().filename)
+        else:
+            ctx = nullcontext()
+        with ErrorContext(func.method), ctx:
+            if specializations:
+                out('/* %s\n' % func.get_name())
+                for (n, v) in specializations:
+                    out('     %s = %s\n' % (n, v))
+                out('*/\n')
             else:
-                ctx = nullcontext()
-            with ErrorContext(func.method), ctx:
-                if specializations:
-                    out('/* %s\n' % func.get_name())
-                    for (n, v) in specializations:
-                        out('     %s = %s\n' % (n, v))
-                    out('*/\n')
-                else:
-                    out('/* %s */\n' % func.get_name())
+                out('/* %s */\n' % func.get_name())
 
-                start_function_definition(func.prototype)
-                som_linemark(func.method.astcode.site)
-                out('{\n', postindent = 1)
+            start_function_definition(func.prototype)
+            with allow_linemarks():
+                site_linemark(func.method.astcode.site)
+                out('{\n', postindent=1)
                 try:
                     code.toc_inline()
                 except DMLError as e:
@@ -3385,12 +3374,13 @@ def generate_cfile_body(device, footers, full_module, filename_prefix):
                     # codegen_method, when all Expression and Statement
                     # objects are instantiated.
                     raise ICE(e.site, 'error during late compile stage')
-                eom_linemark(func.method.rbrace_site)
-                out('}\n\n', preindent = -1)
-            if gather_size_statistics:
-                size_statistics.setdefault(func.method.site.loc(), []).append(
-                    len(ctx.buf))
-                out(ctx.buf)
+                site_linemark(func.method.rbrace_site)
+                out('}\n', preindent=-1)
+            out('\n')
+        if gather_size_statistics:
+            size_statistics.setdefault(func.method.site.loc(), []).append(
+                len(ctx.buf))
+            out(ctx.buf)
         splitting_point()
 
 

py/dml/codegen.py

@@ -19,7 +19,7 @@
 from .expr_util import *
 from .symtab import *
 from .messages import *
-from .output import out
+from .output import *
 from .types import *
 from .set import Set
 from .slotsmeta import auto_init
@@ -316,11 +316,13 @@ def __init__(self, func):
         assert func.method.independent
         self.func = func
         self.method = func.method
+        # SimpleSite wrapper to avoid linemarks being generated.
+        self.site = SimpleSite(self.method.site.loc())
 
     def make_ref(self, ref, typ):
         indexing = ''.join([f'[_idx{i}]'
                             for i in range(self.method.dimensions)])
-        return mkLit(self.method.site, f'_memo{indexing}.{ref}', typ)
+        return mkLit(self.site, f'_memo{indexing}.{ref}', typ)
 
     def prelude(self):
         struct_body = ''.join(
@@ -331,10 +333,10 @@ def prelude(self):
                     + [(f'p_{name}', typ) for (name, typ) in self.func.outp]))
         array_defs = ''.join([f'[{i}]' for i in self.method.dimsizes])
         struct_var_def = mkInline(
-            self.method.site,
+            self.site,
             f'static struct {{{struct_body}}} _memo{array_defs};')
         return [struct_var_def] + memoization_common_prelude(
-            self.method.logname_anonymized(), self.method.site, self.func.outp,
+            self.method.logname_anonymized(), self.site, self.func.outp,
             self.func.throws, self.make_ref)
     def exit_handler(self):
         return MemoizedReturnExit(self.method.site, self.func.outp,
@@ -347,16 +349,18 @@ class SharedIndependentMemoized(Memoization):
     def __init__(self, method):
         assert method.independent
         self.method = method
+        # SimpleSite wrapper to avoid linemarks being generated.
+        self.site = SimpleSite(self.method.site.loc())
     def make_ref(self, ref, typ):
         traitname = cident(self.method.trait.name)
-        return mkLit(self.method.site,
+        return mkLit(self.site,
                      f'((struct _{traitname} *) _{traitname}.trait)'
                      + f'->_memo_outs_{self.method.name}'
                      + f'[_{traitname}.id.encoded_index].{ref}', typ)
     def prelude(self):
         return memoization_common_prelude(
-            self.method.name, self.method.site, self.method.outp,
-            self.method.throws, self.make_ref)
+            self.method.name, self.site, self.method.outp, self.method.throws,
+            self.make_ref)
     def exit_handler(self):
         return MemoizedReturnExit(self.method.site, self.method.outp,
                                   self.method.throws, self.make_ref)
@@ -1925,7 +1929,7 @@ def codegen_statement(tree, *args):
 
 @statement_dispatcher
 def stmt_compound(stmt, location, scope):
-    [stmt_asts] = stmt.args
+    [stmt_asts, rbrace_site] = stmt.args
     if (logging.show_porting and stmt.site.dml_version() == (1, 2)
         and not stmt.site.filename().endswith('dml-builtins.dml')):
         method = location.method()
@@ -1942,7 +1946,8 @@ def stmt_compound(stmt, location, scope):
                                          ret.site))
     lscope = Symtab(scope)
     statements = codegen_statements(stmt_asts, location, lscope)
-    return [mkCompound(stmt.site, declarations(lscope) + statements)]
+    return [mkCompound(stmt.site, declarations(lscope) + statements,
+                       rbrace_site)]
 
 def check_shadowing(scope, name, site):
     if (dml.globals.dml_version == (1, 2)
@@ -2197,7 +2202,7 @@ def stmt_null(stmt, location, scope):
 
 @statement_dispatcher
 def stmt_if(stmt, location, scope):
-    [cond_ast, truebranch, falsebranch] = stmt.args
+    [cond_ast, truebranch, falsebranch, else_site] = stmt.args
     cond = as_bool(codegen_expression(cond_ast, location, scope))
     if cond.constant and stmt.site.dml_version() == (1, 2):
         if (logging.show_porting
@@ -2212,8 +2217,7 @@ def stmt_if(stmt, location, scope):
             if errors:
                 report(PHASH(stmt.site))
                 if falsebranch:
-                    report(PHASHELSE(dmlparse.end_site(truebranch.site),
-                                     'else'))
+                    report(PHASHELSE(else_site, 'else'))
             if (not falsebranch and cond_ast.kind == 'binop'
                 and cond_ast.args[1] == '&&'):
                 lh = as_bool(codegen_expression(cond_ast.args[0], location, scope))
@@ -2234,7 +2238,7 @@ def stmt_if(stmt, location, scope):
             fbranch = codegen_statement(falsebranch, location, scope)
         else:
             fbranch = None
-        return [ctree.If(stmt.site, cond, tbranch, fbranch)]
+        return [ctree.If(stmt.site, cond, tbranch, fbranch, else_site)]
 
 @statement_dispatcher
 def stmt_hashif(stmt, location, scope):
@@ -3219,7 +3223,7 @@ def stmt_switch(stmt, location, scope):
     with CLoopContext():
         if stmt.site.dml_version() != (1, 2):
             assert body_ast.kind == 'compound'
-            [stmt_asts] = body_ast.args
+            [stmt_asts, rbrace_site] = body_ast.args
             stmts = codegen_statements(stmt_asts, location, scope)
             if (not stmts
                 or not isinstance(stmts[0], (ctree.Case, ctree.Default))):
@@ -3257,7 +3261,7 @@ def stmt_switch(stmt, location, scope):
                 body_stmts.append(mkSubsequentCases(
                     subsequent_cases[0].site, subsequent_cases, default_found))
 
-            body = ctree.Compound(body_ast.site, body_stmts)
+            body = ctree.Compound(body_ast.site, body_stmts, rbrace_site)
         else:
             body = codegen_statement(body_ast, location, scope)
 
@@ -3608,15 +3612,15 @@ def codegen_inline(site, meth_node, indices, inargs, outargs,
                                    code, post)
         else:
             assert meth_node.astcode.kind == 'compound'
-            [subs] = meth_node.astcode.args
+            [subs, rbrace_site] = meth_node.astcode.args
             location = Location(meth_node, indices)
             exit_handler = GotoExit_dml14(outargs)
             with exit_handler:
                 code = codegen_statements(subs, location, param_scope)
             decls = declarations(param_scope)
             post = ([mkLabel(site, exit_handler.label)]
                     if exit_handler.used else [])
-            body = mkCompound(site, decls + code)
+            body = mkCompound(site, decls + code, rbrace_site)
             if meth_node.outp and body.control_flow().fallthrough:
                 report(ENORET(meth_node.astcode.site))
             return mkInlinedMethod(site, meth_node, decls, code, post)
@@ -3772,7 +3776,7 @@ def codegen_method_func(func):
                 method.parent, indices,
                 [mkLit(method.site, n, t) for (n, t) in func.inp],
                 [mkLit(method.site, "*%s" % n, t) for (n, t) in func.outp],
-                method.site)
+                SimpleSite(method.site.loc()))
     inline_scope = MethodParamScope(global_scope)
     for (name, e) in func.inp:
         if dml.globals.dml_version == (1, 2) and (
@@ -3894,10 +3898,8 @@ def prelude():
             # manually deconstruct compound AST node, to make sure
             # top-level locals share scope with parameters
             assert ast.kind == 'compound'
-            [subs] = ast.args
+            [subs, _] = ast.args
             with fail_handler, exit_handler:
-                # TODO The linemarks for the prelude will point to the method
-                # declaration, which is not optimal, but should be fine.
                 body = prelude()
                 body.extend(codegen_statements(subs, location, fnscope))
                 code = mkCompound(site, body)
@@ -3907,7 +3909,8 @@ def prelude():
                     else:
                         code = mkCompound(site,
                                           body + [codegen_exit(rbrace_site,
-                                                               [])])
+                                                               [])],
+                                          rbrace_site)
             to_return = code
         return to_return