Polish attribute porting when allocate_type doesn't match type

SIMICS-23126

Author: mandolaerik

py/dml/structure.py

@@ -2205,7 +2205,15 @@ def field_msb(field):
                     type_site = None
                 # integer attributes of all sizes are converted to
                 # the corresponding 64-bit type
-                if atype.startswith('uint'):
+                expected_type = {'double': 'f', 'bool': 'b'}.get(atype, 'i')
+                if param_str(obj, 'type') not in {expected_type,
+                                                  f'{expected_type}|n'}:
+                    # allocate_type doesn't match attribute type, could e.g.
+                    # be enum saved as string. Trust that the getter/setter
+                    # works in this case, but remove the allocate_type
+                    # (SIMICS-23126).
+                    report(PATTRIBUTE(obj.site, None, param.site, None))
+                elif atype.startswith('uint'):
                     report(PATTRIBUTE(obj.site, 'uint64_attr', param.site,
                                       type_site))
                 elif atype.startswith('int'):

py/port_dml.py

@@ -654,10 +654,20 @@ def remove_param_decl(self, f, param_site):
     def apply(self, f):
         offs = self.offset(f)
         (template, allocate_type_param, type_param) = self.params
-        if os.path.normcase(self.loc) in self.uint64_event_sites:
-            template = template.replace('custom_', 'uint64_')
-        instantiate_template(f, offs, template)
-        self.remove_param_decl(f, allocate_type_param)
+        if template:
+            if os.path.normcase(self.loc) in self.uint64_event_sites:
+                template = template.replace('custom_', 'uint64_')
+            instantiate_template(f, offs, template)
+        if allocate_type_param:
+            if template is None:
+                # Add `.val` manually if removing allocate_type param
+                # without adding `is <type>_attr`.
+                alloc_type_offs = self.offset(f, allocate_type_param)
+                alloc_type_str = f.read_line(alloc_type_offs)
+                m = re.search('"(.*)"', alloc_type_str)
+                if m is not None:
+                    f.edit(alloc_type_offs, 0, f'session {m.group(1)} val;\n')
+            self.remove_param_decl(f, allocate_type_param)
         if type_param:
             self.remove_param_decl(f, type_param)
 

test/1.2/misc/porting.dml

@@ -296,6 +296,17 @@ attribute ad {
     parameter allocate_type = "double"; // hello
 }
 
+attribute enum_attr {
+    parameter allocate_type = "uint64";
+    parameter type = "s";
+    method get() -> (attr_value_t v) {
+        v = SIM_make_attr_string($this == 0 ? "zero" : "nonzero");
+    }
+    method set(attr_value_t v) {
+        $this = SIM_attr_string(v)[0] == 'z' ? 0 : 1;
+    }
+}
+
 // PORT-DML-WARNING WUNUSED
 if (false) {
     attribute ab { parameter allocate_type = "bool"; }

test/1.4/misc/porting.dml

@@ -319,6 +319,17 @@ attribute ad is double_attr {
 // hello
 }
 
+attribute enum_attr {
+    session uint64 val;
+    param type = "s";
+    method get() -> (attr_value_t) {
+        return SIM_make_attr_string(this.val == 0 ? "zero" : "nonzero");
+    }
+    method set(attr_value_t v) throws {
+        this.val = SIM_attr_string(v)[0] == 'z' ? 0 : 1;
+    }
+}
+
 // PORT-DML-WARNING WUNUSED
 #if (false) {
     attribute ab { param allocate_type = "bool"; }