Add compatibility feature and releasenotes

Author: lwaern-intel

RELEASENOTES.docu

@@ -1776,4 +1776,12 @@ extern typedef struct { } my_type_t;</pre> </add-note></build-id>
       the <tt>dead_dml_methods</tt> library, which caused it to never
       detect methods as dead if they occur directly after
       a <tt>footer</tt> block.</add-note></build-id>
+  <build-id _6="next" _7="next"><add-note>Typechecking has been reworked
+      to be more strict, and more accurately reject type mismatch that would
+      result in invalid C. To avoid breakage in corners where DMLC is entirely
+      responsible for proper typechecking, such as uses of <tt>extern</tt>
+      macros or method overrides, the legacy lenient typechecking is still used
+      by default with Simics API version 7 or below. The strict typechecking can
+      be enabled by passing <tt>--no-compat=lenient_typechecking</tt> to
+      DMLC.</add-note></build-id>
 </rn>

lib/1.2/dml-builtins.dml

@@ -215,6 +215,7 @@ template device {
     parameter _compat_io_memory auto;
     parameter _compat_shared_logs_on_device auto;
     parameter _compat_suppress_WLOGMIXUP auto;
+    parameter _compat_lenient_typechecking auto;
     parameter _compat_dml12_inline auto;
     parameter _compat_dml12_not auto;
     parameter _compat_dml12_goto auto;

lib/1.4/dml-builtins.dml

@@ -561,6 +561,7 @@ template device {
     param _compat_io_memory auto;
     param _compat_shared_logs_on_device auto;
     param _compat_suppress_WLOGMIXUP auto;
+    param _compat_lenient_typechecking auto;
     param _compat_dml12_inline auto;
     param _compat_dml12_not auto;
     param _compat_dml12_goto auto;

py/dml/compat.py

@@ -199,6 +199,23 @@ class suppress_WLOGMIXUP(CompatFeature):
     last_api_version = api_6
 
 
+@feature
+class lenient_typechecking(CompatFeature):
+    '''This compatibility feature makes DMLC's type checking very inexact and
+    lenient in multiple respects when compared to GCC's type checking of the
+    generated C.
+    This discrepency mostly affects method overrides or uses of `extern`:d C
+    macros, because in those scenarios DMLC can become wholly responsible for
+    proper type checking.
+
+    While migrating from this feature, novel type errors due to uses of
+    `extern`:d macros can often be resolved by changing the signature of
+    the `extern` declaration to more accurately reflect the macro's effective
+    type.
+    '''
+    short = "Make type checking inexact and lenient"
+    last_api_version = api_7
+
 @feature
 class dml12_inline(CompatFeature):
     '''When using `inline` to inline a method in a DML 1.2 device,

py/dml/structure.py

@@ -737,8 +737,13 @@ def typecheck_method_override(m1, m2, location):
             # TODO move to caller
             (_, type1) = eval_type(t1, a1.site, location, global_scope)
             (_, type2) = eval_type(t2, a2.site, location, global_scope)
-            if safe_realtype_unconst(type1).cmp(
-                    safe_realtype_unconst(type2)) != 0:
+            type1 = safe_realtype_unconst(type1)
+            type2 = safe_realtype_unconst(type2)
+
+            ok = (type1.cmp_fuzzy(type2)
+                  if compat.lenient_typechecking in dml.globals.enabled_compat
+                  else type1.cmp(type2)) == 0
+            if not ok:
                 raise EMETH(a1.site, a2.site,
                             f"mismatching types in input argument {n1}")
 
@@ -747,8 +752,12 @@ def typecheck_method_override(m1, m2, location):
             ((n1, t1), (n2, t2)) = (a1.args, a2.args)
             (_, type1) = eval_type(t1, a1.site, location, global_scope)
             (_, type2) = eval_type(t2, a2.site, location, global_scope)
-            if safe_realtype_unconst(type1).cmp(
-                    safe_realtype_unconst(type2)) != 0:
+            type1 = safe_realtype_unconst(type1)
+            type2 = safe_realtype_unconst(type2)
+            ok = (type1.cmp_fuzzy(type2)
+                  if compat.lenient_typechecking in dml.globals.enabled_compat
+                  else type1.cmp(type2)) == 0
+            if not ok:
                 msg = "mismatching types in return value"
                 if len(outp1) > 1:
                     msg += f" {i + 1}"

py/dml/traits.py

@@ -8,7 +8,7 @@
 import contextlib
 import abc
 import os
-from . import objects, logging, crep, codegen, toplevel, topsort
+from . import objects, logging, crep, codegen, toplevel, topsort, compat
 from .logging import *
 from .codegen import *
 from .symtab import *
@@ -401,11 +401,21 @@ def typecheck_method_override(left, right):
     if throws0 != throws1:
         raise EMETH(site0, site1, "different nothrow annotations")
     for ((n, t0), (_, t1)) in zip(inp0, inp1):
-        if safe_realtype_unconst(t0).cmp(safe_realtype_unconst(t1)) != 0:
+        t0 = safe_realtype_unconst(t0)
+        t1 = safe_realtype_unconst(t1)
+        ok = (t0.cmp_fuzzy(t1)
+              if compat.lenient_typechecking in dml.globals.enabled_compat
+              else t0.cmp(t1)) == 0
+        if not ok:
             raise EMETH(site0, site1,
                         "mismatching types in input argument %s" % (n,))
     for (i, ((_, t0), (_, t1))) in enumerate(zip(outp0, outp1)):
-        if safe_realtype_unconst(t0).cmp(safe_realtype_unconst(t1)) != 0:
+        t0 = safe_realtype_unconst(t0)
+        t1 = safe_realtype_unconst(t1)
+        ok = (t0.cmp_fuzzy(t1)
+              if compat.lenient_typechecking in dml.globals.enabled_compat
+              else t0.cmp(t1)) == 0
+        if not ok:
             raise EMETH(site0, site1,
                         "mismatching types in output argument %d" % (i + 1,))
 

py/dml/types.py

@@ -936,6 +936,8 @@ def canstore(self, other):
                          and shallow_const(other.base))
             if self.base.void or other.base.void:
                 ok = True
+                if compat.lenient_typechecking in dml.globals.enabled_compat:
+                    constviol = False
             else:
                 unconst_self_base = safe_realtype_unconst(self.base)
                 unconst_other_base = safe_realtype_unconst(other.base)
@@ -945,7 +947,8 @@ def canstore(self, other):
                        else unconst_self_base.cmp)(unconst_other_base)
                       == 0)
         elif isinstance(other, TFunction):
-            ok = safe_realtype_unconst(self.base).cmp(other) == 0
+            ok = (compat.lenient_typechecking in dml.globals.enabled_compat
+                  or safe_realtype_unconst(self.base).cmp(other) == 0)
         # TODO gate this behind dml.globals.dml_version == (1, 2) or
         # dml12_misc?
         if self.base.void and isinstance(other, TDevice):

test/1.4/legacy/T_lenient_typechecking_disabled.dml

@@ -0,0 +1,12 @@
+/*
+  © 2024 Intel Corporation
+  SPDX-License-Identifier: MPL-2.0
+*/
+dml 1.4;
+
+device test;
+
+/// COMPILE-ONLY
+/// DMLC-FLAG --no-compat=lenient_typechecking
+/// SCAN-FOR-TAGS lenient_typechecking.dml
+import "lenient_typechecking.dml";

test/1.4/legacy/T_lenient_typechecking_enabled.dml

@@ -0,0 +1,11 @@
+/*
+  © 2024 Intel Corporation
+  SPDX-License-Identifier: MPL-2.0
+*/
+dml 1.4;
+
+device test;
+
+/// COMPILE-ONLY
+/// DMLC-FLAG --simics-api=7
+import "lenient_typechecking.dml";

test/1.4/legacy/lenient_typechecking.dml

@@ -0,0 +1,42 @@
+/*
+  © 2024 Intel Corporation
+  SPDX-License-Identifier: MPL-2.0
+*/
+
+dml 1.4;
+
+template t {
+    shared method sm(const int *p) -> (const int *) default { return p; }
+    shared method m(const int *p) -> (const int *);
+    method n(const int *p) -> (const int *) default { return p; }
+}
+
+template u is t {
+    /// ERROR EMETH
+    shared method sm(int *p) -> (int *) { return p; }
+}
+
+group g is u {
+    /// ERROR EMETH
+    method m(int *p) -> (int *) { return p; }
+
+    /// ERROR EMETH
+    method n(int *p) -> (int *) { return p; }
+}
+
+header %{
+    #define MACRO(a,b,c) ((void)0)
+%}
+
+extern void MACRO(void *a, int *b, void (*c)(void));
+
+method init() {
+    // no error
+    MACRO(NULL, NULL, NULL);
+    /// ERROR ECONSTP
+    MACRO(cast(NULL, const int *), NULL, NULL);
+    /// ERROR ECONSTP
+    MACRO(NULL, cast(NULL, const void *), NULL);
+    /// ERROR EPTYPE
+    MACRO(NULL, NULL, MACRO);
+}