Make bitfields compatible only with identically specified bitfields

Author: lwaern-intel

py/dml/types.py

@@ -63,6 +63,7 @@
 from . import output
 import dml .globals
 import abc
+import zlib
 
 class DMLTypeError(Exception): pass
 
@@ -510,6 +511,27 @@ def __init__(self, bits, signed, members = None, const = False):
     def is_bitfields(self):
         return self.members is not None
 
+    def describe_backing_type(self):
+        raise Exception("%s.describe_backing_type not implemented"
+                        % (self.__class__.__name__,))
+
+    def describe(self):
+        return (f'bitfields (backing type: {self.describe_backing_type()})'
+                if self.is_bitfields else self.describe_backing_type())
+
+    def key(self):
+        if not self.is_bitfields:
+            return DMLType.key(self)
+
+        backing = self.describe_backing_type()
+
+        # using adler32 as a quick, dirty, short, implementation-consistent
+        # hash that doesn't pull in any dependencies
+        hsh = zlib.adler32(';'.join(
+            f'{name}:{t.key()}@{msb}-{lsb}'
+            for (name, (t, msb, lsb)) in self.members.items()).encode('utf-8'))
+        return f'{self.const_str}bitfields({backing}, {hsh})'
+
     @property
     def bytes(self):
         return (self.bits - 1) // 8 + 1
@@ -543,8 +565,29 @@ def cmp(self, other):
                 return NotImplemented
         elif other.is_endian:
             return NotImplemented
-        return (0 if (self.bits, self.signed) == (other.bits, other.signed)
-                else NotImplemented)
+        if (self.bits, self.signed) != (other.bits, other.signed):
+            return NotImplemented
+        if self.members is not other.members:
+            if self.members is None or other.members is None:
+                return NotImplemented
+
+            # Slow path, when the two bitfields types have different origins
+
+            # The specifications have to be completely equivalent.
+            # We don't normalize reps via any sorting, as the order matters for
+            # compound initializers; we are not lenient on names, as that
+            # affects mkSubRef and designated initializers; we are not lenient
+            # on types because they SHOULD affect mkSubRef even though they
+            # don't today (see SIMICS-8857 and SIMICS-18394)
+            if (len(self.members) != len(other.members)
+                or any((name0, msb0, lsb0) != (name1, msb1, lsb1)
+                       or t0.cmp(t1) != 0
+                       for ((name0, (t0, msb0, lsb0)),
+                            (name1, (t1, msb1, lsb1)))
+                       in zip(self.members.items(), other.members.items()))):
+                return NotImplemented
+
+        return 0
 
     def cmp_fuzzy(self, other):
         if not other.is_int:
@@ -570,7 +613,11 @@ def cmp_fuzzy(self, other):
     def hashed(self):
         cls = type(self) if self.is_arch_dependent else IntegerType
         byte_order = self.byte_order if self.is_endian else None
-        return hash((cls, self.const, self.bits, self.signed, byte_order))
+        members = (tuple((name, typ.hashed(), lsb, msb)
+                         for (name, (typ, lsb, msb)) in self.members.items())
+                   if self.is_bitfields else None)
+        return hash((cls, self.const, self.bits, self.signed, members,
+                     byte_order))
 
     # This is the most restrictive canstore definition for
     # IntegerTypes, if this is overridden then it should be
@@ -600,12 +647,8 @@ class TInt(IntegerType):
     def __init__(self, bits, signed, members = None, const = False):
         IntegerType.__init__(self, bits, signed, members, const)
 
-    def describe(self):
-        s = 'int%d' % self.bits
-        if self.signed:
-            return s
-        else:
-            return 'u' + s
+    def describe_backing_type(self):
+        return f'{"u"*(not self.signed)}int{self.bits}'
     def __repr__(self):
         return 'TInt(%r,%r,%r,%r)' % (self.bits, self.signed,
                                       self.members, self.const)
@@ -671,7 +714,7 @@ def __init__(self, signed, const=False):
     def c_name(self):
         return self.const_str + ('long' if self.signed else 'unsigned long')
 
-    def describe(self):
+    def describe_backing_type(self):
         return self.c_name()
 
     def __repr__(self):
@@ -692,7 +735,7 @@ def __init__(self, signed, const=False):
     def c_name(self):
         return self.const_str + ('ssize_t' if self.signed else 'size_t')
 
-    def describe(self):
+    def describe_backing_type(self):
         return self.c_name()
 
     def __repr__(self):
@@ -719,7 +762,7 @@ def c_name(self):
         name = 'int64_t' if self.signed else 'uint64_t'
         return f'const {name}' if self.const else name
 
-    def describe(self):
+    def describe_backing_type(self):
         return self.c_name()
 
     def __repr__(self):
@@ -755,7 +798,7 @@ def c_name(self):
             self.const_str, "" if self.signed else "u", self.bits,
             "be" if self.big_endian else "le")
 
-    def describe(self):
+    def describe_backing_type(self):
         return self.c_name()
 
     def __repr__(self):

test/1.4/hooks/T_basic.dml

