Merge #341

341: sizes, 64bit r=therealprof a=burrbull

r? @therealprof 

Right use of cluster.size + better support of 64bit registers.

See #299 , partially closed in #325 .

Not tested yet.

Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>

Author: bors[bot]

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Correct handling of cluster size tag
+
+- Support of 64-bit fields
+
 ## [v0.15.0] - 2019-07-25
 
 - Logging system was introduced by `log` crate.

src/generate/peripheral.rs

@@ -34,7 +34,7 @@ pub fn render(
     }
 
     let name_pc = Ident::from(&*p.name.to_sanitized_upper_case());
-    let address = util::hex(p.base_address);
+    let address = util::hex(p.base_address as u64);
     let description = util::respace(p.description.as_ref().unwrap_or(&p.name));
     let derive_regs = p_derivedfrom.is_some() && p_original.registers.is_none();
 
@@ -600,7 +600,11 @@ fn cluster_size_in_bits(info: &ClusterInfo, defs: &Defaults) -> Result<u32> {
 fn expand_cluster(cluster: &Cluster, defs: &Defaults) -> Result<Vec<RegisterBlockField>> {
     let mut cluster_expanded = vec![];
 
-    let cluster_size = cluster_size_in_bits(cluster, defs)
+    let reg_size = cluster.size.or(defs.size);
+    let mut defs = defs.clone();
+    defs.size = reg_size;
+
+    let cluster_size = cluster_size_in_bits(cluster, &defs)
         .chain_err(|| format!("Cluster {} has no determinable `size` field", cluster.name))?;
 
     match cluster {
@@ -724,7 +728,12 @@ fn cluster_block(
     .replace("[%s]", "")
     .replace("%s", "");
     let name_sc = Ident::from(&*mod_name.to_sanitized_snake_case());
-    let reg_block = register_or_cluster_block(&c.children, defaults, Some(&mod_name), nightly)?;
+
+    let reg_size = c.size.or(defaults.size);
+    let mut defaults = defaults.clone();
+    defaults.size = reg_size;
+
+    let reg_block = register_or_cluster_block(&c.children, &defaults, Some(&mod_name), nightly)?;
 
     // Generate definition for each of the registers.
     let registers = util::only_registers(&c.children);
@@ -734,14 +743,14 @@ fn cluster_block(
             &registers,
             p,
             all_peripherals,
-            defaults,
+            &defaults,
         )?);
     }
 
     // Generate the sub-cluster blocks.
     let clusters = util::only_clusters(&c.children);
     for c in &clusters {
-        mod_items.push(cluster_block(c, defaults, p, all_peripherals, nightly)?);
+        mod_items.push(cluster_block(c, &defaults, p, all_peripherals, nightly)?);
     }
 
     Ok(quote! {

src/generate/register.rs

@@ -103,7 +103,7 @@ pub fn render(
         let rv = register
             .reset_value
             .or(defs.reset_value)
-            .map(util::hex)
+            .map(|v| util::hex(v as u64))
             .ok_or_else(|| format!("Register {} has no reset value", register.name))?;
 
         reg_impl_items.push(quote! {
@@ -257,7 +257,7 @@ pub fn fields(
                 access: f.access,
                 evs: &f.enumerated_values,
                 sc: Ident::from(&*sc),
-                mask: util::hex((((1 as u64) << width) - 1) as u32),
+                mask: util::hex(1u64.wrapping_neg() >> (64-width)),
                 name: &f.name,
                 offset: util::unsuffixed(u64::from(f.bit_range.offset)),
                 ty: width.to_ty()?,
@@ -378,7 +378,7 @@ pub fn fields(
                     let mut arms = variants
                         .iter()
                         .map(|v| {
-                            let value = util::hex_or_bool(v.value as u32, f.width);
+                            let value = util::hex_or_bool(v.value as u64, f.width);
                             let pc = &v.pc;
 
                             quote! {
@@ -714,7 +714,7 @@ pub fn fields(
 fn unsafety(write_constraint: Option<&WriteConstraint>, width: u32) -> Option<Ident> {
     match &write_constraint {
         Some(&WriteConstraint::Range(range))
-            if u64::from(range.min) == 0 && u64::from(range.max) == (1u64 << width) - 1 =>
+            if u64::from(range.min) == 0 && u64::from(range.max) == 1u64.wrapping_neg() >> (64-width) =>
         {
             // the SVD has acknowledged that it's safe to write
             // any value that can fit in the field

src/util.rs

@@ -216,10 +216,14 @@ pub fn access_of(register: &Register) -> Access {
 }
 
 /// Turns `n` into an unsuffixed separated hex token
-pub fn hex(n: u32) -> Tokens {
+pub fn hex(n: u64) -> Tokens {
     let mut t = Tokens::new();
-    let (h2, h1) = ((n >> 16) & 0xffff, n & 0xffff);
-    t.append(if h2 != 0 {
+    let (h4, h3, h2, h1) = ((n >> 48) & 0xffff, (n >> 32) & 0xffff, (n >> 16) & 0xffff, n & 0xffff);
+    t.append(if h4 != 0 {
+        Ident::from(format!("0x{:04x}_{:04x}_{:04x}_{:04x}", h4, h3, h2, h1))
+    } else if h3 != 0 {
+        Ident::from(format!("0x{:04x}_{:04x}_{:04x}", h3, h2, h1))
+    } else if h2 != 0 {
         Ident::from(format!("0x{:04x}_{:04x}", h2, h1))
     } else if h1 & 0xff00 != 0 {
         Ident::from(format!("0x{:04x}", h1))
@@ -231,7 +235,7 @@ pub fn hex(n: u32) -> Tokens {
     t
 }
 
-pub fn hex_or_bool(n: u32, width: u32) -> Tokens {
+pub fn hex_or_bool(n: u64, width: u32) -> Tokens {
     if width == 1 {
         let mut t = Tokens::new();
         t.append(Ident::from(if n == 0 { "false" } else { "true" }));