Generate safe bits writers when possible

The 'bits' method of register writers can be safe if:
* there is a single field that covers the entire register
* that field can represent all values

Author: newAM

CHANGELOG.md

@@ -31,6 +31,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Bumped `xtensa-lx` and add `xtensa_lx::interrupt::InterruptNumber` implementation.
 - Don't use a mask when the width of the mask is the same as the width of the parent register.
 - Improved error handling
+- Registers with single fields that span the entire register now generate safe `bits` writers.
 
 ## [v0.19.0] - 2021-05-26
 

src/generate/register.rs

@@ -7,6 +7,7 @@ use core::u64;
 use log::warn;
 use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};
 use quote::{quote, ToTokens};
+use std::ops::Deref;
 
 use crate::util::{self, Config, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext};
 use anyhow::{anyhow, Result};
@@ -168,10 +169,34 @@ pub fn render(
 
         mod_items.extend(w_impl_items);
 
+        // the writer can be safe if:
+        // * there is a single field that covers the entire register
+        // * that field can represent all values
+        let unsafefn: Option<Ident> = register
+            .deref()
+            .fields
+            .as_ref()
+            .map(|fields| fields.iter().next())
+            .flatten()
+            .map(|field| field.deref().write_constraint)
+            .flatten()
+            .map(|constraint| match constraint {
+                WriteConstraint::Range(range) => {
+                    if range.min == 0 && range.max == 2_u64.pow(rsize) - 1 {
+                        None
+                    } else {
+                        Some(())
+                    }
+                }
+                _ => Some(()),
+            })
+            .flatten()
+            .map(|_| Ident::new("unsafe", span));
+
         mod_items.extend(quote! {
             #[doc = "Writes raw bits to the register."]
             #[inline(always)]
-            pub unsafe fn bits(&mut self, bits: #rty) -> &mut Self {
+            pub #unsafefn fn bits(&mut self, bits: #rty) -> &mut Self {
                 self.0.bits(bits);
                 self
             }