@@ -36,15 +36,15 @@ template hookset_test is hookset {
         assert h0.suspended == 0 && resumed == 2 && count == 2 && storage == 7;
         count = storage = 0;
 
-        local int i = 5;
+        local bf_t i = 5;
         after h1 -> p: one_param(p);
         assert h1.suspended == 1 && i == 5;
         resumed = h1.send_now(&i);
         assert h1.suspended == 0 && resumed == 1 && i == 6;
-        after h1 -> p: one_serializable_param(-5);
+        after h1 -> p: one_serializable_param(11);
         assert h1.suspended == 1 && storage == 0 && i == 6;
         resumed = h1.send_now(&i);
-        assert h1.suspended == 0 && resumed == 1 && storage == -5 && i == 6;
+        assert h1.suspended == 0 && resumed == 1 && storage == 11 && i == 6;
         storage = i = 0;
 
         after h2 -> (p, i): two_params(p, i);
@@ -85,11 +85,11 @@ template hookset_test is hookset {
         resumed = h1.send_now(&i);
         assert h1.suspended == 0 && resumed == 1 && i == 3 * 7 + 5;
         i = 0;
-        after h1 -> p: indexed[3][5].one_serializable_param(-5);
+        after h1 -> p: indexed[3][5].one_serializable_param(11);
         assert h1.suspended == 1 && storage_indexed == 0 && i == 0;
         resumed = h1.send_now(&i);
         assert h1.suspended == 0 && resumed == 1
-            && storage_indexed == -5 * (3 * 7 + 5) && i == 0;
+            && storage_indexed == 11 * (3 * 7 + 5) && i == 0;
         storage_indexed = 0;
 
         after h2 -> (p, i): indexed[3][5].two_params(p, i);

test/1.4/hooks/T_checkpointing.dml

@@ -63,7 +63,7 @@ attribute test_state is write_only_attr {
             count = storage = storage_indexed = 0;
             last_i_indexed = last_j_indexed = -1;
 
-            local int x = 4;
+            local bf_t x = 4;
             resumed = obj.h1.send_now(&x);
             assert resumed == 2 && x == 5 && storage == 9;
             storage = 0;

test/1.4/hooks/common.dml

@@ -4,48 +4,50 @@
 */
 dml 1.4;
 
-session int count;
+typedef bitfields 16 { uint6 a @[12:7]; } bf_t;
+
+session bf_t count;
 method no_params() {
     ++count;
 }
-method one_param(int *x) {
+method one_param(bf_t *x) {
     ++*x;
 }
-method two_params(int *x, int i) {
+method two_params(bf_t *x, bf_t i) {
     *x = i;
 }
-session int storage;
-method one_serializable_param(int i) {
+session bf_t storage;
+method one_serializable_param(bf_t i) {
     storage = i;
 }
 
-session int storage_indexed;
+session bf_t storage_indexed;
 session (int last_i_indexed, int last_j_indexed) = (-1, -1);
 group indexed[i < 5][j < 7] {
     method no_params() {
         (last_i_indexed, last_j_indexed) = (i, j);
     }
-    method one_param(int *x) {
+    method one_param(bf_t *x) {
         *x = i*7 + j;
     }
-    method two_params(int *x, int coeff) {
+    method two_params(bf_t *x, bf_t coeff) {
         *x = coeff * (i*7 + j);
     }
-    method one_serializable_param(int coeff) {
+    method one_serializable_param(bf_t coeff) {
         storage_indexed = coeff * (i*7 + j);
     }
 }
 
 template hookset {
     hook() _h0;
-    hook(int *) _h1;
-    hook(int *, int) _h2;
+    hook(bf_t *) _h1;
+    hook(bf_t *, bf_t) _h2;
 
     hook() _h3[6][8];
-    hook(int *) _h4[6][8];
-    hook(int *, int) _h5[6][8];
+    hook(bf_t *) _h4[6][8];
+    hook(bf_t *, bf_t) _h5[6][8];
 
-    hook(int) _h6;
+    hook(bf_t) _h6;
 
     param h0 default _h0;
     param h1 default _h1;
@@ -73,24 +75,24 @@ method enforce_h0_ref(hook() h) -> (hook()) {
     return h;
 }
 
-method enforce_h1_ref(hook(int *) h) -> (hook(int *)) {
+method enforce_h1_ref(hook(bf_t *) h) -> (hook(bf_t *)) {
     return h;
 }
 
-method enforce_h2_ref(hook(int *, int) h) -> (hook(int *, int)) {
+method enforce_h2_ref(hook(bf_t *, bf_t) h) -> (hook(bf_t *, bf_t)) {
     return h;
 }
 
-method enforce_h6_ref(hook(int) h) -> (hook(int)) {
+method enforce_h6_ref(hook(bf_t) h) -> (hook(bf_t)) {
     return h;
 }
 
 group via_hookref is hookset_set {
     in each hookset {
         is init;
         session hook() h3_arr[6][8];
-        session hook(int *) h4_arr[6][8];
-        session hook(int *, int) h5_arr[6][8];
+        session hook(bf_t *) h4_arr[6][8];
+        session hook(bf_t *, bf_t) h5_arr[6][8];
         method init() {
             for (local int idx_0 = 0; idx_0 < 6; ++idx_0) {
                 for (local int idx_1 = 0; idx_1 < 8; ++idx_1) {