Typed set/get variants for standard attribute templates -- SIMICS-17951

Author: lwaern-intel

RELEASENOTES-1.4.docu

@@ -455,4 +455,13 @@
       (<tt>-g</tt>) that caused <tt>inline</tt> method calls to inline constant
       arguments even for parameters not declared <tt>inline</tt>
       <bug number="16019548195"/>.</add-note></build-id>
+  <build-id value="next"><add-note>Two new overridable methods
+      <tt>get_val() -> (<em>type</em>)</tt> and
+      <tt>set_val(<em>type</em> val) throws</tt> have been introduced to the
+      attribute templates <tt>bool_attr</tt>, <tt>uint64_attr</tt>,
+      <tt>int64_attr</tt> and <tt>double_attr</tt>. These methods are used by
+      the default implementations of <tt>get</tt> and <tt>set</tt>, and
+      overriding them is an alternate way of specifying custom get/set logic for
+      attributes making use of these templates <bug number="SIMICS-17951"/>.
+  </add-note></build-id>
 </rn>

lib/1.2/dml12-compatibility.dml

@@ -23,34 +23,97 @@ template bool_attr is (attribute, _banned_init_val) {
     param val = this;
     // Since we are by definition backed by 1.2 builtins, get throws
     shared method get() -> (attr_value_t);
+    method get() -> (attr_value_t) default {
+        return SIM_make_attr_boolean(get_val());
+    }
     shared method set(attr_value_t val) throws;
+    method set(attr_value_t val) throws default {
+        set_val(SIM_attr_boolean(val));
+    }
+    shared method get_val() -> (bool);
+    method get_val() -> (bool) default {
+        return this;
+    }
+    shared method set_val(bool val) throws;
+    method set_val(bool val) throws default {
+        this = val;
+    }
 }
 
 template uint64_attr is (attribute, _banned_init_val) {
     param allocate_type = "uint64";
     param val = this;
     shared method get() -> (attr_value_t);
+    method get() -> (attr_value_t) default {
+        return SIM_make_attr_uint64(get_val());
+    }
     shared method set(attr_value_t val) throws;
+    method set(attr_value_t val) throws default {
+        if (!SIM_attr_is_uint64(val)) {
+            SIM_c_attribute_error("negative integer value: %lld",
+                                  cast(SIM_attr_integer(val), int64));
+            throw;
+        }
+        set_val(SIM_attr_integer(val));
+    }
+    shared method set_val(uint64 val) throws;
+    method set_val(uint64 val) throws default {
+        this = val;
+    }
+    shared method get_val() -> (uint64);
+    method get_val() -> (uint64) default {
+        return this;
+    }
 }
 
 template int64_attr is (attribute, _banned_init_val) {
     param allocate_type = "int64";
     param val = this;
+    // Note: 1.4 attribute returns signed int but 1.2 does not,
+    // hence the override here is not only to make use of get_val(), but
+    // also to always return signed
     shared method get() -> (attr_value_t);
-    shared method set(attr_value_t val) throws;
-    // 1.4 attribute returns signed int, but 1.2 does not,
-    // hence we need to override get here to always return
-    // signed
     method get() -> (attr_value_t) default {
-        return SIM_make_attr_int64(val);
+        return SIM_make_attr_int64(get_val());
+    }
+    shared method set(attr_value_t val) throws;
+    method set(attr_value_t val) throws default {
+        if (!SIM_attr_is_int64(val)) {
+            SIM_c_attribute_error("integer value too large: %llu",
+                                  cast(SIM_attr_integer(val), uint64));
+            throw;
+        }
+        set_val(SIM_attr_integer(val));
+    }
+    shared method get_val() -> (int64);
+    method get_val() -> (int64) default {
+        return this;
+    }
+    shared method set_val(int64 val) throws;
+    method set_val(int64 val) throws default {
+        this = val;
     }
 }
 
 template double_attr is (attribute, _banned_init_val) {
     param allocate_type = "double";
     param val = this;
     shared method get() -> (attr_value_t);
+    method get() -> (attr_value_t) default {
+        return SIM_make_attr_floating(get_val());
+    }
     shared method set(attr_value_t val) throws;
+    method set(attr_value_t val) throws default {
+        set_val(SIM_attr_floating(val));
+    }
+    shared method get_val() -> (double);
+    method get_val() -> (double) default {
+        return this;
+    }
+    shared method set_val(double val) throws;
+    method set_val(double val) throws default {
+        this = val;
+    }
 }
 
 template pseudo_attr is attribute {

lib/1.4/dml-builtins.dml

@@ -1040,7 +1040,14 @@ standard types. Each store the attribute value in a member `val`,
 provide default implementations of methods `get` and `set` according to the
 type, and provide a default implementation of `init` that initializes
 `val` using the `init_val` parameter also provided by the template (whose
-default definition simply zero-initializes `val`.) These four templates are:
+default definition simply zero-initializes `val`.)
+The default implementations of `get` and `set` make use of corresponding
+methods <tt>get_val() -> (<em>type</em>)</tt> and
+<tt>set_val(<em>type</em> val) throws</tt>, which can be overridden in order to
+provide custom get/set logic in a more ergonomic way compared to overriding
+`get`/`set` directly.
+
+The four templates are:
 
 <dl><dt>
 
