Enforce register value constraints

Enforce register size, reset, and mask value agreement. If the provided
reset value or mask extend past the register size, or the provided reset
value would conflict with the mask, then fail parsing.

Author: gkelly

src/error.rs

@@ -72,6 +72,16 @@ pub enum NameError {
     Invalid(String, String),
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ResetValueError {
+    #[error("Reset value 0x{0:x} doesn't fit in {1} bits")]
+    ValueTooLarge(u32, u32),
+    #[error("Reset value 0x{0:x} conflicts with mask '{1}'")]
+    MaskConflict(u32, u32),
+    #[error("Mask value 0x{0:x} doesn't fit in {1} bits")]
+    MaskTooLarge(u32, u32),
+}
+
 pub(crate) fn is_valid_name(name: &str) -> bool {
     let mut chars = name.chars();
     if let Some(first) = chars.next() {
@@ -96,3 +106,56 @@ pub(crate) fn check_name(name: &str, tag: &str) -> Result<()> {
         Err(NameError::Invalid(name.to_string(), tag.to_string()).into())
     }
 }
+
+pub(crate) fn check_reset_value(
+    size: &Option<u32>,
+    value: &Option<u32>,
+    mask: &Option<u32>,
+) -> Result<()> {
+    const MAX_BITS: u32 = u32::MAX.count_ones();
+
+    if let (&Some(size), &Some(value)) = (size, value) {
+        if MAX_BITS - value.leading_zeros() > size {
+            return Err(ResetValueError::ValueTooLarge(value, size).into());
+        }
+    }
+    if let (&Some(size), &Some(mask)) = (size, mask) {
+        if MAX_BITS - mask.leading_zeros() > size {
+            return Err(ResetValueError::MaskTooLarge(mask, size).into());
+        }
+    }
+    if let (&Some(value), &Some(mask)) = (value, mask) {
+        if value & mask != value {
+            return Err(ResetValueError::MaskConflict(value, mask).into());
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::error::check_reset_value;
+
+    #[test]
+    fn test_check_reset_value() {
+        check_reset_value(&None, &None, &None).unwrap();
+        check_reset_value(&Some(8), &None, &None).unwrap();
+        check_reset_value(&Some(8), &None, &Some(0xff)).unwrap();
+        check_reset_value(&Some(32), &Some(0xfaceface), &None).unwrap();
+        check_reset_value(&Some(32), &Some(0xfaceface), &Some(0xffffffff)).unwrap();
+
+        assert!(
+            check_reset_value(&Some(8), &None, &Some(0x100)).is_err(),
+            "mask shouldn't fit in size"
+        );
+        assert!(
+            check_reset_value(&Some(1), &Some(0x02), &None).is_err(),
+            "reset value shouldn't fit in field"
+        );
+        assert!(
+            check_reset_value(&Some(8), &Some(0x80), &Some(0x01)).is_err(),
+            "value should conflict with mask"
+        );
+    }
+}

src/svd/registerproperties.rs

@@ -51,6 +51,7 @@ impl Parse for RegisterProperties {
         p.reset_value = parse::optional::<u32>("resetValue", tree)?;
         p.reset_mask = parse::optional::<u32>("resetMask", tree)?;
         p.access = parse::optional::<Access>("access", tree)?;
+        check_reset_value(&p.size, &p.reset_value, &p.reset_mask)?;
         Ok(p)
     }
 }