macros: Don't use Option in singleton!()

As detailed in #364, niche optimization of the
`Option` used in the `singleton!()` macro can lead to the initial value
of the static to contain non-zero bits.  This in turn leads to the whole
static being moved from `.bss` to `.data` which means it eats up flash
space for no reason.  Especially if the singleton stores a particularly
large type, this can be quite problematic.

Prevent this by using an explicit boolean flag instead of the `Option`
type.  This is not quite as nice but at least there is no chance for the
`singleton!()` to end up in `.data`...

Author: Rahix

src/macros.rs

@@ -63,23 +63,24 @@ macro_rules! iprintln {
 macro_rules! singleton {
     ($name:ident: $ty:ty = $expr:expr) => {
         $crate::interrupt::free(|_| {
-            static mut $name: Option<$ty> = None;
+            // this is a tuple of a MaybeUninit and a bool because using an Option here is
+            // problematic:  Due to niche-optimization, an Option could end up producing a non-zero
+            // initializer value which would move the entire static from `.bss` into `.data`...
+            static mut $name: (::core::mem::MaybeUninit<$ty>, bool) =
+                (::core::mem::MaybeUninit::uninit(), false);
 
             #[allow(unsafe_code)]
-            let used = unsafe { $name.is_some() };
+            let used = unsafe { $name.1 };
             if used {
                 None
             } else {
                 let expr = $expr;
 
                 #[allow(unsafe_code)]
                 unsafe {
-                    $name = Some(expr)
-                }
-
-                #[allow(unsafe_code)]
-                unsafe {
-                    $name.as_mut()
+                    $name.1 = true;
+                    $name.0 = ::core::mem::MaybeUninit::new(expr);
+                    Some(&mut *$name.0.as_mut_ptr())
                 }
             }
         })