@@ -1110,10 +1117,16 @@ template bool_attr is (attribute, init) {
         val = init_val;
     }
     shared method get() -> (attr_value_t) default {
-        return SIM_make_attr_boolean(val);
+        return SIM_make_attr_boolean(get_val());
     }
     shared method set(attr_value_t val) throws default {
-        this.val = SIM_attr_boolean(val);
+        set_val(SIM_attr_boolean(val));
+    }
+    shared method set_val(bool val) throws default {
+        this.val = val;
+    }
+    shared method get_val() -> (bool) default {
+        return this.val;
     }
 }
 
@@ -1126,15 +1139,21 @@ template uint64_attr is (attribute, init) {
         val = init_val;
     }
     shared method get() -> (attr_value_t) default {
-        return SIM_make_attr_uint64(val);
+        return SIM_make_attr_uint64(get_val());
     }
     shared method set(attr_value_t val) throws default {
         if (!SIM_attr_is_uint64(val)) {
             SIM_c_attribute_error("negative integer value: %lld",
                                   cast(SIM_attr_integer(val), int64));
             throw;
         }
-        this.val = SIM_attr_integer(val);
+        set_val(SIM_attr_integer(val));
+    }
+    shared method set_val(uint64 val) throws default {
+        this.val = val;
+    }
+    shared method get_val() -> (uint64) default {
+        return this.val;
     }
 }
 
@@ -1147,15 +1166,21 @@ template int64_attr is (attribute, init) {
         val = init_val;
     }
     shared method get() -> (attr_value_t) default {
-        return SIM_make_attr_int64(val);
+        return SIM_make_attr_int64(get_val());
     }
     shared method set(attr_value_t val) throws default {
         if (!SIM_attr_is_int64(val)) {
             SIM_c_attribute_error("integer value too large: %llu",
                                   cast(SIM_attr_integer(val), uint64));
             throw;
         }
-        this.val = SIM_attr_integer(val);
+        set_val(SIM_attr_integer(val));
+    }
+    shared method set_val(int64 val) throws default {
+        this.val = val;
+    }
+    shared method get_val() -> (int64) default {
+        return this.val;
     }
 }
 
@@ -1168,10 +1193,16 @@ template double_attr is (attribute, init) {
         val = init_val;
     }
     shared method get() -> (attr_value_t) default {
-        return SIM_make_attr_floating(val);
+        return SIM_make_attr_floating(get_val());
     }
     shared method set(attr_value_t val) throws default {
-        this.val = SIM_attr_floating(val);
+        set_val(SIM_attr_floating(val));
+    }
+    shared method set_val(double val) throws default {
+        this.val = val;
+    }
+    shared method get_val() -> (double) default {
+        return this.val;
     }
 }
 

test/1.2/misc/dml14.dml

@@ -358,6 +358,44 @@ attribute woa is (write_only_attr) {
     method set(attr_value_t val) throws {}
 }
 
+attribute ia2 is (int64_attr) {
+    method get_val() -> (int64) {
+        return this.val + 1;
+    }
+
+    method set_val(int64 val) throws {
+        this.val = val - 1;
+    }
+}
+
+attribute ua2 is (uint64_attr) {
+    method get_val() -> (uint64) {
+        return this.val + 1;
+    }
+
+    method set_val(uint64 val) throws {
+        this.val = val - 1;
+    }
+}
+attribute ba2 is (bool_attr) {
+    method get_val() -> (bool) {
+        return !this.val;
+    }
+
+    method set_val(bool val) throws {
+        this.val = !val;
+    }
+}
+attribute fa2 is (double_attr) {
+    method get_val() -> (double) {
+        return -this.val;
+    }
+
+    method set_val(double val) throws {
+        this.val = -val;
+    }
+}
+
 param global_sym = 14;
 
 /// WARNING WEXPERIMENTAL
