cortex-m: generate code that compiles on stable

Author: japaric

Cargo.toml

@@ -19,7 +19,7 @@ keywords = [
 license = "MIT OR Apache-2.0"
 name = "svd2rust"
 repository = "https://github.com/japaric/svd2rust"
-version = "0.12.1"
+version = "0.13.0"
 
 [[bin]]
 doc = false

src/generate/device.rs

@@ -27,7 +27,7 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
         });
     }
 
-    if *target != Target::None {
+    if *target != Target::None && *target != Target::CortexM {
         out.push(quote! {
             #![cfg_attr(feature = "rt", feature(global_asm))]
             #![cfg_attr(feature = "rt", feature(use_extern_macros))]
@@ -37,12 +37,9 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
 
     out.push(quote! {
         #![doc = #doc]
-        #![allow(private_no_mangle_statics)]
         #![deny(missing_docs)]
         #![deny(warnings)]
         #![allow(non_camel_case_types)]
-        #![feature(const_fn)]
-        #![feature(try_from)]
         #![no_std]
     });
 
@@ -58,8 +55,6 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
                 extern crate cortex_m;
                 #[cfg(feature = "rt")]
                 extern crate cortex_m_rt;
-                #[cfg(feature = "rt")]
-                pub use cortex_m_rt::{default_handler, exception};
             });
         }
         Target::Msp430 => {
@@ -98,7 +93,7 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
         });
     }
 
