mmaps derivedFrom

Author: burrbull

src/mmap/mmap_cli.rs

@@ -78,6 +78,14 @@ fn get_interrupts(peripheral: &Peripheral, mmap: &mut Vec<String>) {
     }
 }
 
+fn derived_str(dname: &Option<String>) -> String {
+    if let Some(dname) = dname.as_ref() {
+        format!(" (={dname})")
+    } else {
+        String::new()
+    }
+}
+
 fn get_registers(
     base_address: u64,
     registers: Option<&Vec<RegisterCluster>>,
@@ -95,19 +103,24 @@ fn get_registers(
                         Register::Single(r) => {
                             let addr = str_utils::format_address(first_addr);
                             let rname = r.name.to_string() + suffix;
-                            let text = format!("{addr} B  REGISTER {rname}{access}: {description}");
+                            let derived = derived_str(&r.derived_from);
+                            let text = format!(
+                                "{addr} B  REGISTER {rname}{derived}{access}: {description}"
+                            );
                             mmap.push(text);
                             get_fields(r, &addr, mmap);
                         }
                         Register::Array(r, d) => {
+                            let derived = derived_str(&r.derived_from);
                             for (i, idx) in d.indexes().enumerate() {
                                 let addr = str_utils::format_address(
                                     first_addr + (i as u64) * (d.dim_increment as u64),
                                 );
                                 let rname = r.name.replace("%s", &idx);
                                 let description = description.replace("%s", &idx);
-                                let text =
-                                    format!("{addr} B  REGISTER {rname}{access}: {description}");
+                                let text = format!(
+                                    "{addr} B  REGISTER {rname}{derived}{access}: {description}"
+                                );
                                 mmap.push(text);
                                 get_fields(r, &addr, mmap);
                             }
@@ -121,17 +134,20 @@ fn get_registers(
                         Cluster::Single(c) => {
                             let addr = str_utils::format_address(first_addr);
                             let cname = &c.name;
-                            let text = format!("{addr} B  CLUSTER {cname}: {description}");
+                            let derived = derived_str(&c.derived_from);
+                            let text = format!("{addr} B  CLUSTER {cname}{derived}: {description}");
                             mmap.push(text);
                             get_registers(first_addr, Some(&c.children), "", mmap);
                         }
                         Cluster::Array(c, d) => {
+                            let derived = derived_str(&c.derived_from);
                             for (i, idx) in d.indexes().enumerate() {
                                 let caddr = first_addr + (i as u64) * (d.dim_increment as u64);
                                 let addr = str_utils::format_address(caddr);
                                 let cname = c.name.replace("%s", &idx);
                                 let description = description.replace("%s", &idx);
-                                let text = format!("{addr} B  CLUSTER {cname}: {description}");
+                                let text =
+                                    format!("{addr} B  CLUSTER {cname}{derived}: {description}");
                                 mmap.push(text);
                                 get_registers(caddr, Some(&c.children), &idx, mmap);
                             }
@@ -153,18 +169,20 @@ fn get_fields(register: &RegisterInfo, addr: &str, mmap: &mut Vec<String>) {
                     let bit_offset = f.bit_range.offset;
                     let bit_width = f.bit_range.width;
                     let fname = &f.name;
+                    let derived = derived_str(&f.derived_from);
                     let text = format!(
-                        "{addr} C   FIELD {bit_offset:02}w{bit_width:02} {fname}{access}: {description}"
+                        "{addr} C   FIELD {bit_offset:02}w{bit_width:02} {fname}{derived}{access}: {description}"
                     );
                     mmap.push(text);
                 }
                 Field::Array(f, d) => {
+                    let derived = derived_str(&f.derived_from);
                     for (i, idx) in d.indexes().enumerate() {
                         let bit_offset = f.bit_range.offset + (i as u32) * d.dim_increment;
                         let bit_width = f.bit_range.width;
                         let fname = f.name.replace("%s", &idx);
                         let text = format!(
-                            "{addr} C   FIELD {bit_offset:02}w{bit_width:02} {fname}{access}: {description}"
+                            "{addr} C   FIELD {bit_offset:02}w{bit_width:02} {fname}{derived}{access}: {description}"
                         );
                         mmap.push(text);
                     }

svdtools/mmap.py

@@ -94,6 +94,13 @@ def get_int(node, tag, default=None):
         return int(text, 10)
 
 
+def derived_str(dname):
+    if dname is None:
+        return ""
+    else:
+        return f"(={dname})"
+
+
 def expand_dim(node, field=False):
     """
     Given a node (a cluster, a register or a field) which may have a `dim` child,
@@ -167,25 +174,29 @@ def parse_register(rtag):
     rdesc = get_string(rtag, "description")
     raccess = get_access(rtag)
     roffset = get_int(rtag, "addressOffset")
+    r_derived = derived_str(rtag.attrib.get("derivedFrom", None))
     for ftag in iter_fields(rtag):
         for ftag in expand_dim(ftag, field=True):
             fname = get_string(ftag, "name")
             foffset, fwidth = get_field_offset_width(ftag)
             fdesc = get_string(ftag, "description")
             faccess = get_access(ftag)
+            f_derived = derived_str(ftag.attrib.get("derivedFrom", None))
             fields[fname] = {
                 "name": fname,
                 "offset": foffset,
                 "width": fwidth,
                 "description": fdesc,
                 "access": faccess,
+                "derived": f_derived,
             }
     return {
         "name": rname,
         "offset": roffset,
         "description": rdesc,
         "access": raccess,
         "fields": fields,
+        "derived": r_derived,
     }
 
 
@@ -218,10 +229,16 @@ def parse(svdfile):
                 cname = get_string(ctag, "name")
                 cdesc = get_string(ctag, "description")
                 coff = get_int(ctag, "addressOffset")
+                c_derived = derived_str(ctag.attrib.get("derivedFrom", None))
                 for rtag in expand_cluster(ctag):
                     register = parse_register(rtag)
                     registers[register["name"]] = register
-                clusters[cname] = {"name": cname, "description": cdesc, "offset": coff}
+                clusters[cname] = {
+                    "name": cname,
+                    "description": cdesc,
+                    "offset": coff,
+                    "derived": c_derived,
+                }
         for rtag in iter_registers(ptag):
             for rtag in expand_dim(rtag):
                 register = parse_register(rtag)
@@ -263,19 +280,20 @@ def to_text(device):
         for c in p["clusters"].values():
             addr = p["base"] + c["offset"]
             mmap.append(
-                f"0x{addr:08X} B  CLUSTER {c['name']}: " + f"{c['description']}"
+                f"0x{addr:08X} B  CLUSTER {c['name']}{c['derived']}: "
+                + f"{c['description']}"
             )
         for r in p["registers"].values():
             addr = p["base"] + r["offset"]
             mmap.append(
-                f"0x{addr:08X} B  REGISTER {r['name']}{r['access']}: "
+                f"0x{addr:08X} B  REGISTER {r['name']}{r['derived']}{r['access']}: "
                 + f"{r['description']}"
             )
             for f in r["fields"].values():
                 offset, width = f["offset"], f["width"]
                 mmap.append(
                     f"0x{addr:08X} C   FIELD {offset:02d}w{width:02d} "
-                    + f"{f['name']}{f['access']}: "
+                    + f"{f['name']}{f['derived']}{f['access']}: "
                     + f"{f['description']}"
                 )
     return "\n".join(sorted(mmap))