@@ -432,21 +470,34 @@ method len_test() {
 // checks that typed attribute access works
 method attribute_test() throws {
     cast(ia, int64_attr).set(SIM_make_attr_int64(-16));
-    local attr_value_t ia_get;
-    (ia_get) = cast(ia, int64_attr).get();
-    assert(SIM_attr_integer(ia_get) == -16);
+    local attr_value_t ia_get = cast(ia, int64_attr).get();
+    assert SIM_attr_integer(ia_get) == -16;
     cast(ua, uint64_attr).set(SIM_make_attr_uint64(32));
-    local attr_value_t ua_get;
-    (ua_get) = cast(ua, uint64_attr).get();
-    assert(SIM_attr_integer(ua_get) == 32);
+    local attr_value_t ua_get = cast(ua, uint64_attr).get();
+    assert SIM_attr_integer(ua_get) == 32;
     cast(ba, bool_attr).set(SIM_make_attr_boolean(true));
-    local attr_value_t ba_get;
-    (ba_get) = cast(ba, bool_attr).get();
-    assert(SIM_attr_boolean(ba_get));
+    local attr_value_t ba_get = cast(ba, bool_attr).get();
+    assert SIM_attr_boolean(ba_get);
     cast(fa, double_attr).set(SIM_make_attr_floating(4.13));
-    local attr_value_t fa_get;
-    (fa_get) = cast(fa, double_attr).get();
-    assert(SIM_attr_floating(fa_get) == 4.13);
+    local attr_value_t fa_get = cast(fa, double_attr).get();
+    assert SIM_attr_floating(fa_get) == 4.13;
+
+    cast(ia2, int64_attr).set(SIM_make_attr_int64(-16));
+    local attr_value_t ia2_get = cast(ia2, int64_attr).get();
+    assert SIM_attr_integer(ia2_get) == -16;
+    assert ia2.val == -17;
+    cast(ua2, uint64_attr).set(SIM_make_attr_uint64(32));
+    local attr_value_t ua2_get = cast(ua2, uint64_attr).get();
+    assert SIM_attr_integer(ua2_get) == 32;
+    assert ua2.val == 31;
+    cast(ba2, bool_attr).set(SIM_make_attr_boolean(true));
+    local attr_value_t ba2_get = cast(ba2, bool_attr).get();
+    assert SIM_attr_boolean(ba2_get);
+    assert !ba2.val;
+    cast(fa2, double_attr).set(SIM_make_attr_floating(4.13));
+    local attr_value_t fa2_get = cast(fa2, double_attr).get();
+    assert SIM_attr_floating(fa2_get) == 4.13;
+    assert fa2.val == -4.13;
 }
 
 method pseudo_attr_test() throws {

test/1.4/lib/T_attributes.dml

@@ -51,6 +51,41 @@ attribute overridden_init is (bool_attr) {
     method init() { }
 }
 
+attribute b3 is (bool_attr) {
+    method get_val() -> (bool) {
+        return !this.val;
+    }
+    method set_val(bool val) throws {
+        this.val = !val;
+    }
+}
+
+attribute u3 is (uint64_attr) {
+    method get_val() -> (uint64) {
+        return this.val + 1;
+    }
+    method set_val(uint64 val) throws {
+        this.val = val - 1;
+    }
+}
+
+attribute i3 is (int64_attr) {
+    method get_val() -> (int64) {
+        return this.val + 1;
+    }
+    method set_val(int64 val) throws {
+        this.val = val - 1;
+    }
+}
+
+attribute f3 is (double_attr) {
+    method get_val() -> (double) {
+        return -this.val;
+    }
+    method set_val(double val) throws {
+        this.val = -val;
+    }
+}
 
 method test() throws {
     b.val = true;
@@ -94,4 +129,26 @@ method test() throws {
     assert i2.val == -33;
     assert f2.val == 3.3;
     assert !overridden_init.val;
+
+    // local attr_value_t bool_attr = SIM_make_attr_boolean(false);
+    SIM_set_attribute(dev.obj, "b3", &bool_attr);
+    assert b3.val;
+    assert !SIM_attr_boolean(SIM_get_attribute(dev.obj, "b3"));
+
+    local attr_value_t uint_attr = SIM_make_attr_uint64(134);
+    SIM_set_attribute(dev.obj, "u3", &uint_attr);
+    assert u3.val == 133;
+    assert cast(SIM_attr_integer(SIM_get_attribute(dev.obj, "u3")), uint64)
+        == 134;
+
+    local attr_value_t int_attr = SIM_make_attr_int64(-134);
+    SIM_set_attribute(dev.obj, "i3", &int_attr);
+    assert i3.val == -135;
+    assert SIM_attr_integer(SIM_get_attribute(dev.obj, "i3")) == -134;
+
+    // local attr_value_t float_attr = SIM_make_attr_floating(1.414);
+    SIM_set_attribute(dev.obj, "f3", &float_attr);
+    assert f3.val == -1.414;
+    assert SIM_attr_floating(SIM_get_attribute(dev.obj, "f3"))
+        == 1.414;
 }