-    out.extend(interrupt::render(d, target, &d.peripherals)?);
+    out.extend(interrupt::render(target, &d.peripherals)?);
 
     const CORE_PERIPHERALS: &[&str] = &[
         "CBP", "CPUID", "DCB", "DWT", "FPB", "FPU", "ITM", "MPU", "NVIC", "SCB", "SYST", "TPIU"
@@ -180,6 +175,7 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
         // NOTE `no_mangle` is used here to prevent linking different minor versions of the device
         // crate as that would let you `take` the device peripherals more than once (one per minor
         // version)
+        #[allow(private_no_mangle_statics)]
         #[no_mangle]
         static mut DEVICE_PERIPHERALS: bool = false;
 

src/generate/interrupt.rs

@@ -2,15 +2,15 @@ use std::collections::HashMap;
 
 use cast::u64;
 use quote::Tokens;
-use svd::{Device, Peripheral};
+use svd::Peripheral;
 use syn::Ident;
 
 use errors::*;
 use util::{self, ToSanitizedUpperCase};
 use Target;
 
 /// Generates code for `src/interrupt.rs`
-pub fn render(device: &Device, target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>> {
+pub fn render(target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>> {
     let interrupts = peripherals
         .iter()
         .flat_map(|p| p.interrupt.iter())
@@ -20,6 +20,7 @@ pub fn render(device: &Device, target: &Target, peripherals: &[Peripheral]) -> R
     let mut interrupts = interrupts.into_iter().map(|(_, v)| v).collect::<Vec<_>>();
     interrupts.sort_by_key(|i| i.value);
 
+    let mut root = vec![];
     let mut arms = vec![];
     let mut from_arms = vec![];
     let mut elements = vec![];
@@ -29,9 +30,6 @@ pub fn render(device: &Device, target: &Target, peripherals: &[Peripheral]) -> R
     // Current position in the vector table
     let mut pos = 0;
     let mut mod_items = vec![];
-    mod_items.push(quote! {
-        use bare_metal::Nr;
-    });
     for interrupt in &interrupts {
         while pos < interrupt.value {
             elements.push(quote!(None));
@@ -85,63 +83,17 @@ pub fn render(device: &Device, target: &Target, peripherals: &[Peripheral]) -> R
     let n = util::unsuffixed(u64(pos));
     match *target {
         Target::CortexM => {
-            let is_armv6 = match device.cpu {
-                Some(ref cpu) => cpu.name.starts_with("CM0"),
-                None => true, // default to armv6 when the <cpu> section is missing
-            };
-
-            if is_armv6 {
-                // Cortex-M0(+) are ARMv6 and don't have `b.w` (branch with 16 MB range). This
-                // can cause linker errors when the handler is too far away. Instead of a small
-                // inline assembly shim, we generate a function for those targets and let the
-                // compiler do the work (sacrificing a few bytes of code).
-                mod_items.push(quote! {
-                    #[cfg(feature = "rt")]
-                    extern "C" {
-                        fn DEFAULT_HANDLER();
-                    }
-
-                    #[cfg(feature = "rt")]
-                    #[allow(non_snake_case)]
-                    #[no_mangle]
-                    pub unsafe extern "C" fn DH_TRAMPOLINE() {
-                        DEFAULT_HANDLER();
-                    }
-                });
-            } else {
-                mod_items.push(quote! {
-                    #[cfg(all(target_arch = "arm", feature = "rt"))]
-                    global_asm!("
-                    .thumb_func
-                    DH_TRAMPOLINE:
-                        b DEFAULT_HANDLER
-                    ");
-
-                    /// Hack to compile on x86
-                    #[cfg(all(target_arch = "x86_64", feature = "rt"))]
-                    global_asm!("
-                    DH_TRAMPOLINE:
-                        jmp DEFAULT_HANDLER
-                    ");
-                })
-            }
-
-            mod_items.push(quote! {
-                #[cfg(feature = "rt")]
-                global_asm!(#aliases);
-
+            root.push(quote! {
                 #[cfg(feature = "rt")]
                 extern "C" {
                     #(fn #names();)*
                 }
 
-                #[allow(private_no_mangle_statics)]
                 #[cfg(feature = "rt")]
                 #[doc(hidden)]
                 #[link_section = ".vector_table.interrupts"]
                 #[no_mangle]
-                #[used]
-                pub static INTERRUPTS: [Option<unsafe extern "C" fn()>; #n] = [
+                pub static __INTERRUPTS: [Option<unsafe extern "C" fn()>; #n] = [
                     #(#elements,)*
                 ];
             });
@@ -178,106 +130,117 @@ pub fn render(device: &Device, target: &Target, peripherals: &[Peripheral]) -> R
         Target::None => {}
     }
 
-    mod_items.push(quote! {
+    let interrupt_enum = quote! {
         /// Enumeration of all the interrupts
         pub enum Interrupt {
             #(#variants)*
         }
 
-        unsafe impl Nr for Interrupt {
+        unsafe impl ::bare_metal::Nr for Interrupt {
             #[inline]
             fn nr(&self) -> u8 {
                 match *self {
                     #(#arms)*
                 }
             }
         }
+    };
 
-        use core::convert::TryFrom;
+    if *target == Target::CortexM {
+        root.push(interrupt_enum);
+    } else {
+        mod_items.push(quote! {
+            use core::convert::TryFrom;
 
-        #[derive(Debug, Copy, Clone)]
-        pub struct TryFromInterruptError(());
+            #[derive(Debug, Copy, Clone)]
+            pub struct TryFromInterruptError(());
 
-        impl TryFrom<u8> for Interrupt {
-            type Error = TryFromInterruptError;
+            impl TryFrom<u8> for Interrupt {
+                type Error = TryFromInterruptError;
 
-            #[inline]
-            fn try_from(value: u8) -> Result<Self, Self::Error> {
-                match value {
-                    #(#from_arms)*
-                    _ => Err(TryFromInterruptError(())),
+                #[inline]
+                fn try_from(value: u8) -> Result<Self, Self::Error> {
+                    match value {
+                        #(#from_arms)*
+                        _ => Err(TryFromInterruptError(())),
+                    }
                 }
             }
-        }
-    });
+        });
+    }
 
     if *target != Target::None {
         let abi = match *target {
             Target::Msp430 => "msp430-interrupt",
             _ => "C",
         };
-        mod_items.push(quote! {
-            #[cfg(feature = "rt")]
-            #[macro_export]
-            macro_rules! interrupt {
-                ($NAME:ident, $path:path, locals: {
-                    $($lvar:ident:$lty:ty = $lval:expr;)*
-                }) => {
-                    #[allow(non_snake_case)]
-                    mod $NAME {
-                        pub struct Locals {
-                            $(
-                                pub $lvar: $lty,
-                            )*
-                        }
-                    }
-
-                    #[allow(non_snake_case)]
-                    #[no_mangle]
-                    pub extern #abi fn $NAME() {
-                        // check that the handler exists
-                        let _ = $crate::interrupt::Interrupt::$NAME;
 
-                        static mut LOCALS: self::$NAME::Locals =
-                            self::$NAME::Locals {
+        if *target != Target::CortexM {
+            mod_items.push(quote! {
+                #[cfg(feature = "rt")]
+                #[macro_export]
+                macro_rules! interrupt {
+                    ($NAME:ident, $path:path, locals: {
+                        $($lvar:ident:$lty:ty = $lval:expr;)*
+                    }) => {
+                        #[allow(non_snake_case)]
+                        mod $NAME {
+                            pub struct Locals {
                                 $(
-                                    $lvar: $lval,
+                                    pub $lvar: $lty,
                                 )*
-                            };
+                            }
+                        }
 
-                        // type checking
-                        let f: fn(&mut self::$NAME::Locals) = $path;
-                        f(unsafe { &mut LOCALS });
-                    }
-                };
-                ($NAME:ident, $path:path) => {
-                    #[allow(non_snake_case)]
-                    #[no_mangle]
-                    pub extern #abi fn $NAME() {
-                        // check that the handler exists
-                        let _ = $crate::interrupt::Interrupt::$NAME;
-
-                        // type checking
-                        let f: fn() = $path;
-                        f();
+                        #[allow(non_snake_case)]
+                        #[no_mangle]
+                        pub extern #abi fn $NAME() {
+                            // check that the handler exists
+                            let _ = $crate::interrupt::Interrupt::$NAME;
+
+                            static mut LOCALS: self::$NAME::Locals =
+                                self::$NAME::Locals {
+                                    $(
+                                        $lvar: $lval,
+                                    )*
+                                };
+
+                            // type checking
+                            let f: fn(&mut self::$NAME::Locals) = $path;
+                            f(unsafe { &mut LOCALS });
+                        }
+                    };
+                    ($NAME:ident, $path:path) => {
+                        #[allow(non_snake_case)]
+                        #[no_mangle]
+                        pub extern #abi fn $NAME() {
+                            // check that the handler exists
+                            let _ = $crate::interrupt::Interrupt::$NAME;
+
+                            // type checking
+                            let f: fn() = $path;
+                            f();
+                        }
                     }
                 }
-            }
-        });
+            });
+        }
     }
 
-    let mut out = vec![];
-
     if interrupts.len() > 0 {
-        out.push(quote! {
-            pub use interrupt::Interrupt;
-
+        root.push(quote! {
             #[doc(hidden)]
             pub mod interrupt {
                 #(#mod_items)*
             }
         });
+
+        if *target != Target::CortexM {
+            root.push(quote! {
+                pub use interrupt::Interrupt;
+            });
+        }
     }
 
-    Ok(out)
+    Ok(root)
 }