Add compatibility feature and releasenotes

Author: lwaern-intel

RELEASENOTES.docu

@@ -1771,4 +1771,12 @@ extern typedef struct { } my_type_t;</pre> </add-note></build-id>
       m(conf_object_t)</tt> for function pointers is only permitted
       when this feature is enabled. The feature will be disabled in
       Simics API versions > 7.</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

@@ -214,6 +214,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

@@ -560,6 +560,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

@@ -178,6 +178,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

@@ -674,8 +674,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}")
 
@@ -684,8 +689,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

@@ -7,7 +7,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 *
@@ -398,11 +398,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):