unbreak msp430 / riscv; generate 3 files for cortex-m

Author: japaric

src/generate/device.rs

@@ -9,7 +9,7 @@ use Target;
 use generate::{interrupt, peripheral};
 
 /// Whole device generation
-pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>> {
+pub fn render(d: &Device, target: &Target, nightly: bool, device_x: &mut String) -> Result<Vec<Tokens>> {
     let mut out = vec![];
 
     let doc = format!(
@@ -43,6 +43,13 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
         #![no_std]
     });
 
+    if *target != Target::CortexM {
+        out.push(quote! {
+            #![feature(const_fn)]
+            #![feature(try_From)]
+        });
+    }
+
     if nightly {
         out.push(quote! {
             #![feature(untagged_unions)]
@@ -93,7 +100,7 @@ pub fn render(d: &Device, target: &Target, nightly: bool) -> Result<Vec<Tokens>>
         });
     }
 
-    out.extend(interrupt::render(target, &d.peripherals)?);
+    out.extend(interrupt::render(target, &d.peripherals, device_x)?);
 
     const CORE_PERIPHERALS: &[&str] = &[
         "CBP", "CPUID", "DCB", "DWT", "FPB", "FPU", "ITM", "MPU", "NVIC", "SCB", "SYST", "TPIU"

src/generate/interrupt.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::fmt::Write;
 
 use cast::u64;
 use quote::Tokens;
@@ -10,7 +11,11 @@ use util::{self, ToSanitizedUpperCase};
 use Target;
 
 /// Generates code for `src/interrupt.rs`
-pub fn render(target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>> {
+pub fn render(
+    target: &Target,
+    peripherals: &[Peripheral],
+    device_x: &mut String,
+) -> Result<Vec<Tokens>> {
     let interrupts = peripherals
         .iter()
         .flat_map(|p| p.interrupt.iter())
@@ -32,7 +37,7 @@ pub fn render(target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>
     let mut mod_items = vec![];
     for interrupt in &interrupts {
         while pos < interrupt.value {
-            elements.push(quote!(None));
+            elements.push(quote!(Vector { _reserved: 0 }));
             pos += 1;
         }
         pos += 1;
@@ -63,42 +68,87 @@ pub fn render(target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>
             #value => Ok(Interrupt::#name_uc),
         });
 
-        elements.push(quote!(Some(#name_uc)));
+        elements.push(quote!(Vector { _handler: #name_uc }));
         names.push(name_uc);
     }
 
-    let aliases = names
-        .iter()
-        .map(|n| {
-            format!(
-                "
-.weak {0}
-{0} = DH_TRAMPOLINE",
-                n
-            )
-        })
-        .collect::<Vec<_>>()
-        .concat();
-
     let n = util::unsuffixed(u64(pos));
     match *target {
         Target::CortexM => {
+            for name in &names {
+                writeln!(device_x, "PROVIDE({} = DefaultHandler);" ,name).unwrap();
+            }
+
             root.push(quote! {
                 #[cfg(feature = "rt")]
                 extern "C" {
                     #(fn #names();)*
                 }
 
+                #[doc(hidden)]
+                pub union Vector {
+                    _handler: unsafe extern "C" fn(),
+                    _reserved: u32,
+                }
+
                 #[cfg(feature = "rt")]
                 #[doc(hidden)]
                 #[link_section = ".vector_table.interrupts"]
                 #[no_mangle]
-                pub static __INTERRUPTS: [Option<unsafe extern "C" fn()>; #n] = [
+                pub static __INTERRUPTS: [Vector; #n] = [
                     #(#elements,)*
                 ];
+
+                /// Macro to override a device specific interrupt handler
+                #[cfg(feature = "rt")]
+                #[macro_export]
+                macro_rules! interrupt {
+                    ($Name:ident, $handler:path,state: $State:ty = $initial_state:expr) => {
+                        #[allow(unsafe_code)]
+                        #[no_mangle]
+                        pub unsafe extern "C" fn $Name() {
+                            static mut STATE: $State = $initial_state;
+
+                            // check that this interrupt exists
+                            let _ = $crate::Interrupt::$Name;
+
+                            // validate the signature of the user provided handler
+                            let f: fn(&mut $State) = $handler;
+
+                            f(&mut STATE)
+                        }
+                    };
+
+                    ($Name:ident, $handler:path) => {
+                        #[allow(unsafe_code)]
+                        #[no_mangle]
+                        pub unsafe extern "C" fn $Name() {
+                            // check that this interrupt exists
+                            let _ = $crate::Interrupt::$Name;
+
+                            // validate the signature of the user provided handler
+                            let f: fn() = $handler;
+
+                            f()
+                        }
+                    };
+                }
             });
         }
         Target::Msp430 => {
+            let aliases = names
+                .iter()
+                .map(|n| {
+                    format!(
+                        "
+.weak {0}
+{0} = DH_TRAMPOLINE",
+                        n
+                    )
+                })
+                .collect::<Vec<_>>()
+                .concat();
+
             mod_items.push(quote! {
                 #[cfg(feature = "rt")]
                 global_asm!("
@@ -114,14 +164,20 @@ pub fn render(target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>
                     #(fn #names();)*
                 }
 
+                #[doc(hidden)]
+                pub union Vector {
+                    _handler: unsafe extern "msp430-interrupt" fn(),
+                    _reserved: u32,
+                }
+
                 #[allow(private_no_mangle_statics)]
                 #[cfg(feature = "rt")]
                 #[doc(hidden)]
                 #[link_section = ".vector_table.interrupts"]
                 #[no_mangle]
                 #[used]
                 pub static INTERRUPTS:
-                    [Option<unsafe extern "msp430-interrupt" fn()>; #n] = [
+                    [Vector; #n] = [
                         #(#elements,)*
                     ];
             });
@@ -152,6 +208,8 @@ pub fn render(target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>
         mod_items.push(quote! {
             use core::convert::TryFrom;
 
+            #interrupt_enum
+
             #[derive(Debug, Copy, Clone)]
             pub struct TryFromInterruptError(());
 

src/main.rs

@@ -16,8 +16,10 @@ mod generate;
 mod util;
 
 use std::fs::File;
-use std::{io, process};
+use std::process;
+use std::io::{self, Write};
 
+use quote::Tokens;
 use clap::{App, Arg};
 
 use errors::*;
@@ -98,14 +100,21 @@ fn run() -> Result<()> {
 
     let nightly = matches.is_present("nightly_features");
 
-    let items = generate::device::render(&device, &target, nightly)?;
-
-    println!(
-        "{}",
-        quote! {
-            #(#items)*
-        }
-    );
+    let mut device_x = String::new();
+    let items = generate::device::render(&device, &target, nightly, &mut device_x)?;
+
+    if target == Target::CortexM {
+        writeln!(File::create("lib.rs").unwrap(), "{}", quote!(#(#items)*)).unwrap();
+        writeln!(File::create("device.x").unwrap(), "{}", device_x).unwrap();
+        writeln!(File::create("build.rs").unwrap(), "{}", build_rs()).unwrap();
+    } else {
+        println!(
+            "{}",
+            quote! {
+                #(#items)*
+            }
+        );
+    }
 
     Ok(())
 }
@@ -132,3 +141,28 @@ fn main() {
         process::exit(1);
     }
 }
+
+fn build_rs() -> Tokens {
+    quote! {
+        use std::env;
+        use std::fs::File;
+        use std::io::Write;
+        use std::path::PathBuf;
+
+        fn main() {
+            if env::var_os("CARGO_FEATURE_RT").is_some() {
+                // Put the linker script somewhere the linker can find it
+                let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+                File::create(out.join("device.x"))
+                    .unwrap()
+                    .write_all(include_bytes!("device.x"))
+                    .unwrap();
+                println!("cargo:rustc-link-search={}", out.display());
+
+                println!("cargo:rerun-if-changed=device.x");
+            }
+
+            println!("cargo:rerun-if-changed=build.rs");
+        }
+    }
+}