From bc9499a57521b9177108233cb3aab2ad51f673ee Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sat, 18 Aug 2018 22:45:13 +0200 Subject: [PATCH 1/3] turn macros into attributes --- .gitignore | 1 + Cargo.toml | 1 + ci/script.sh | 2 + examples/alignment.rs | 4 +- examples/data_overflow.rs | 4 +- examples/device.rs | 5 +- examples/minimal.rs | 6 +- examples/override-exception.rs | 13 +- examples/pre_init.rs | 8 +- examples/state.rs | 12 +- macros/Cargo.toml | 17 ++ macros/src/lib.rs | 462 +++++++++++++++++++++++++++++++++ src/lib.rs | 263 +------------------ 13 files changed, 517 insertions(+), 281 deletions(-) create mode 100644 macros/Cargo.toml create mode 100644 macros/src/lib.rs diff --git a/.gitignore b/.gitignore index c71d6dbd..d8748d64 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ **/*.rs.bk +.#* Cargo.lock bin/*.after bin/*.before diff --git a/Cargo.toml b/Cargo.toml index 0dfbaf7f..016cdc9d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,7 @@ version = "0.5.3" [dependencies] r0 = "0.2.1" +cortex-m-rt-macros = { path = "macros", version = "0.1.0" } [dev-dependencies] panic-semihosting = "0.3.0" diff --git a/ci/script.sh b/ci/script.sh index 7d1cc677..242a546e 100644 --- a/ci/script.sh +++ b/ci/script.sh @@ -5,6 +5,8 @@ main() { cargo check --target $TARGET --features device + ( cd macros && cargo check && cargo test ) + local examples=( alignment minimal diff --git a/examples/alignment.rs b/examples/alignment.rs index 56358516..25d755d0 100644 --- a/examples/alignment.rs +++ b/examples/alignment.rs @@ -4,13 +4,12 @@ #![no_main] #![no_std] -#[macro_use(entry)] extern crate cortex_m_rt as rt; extern crate panic_abort; use core::ptr; -entry!(main); +use rt::entry; static mut BSS1: u16 = 0; static mut BSS2: u8 = 0; @@ -19,6 +18,7 @@ static mut DATA2: u16 = 1; static RODATA1: &[u8; 3] = b"012"; static RODATA2: &[u8; 2] = b"34"; +#[entry] fn main() -> ! { unsafe { let _bss1 = ptr::read_volatile(&BSS1); diff --git a/examples/data_overflow.rs b/examples/data_overflow.rs index 396f1c8a..ceec18b1 100644 --- a/examples/data_overflow.rs +++ b/examples/data_overflow.rs @@ -5,13 +5,12 @@ #![no_main] #![no_std] -#[macro_use(entry)] extern crate cortex_m_rt as rt; extern crate panic_abort; use core::ptr; -entry!(main); +use rt::entry; // This large static array uses most of .rodata static RODATA: [u8; 48*1024] = [1u8; 48*1024]; @@ -20,6 +19,7 @@ static RODATA: [u8; 48*1024] = [1u8; 48*1024]; // without also overflowing RAM. static mut DATA: [u8; 16*1024] = [1u8; 16*1024]; +#[entry] fn main() -> ! { unsafe { let _bigdata = ptr::read_volatile(&RODATA as *const u8); diff --git a/examples/device.rs b/examples/device.rs index 4395db25..950a5646 100644 --- a/examples/device.rs +++ b/examples/device.rs @@ -5,13 +5,12 @@ #![no_main] #![no_std] -#[macro_use(entry)] extern crate cortex_m_rt as rt; extern crate panic_semihosting; -// the program entry point -entry!(main); +use rt::entry; +#[entry] fn main() -> ! { loop {} } diff --git a/examples/minimal.rs b/examples/minimal.rs index a0360463..6f60180e 100644 --- a/examples/minimal.rs +++ b/examples/minimal.rs @@ -5,13 +5,13 @@ #![no_main] #![no_std] -#[macro_use(entry)] extern crate cortex_m_rt as rt; extern crate panic_semihosting; -// the program entry point -entry!(main); +use rt::entry; +// the program entry point +#[entry] fn main() -> ! { loop {} } diff --git a/examples/override-exception.rs b/examples/override-exception.rs index 2f100a20..dca31e66 100644 --- a/examples/override-exception.rs +++ b/examples/override-exception.rs @@ -6,28 +6,23 @@ #![no_std] extern crate cortex_m; -#[macro_use(entry, exception)] extern crate cortex_m_rt as rt; extern crate panic_semihosting; use cortex_m::asm; -use rt::ExceptionFrame; - -// the program entry point -entry!(main); +use rt::{entry, exception, ExceptionFrame}; +#[entry] fn main() -> ! { loop {} } -exception!(*, default_handler); - +#[exception(DefaultHandler)] fn default_handler(_irqn: i16) { asm::bkpt(); } -exception!(HardFault, hard_fault); - +#[exception(HardFault)] fn hard_fault(_ef: &ExceptionFrame) -> ! { asm::bkpt(); diff --git a/examples/pre_init.rs b/examples/pre_init.rs index 7258936f..00e2f2c1 100644 --- a/examples/pre_init.rs +++ b/examples/pre_init.rs @@ -4,19 +4,17 @@ #![no_main] #![no_std] -#[macro_use(entry, pre_init)] extern crate cortex_m_rt as rt; extern crate panic_semihosting; -pre_init!(disable_watchdog); +use rt::{entry, pre_init}; +#[pre_init] unsafe fn disable_watchdog() { // Do what you need to disable the watchdog. } -// the program entry point -entry!(main); - +#[entry] fn main() -> ! { loop {} } diff --git a/examples/state.rs b/examples/state.rs index dbacdaf4..72ca194f 100644 --- a/examples/state.rs +++ b/examples/state.rs @@ -5,20 +5,18 @@ #![no_main] #![no_std] -#[macro_use(entry, exception)] extern crate cortex_m_rt as rt; extern crate panic_semihosting; -// the program entry point -entry!(main); +use rt::{entry, exception}; +#[entry] fn main() -> ! { loop {} } // exception handler with state -exception!(SysTick, sys_tick, state: u32 = 0); - -fn sys_tick(state: &mut u32) { - *state += 1; +#[exception(SysTick, static STATE: u32 = 0)] +fn sys_tick() { + *STATE += 1; } diff --git a/macros/Cargo.toml b/macros/Cargo.toml new file mode 100644 index 00000000..85e8cd1a --- /dev/null +++ b/macros/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "cortex-m-rt-macros" +version = "0.1.0" +authors = ["Jorge Aparicio "] + +[lib] +proc-macro = true + +[dependencies] +quote = "0.6.6" + +[dependencies.syn] +features = ["extra-traits", "full"] +version = "0.14.8" + +[dev-dependencies] +cortex-m-rt = { path = ".." } diff --git a/macros/src/lib.rs b/macros/src/lib.rs new file mode 100644 index 00000000..3aa494d6 --- /dev/null +++ b/macros/src/lib.rs @@ -0,0 +1,462 @@ +#![deny(warnings)] + +extern crate proc_macro; +#[macro_use] +extern crate quote; +#[macro_use] +extern crate syn; + +use syn::synom::Synom; +use syn::token::{Colon, Comma, Eq, Static}; +use syn::{Expr, FnArg, Ident, ItemFn, ReturnType, Type, Visibility}; + +use proc_macro::TokenStream; + +/// Attribute to declare the entry point of the program +/// +/// **NOTE** This macro must be invoked once and must be invoked from an accessible module, ideally +/// from the root of the crate. +/// +/// The specified function will be called by the reset handler *after* RAM has been initialized. In +/// the case of the `thumbv7em-none-eabihf` target the FPU will also be enabled before the function +/// is called. +/// +/// The type of the specified function must be `fn() -> !` (never ending function) +/// +/// # Examples +/// +/// ``` no_run +/// # #![no_main] +/// # use cortex_m_rt_macros::entry; +/// #[entry] +/// fn main() -> ! { +/// loop { +/// /* .. */ +/// } +/// } +/// ``` +#[proc_macro_attribute] +pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream { + let f: ItemFn = syn::parse(input).expect("`#[entry]` must be applied to a function"); + + // check the function signature + assert!( + f.constness.is_none() + && f.vis == Visibility::Inherited + && f.unsafety.is_none() + && f.abi.is_none() + && f.decl.inputs.is_empty() + && f.decl.generics.params.is_empty() + && f.decl.generics.where_clause.is_none() + && f.decl.variadic.is_none() + && match f.decl.output { + ReturnType::Default => false, + ReturnType::Type(_, ref ty) => match **ty { + Type::Never(_) => true, + _ => false, + }, + }, + "`#[entry]` function must have signature `fn() -> !`" + ); + + assert_eq!( + args.to_string(), + "", + "`entry` attribute must have no arguments" + ); + + // XXX should we blacklist other attributes? + let attrs = f.attrs; + let ident = f.ident; + let block = f.block; + + quote!( + #[export_name = "main"] + #(#attrs)* + pub fn #ident() -> ! #block + ).into() +} + +struct ExceptionArgs { + first: Ident, + second: Option, +} + +impl Synom for ExceptionArgs { + named!(parse -> Self, do_parse!( + first: syn!(Ident) >> + second: option!(syn!(State)) >> ( + ExceptionArgs { first, second } + ) + )); +} + +struct State { + _comma: Comma, + _static: Static, + ident: Ident, + _colon: Colon, + ty: Type, + _eq: Eq, + expr: Expr, +} + +impl Synom for State { + named!(parse -> Self, do_parse!( + _comma: punct!(,) >> + _static: syn!(Static) >> + ident: syn!(Ident) >> + _colon: punct!(:) >> + ty: syn!(Type) >> + _eq: punct!(=) >> + expr: syn!(Expr) >> ( + State { _comma, _static, ident, _colon, ty, _eq, expr } + ) + )); +} + +/// Attribute to declare an exception handler +/// +/// **NOTE** This macro must be invoked from an accessible module, ideally from the root of the +/// crate. +/// +/// # Syntax +/// +/// ``` +/// # use cortex_m_rt_macros::exception; +/// #[exception(SysTick, static COUNT: u32 = 0)] +/// fn handler() { +/// // .. +/// } +/// +/// # fn main() {} +/// ``` +/// +/// where the first argument can be one of: +/// +/// - `DefaultHandler` +/// - `NonMaskableInt` +/// - `HardFault` +/// - `MemoryManagement` (a) +/// - `BusFault` (a) +/// - `UsageFault` (a) +/// - `SecureFault` (b) +/// - `SVCall` +/// - `DebugMonitor` (a) +/// - `PendSV` +/// - `SysTick` +/// +/// and the second is optional. +/// +/// (a) Not available on Cortex-M0 variants (`thumbv6m-none-eabi`) +/// +/// (b) Only available on ARMv8-M +/// +/// # Usage +/// +/// `#[exception(HardFault)]` sets the hard fault handler. The handler must have signature +/// `fn(&ExceptionFrame) -> !`. This handler is not allowed to return as that can cause undefined +/// behavior. +/// +/// `#[exception(DefaultHandler)]` sets the *default* handler. All exceptions which have not been +/// assigned a handler will be serviced by this handler. This handler must have signature `fn(irqn: +/// i16)`. `irqn` is the IRQ number (See CMSIS); `irqn` will be a negative number when the handler +/// is servicing a core exception; `irqn` will be a positive number when the handler is servicing a +/// device specific exception (interrupt). +/// +/// `#[exception(Name)]` overrides the default handler for the exception with the given `Name`. +/// +/// # Examples +/// +/// - Setting the `HardFault` handler +/// +/// ``` +/// # extern crate cortex_m_rt; +/// # extern crate cortex_m_rt_macros; +/// # use cortex_m_rt_macros::exception; +/// #[exception(HardFault)] +/// fn hard_fault(ef: &cortex_m_rt::ExceptionFrame) -> ! { +/// // prints the exception frame as a panic message +/// panic!("{:#?}", ef); +/// } +/// +/// # fn main() {} +/// ``` +/// +/// - Setting the default handler +/// +/// ``` +/// # use cortex_m_rt_macros::exception; +/// #[exception(DefaultHandler)] +/// fn default_handler(irqn: i16) { +/// println!("IRQn = {}", irqn); +/// } +/// +/// # fn main() {} +/// ``` +/// +/// - Overriding the `SysTick` handler +/// +/// ``` +/// extern crate cortex_m_rt as rt; +/// +/// use rt::exception; +/// +/// #[exception(SysTick, static COUNT: i32 = 0)] +/// fn sys_tick() { +/// *COUNT += 1; +/// +/// println!("{}", COUNT); +/// } +/// +/// # fn main() {} +/// ``` +#[proc_macro_attribute] +pub fn exception(args: TokenStream, input: TokenStream) -> TokenStream { + let f: ItemFn = syn::parse(input).expect("`#[exception]` must be applied to a function"); + let args: ExceptionArgs = syn::parse(args).expect( + "`exception` attribute expects the exception name as its argument. \ + e.g. `#[exception(HardFault)]`", + ); + let name = args.first; + let name_s = name.to_string(); + + enum Exception { + DefaultHandler, + HardFault, + Other, + } + + // first validation of the exception name + let exn = match &*name_s { + "DefaultHandler" => Exception::DefaultHandler, + "HardFault" => Exception::HardFault, + // NOTE that at this point we don't check if the exception is available on the target (e.g. + // MemoryManagement is not available on Cortex-M0) + "NonMaskableInt" | "MemoryManagement" | "BusFault" | "UsageFault" | "SecureFault" + | "SVCall" | "DebugMonitor" | "PendSV" | "SysTick" => Exception::Other, + _ => panic!("{} is not a valid exception name", name_s), + }; + + // XXX should we blacklist other attributes? + let attrs = f.attrs; + let ident = f.ident; + let block = f.block; + let stmts = &block.stmts; + + match exn { + Exception::DefaultHandler => { + assert!( + f.constness.is_none() + && f.vis == Visibility::Inherited + && f.unsafety.is_none() + && f.abi.is_none() + && f.decl.inputs.len() == 1 + && f.decl.generics.params.is_empty() + && f.decl.generics.where_clause.is_none() + && f.decl.variadic.is_none() + && match f.decl.output { + ReturnType::Default => true, + ReturnType::Type(_, ref ty) => match **ty { + Type::Tuple(ref tuple) => tuple.elems.is_empty(), + _ => false, + }, + }, + "`#[exception(DefaultHandler)]` function must have signature `fn(i16)`" + ); + + assert!( + args.second.is_none(), + "`#[exception(DefaultHandler)]` takes no additional arguments" + ); + + let arg = match f.decl.inputs[0] { + FnArg::Captured(ref arg) => arg, + _ => unreachable!(), + }; + + quote!( + #[export_name = #name_s] + #(#attrs)* + pub fn #ident() { + extern crate core; + + const SCB_ICSR: *const u32 = 0xE000_ED04 as *const u32; + + let #arg = unsafe { core::ptr::read(SCB_ICSR) as u8 as i16 - 16 }; + + #(#stmts)* + } + ).into() + } + Exception::HardFault => { + assert!( + f.constness.is_none() + && f.vis == Visibility::Inherited + && f.unsafety.is_none() + && f.abi.is_none() + && f.decl.inputs.len() == 1 + && match f.decl.inputs[0] { + FnArg::Captured(ref arg) => match arg.ty { + Type::Reference(ref r) => { + r.lifetime.is_none() && r.mutability.is_none() + } + _ => false, + }, + _ => false, + } + && f.decl.generics.params.is_empty() + && f.decl.generics.where_clause.is_none() + && f.decl.variadic.is_none() + && match f.decl.output { + ReturnType::Default => false, + ReturnType::Type(_, ref ty) => match **ty { + Type::Never(_) => true, + _ => false, + }, + }, + "`#[exception(HardFault)]` function must have signature `fn(&ExceptionFrame) -> !`" + ); + + assert!( + args.second.is_none(), + "`#[exception(HardFault)]` takes no additional arguments" + ); + + let arg = match f.decl.inputs[0] { + FnArg::Captured(ref arg) => arg, + _ => unreachable!(), + }; + + let pat = &arg.pat; + + quote!( + #[export_name = "UserHardFault"] + #(#attrs)* + pub unsafe extern "C" fn #ident(#arg) -> ! { + extern crate cortex_m_rt; + + // further type check of the input argument + let #pat: &cortex_m_rt::ExceptionFrame = #pat; + + #(#stmts)* + } + ).into() + } + Exception::Other => { + assert!( + f.constness.is_none() + && f.vis == Visibility::Inherited + && f.unsafety.is_none() + && f.abi.is_none() + && f.decl.inputs.is_empty() + && f.decl.generics.params.is_empty() + && f.decl.generics.where_clause.is_none() + && f.decl.variadic.is_none() + && match f.decl.output { + ReturnType::Default => true, + ReturnType::Type(_, ref ty) => match **ty { + Type::Tuple(ref tuple) => tuple.elems.is_empty(), + _ => false, + }, + }, + "`#[exception]` functions must have signature `fn()`" + ); + + if let Some(second) = args.second { + let ty = second.ty; + let expr = second.expr; + let state = second.ident; + + quote!( + #[export_name = #name_s] + #(#attrs)* + pub fn #ident() { + extern crate cortex_m_rt; + + cortex_m_rt::Exception::#name; + + static mut __STATE__: #ty = #expr; + + #[allow(non_snake_case)] + let #state: &mut #ty = unsafe { &mut __STATE__ }; + + #(#stmts)* + } + ).into() + } else { + quote!( + #[export_name = #name_s] + #(#attrs)* + pub fn #ident() { + extern crate cortex_m_rt; + + cortex_m_rt::Exception::#name; + + #(#stmts)* + } + ).into() + } + } + } +} + +/// Attribute to mark which function will be called at the beginning of the reset handler. +/// +/// The function must have the signature of `unsafe fn()`. +/// +/// The function passed will be called before static variables are initialized. Any access of static +/// variables will result in undefined behavior. +/// +/// # Examples +/// +/// ``` +/// # use cortex_m_rt_macros::pre_init; +/// #[pre_init] +/// unsafe fn before_main() { +/// // do something here +/// } +/// +/// # fn main() {} +/// ``` +#[proc_macro_attribute] +pub fn pre_init(args: TokenStream, input: TokenStream) -> TokenStream { + let f: ItemFn = syn::parse(input).expect("`#[pre_init]` must be applied to a function"); + + // check the function signature + assert!( + f.constness.is_none() + && f.vis == Visibility::Inherited + && f.unsafety.is_some() + && f.abi.is_none() + && f.decl.inputs.is_empty() + && f.decl.generics.params.is_empty() + && f.decl.generics.where_clause.is_none() + && f.decl.variadic.is_none() + && match f.decl.output { + ReturnType::Default => true, + ReturnType::Type(_, ref ty) => match **ty { + Type::Tuple(ref tuple) => tuple.elems.is_empty(), + _ => false, + }, + }, + "`#[pre_init]` function must have signature `unsafe fn()`" + ); + + assert_eq!( + args.to_string(), + "", + "`pre_init` attribute must have no arguments" + ); + + // XXX should we blacklist other attributes? + let attrs = f.attrs; + let ident = f.ident; + let block = f.block; + + quote!( + #[export_name = "__pre_init"] + #(#attrs)* + pub unsafe fn #ident() #block + ).into() +} diff --git a/src/lib.rs b/src/lib.rs index 10f60f6b..526b28b9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -94,18 +94,16 @@ //! #![no_main] //! #![no_std] //! -//! #[macro_use(entry, exception)] //! extern crate cortex_m_rt as rt; //! //! // makes `panic!` print messages to the host stderr using semihosting //! extern crate panic_semihosting; //! -//! use rt::ExceptionFrame; +//! use rt::entry; //! //! // use `main` as the entry point of this application -//! entry!(main); -//! //! // `main` is not allowed to return +//! #[entry] //! fn main() -> ! { //! // initialization //! @@ -113,20 +111,6 @@ //! // application logic //! } //! } -//! -//! // define the hard fault handler -//! exception!(HardFault, hard_fault); -//! -//! fn hard_fault(ef: &ExceptionFrame) -> ! { -//! panic!("{:#?}", ef); -//! } -//! -//! // define the default exception handler -//! exception!(*, default_handler); -//! -//! fn default_handler(irqn: i16) { -//! panic!("unhandled exception (IRQn={})", irqn); -//! } //! ``` //! //! To actually build this program you need to place a `memory.x` linker script somewhere the linker @@ -397,11 +381,14 @@ #![deny(warnings)] #![no_std] +extern crate cortex_m_rt_macros as macros; extern crate r0; use core::fmt; use core::sync::atomic::{self, Ordering}; +pub use macros::{entry, exception, pre_init}; + /// Registers stacked (pushed into the stack) during an exception #[derive(Clone, Copy)] #[repr(C)] @@ -474,8 +461,6 @@ pub static __RESET_VECTOR: unsafe extern "C" fn() -> ! = Reset; #[no_mangle] pub unsafe extern "C" fn Reset() -> ! { extern "C" { - // This symbol will be provided by the user via the `entry!` macro - fn main() -> !; // These symbols come from `link.x` static mut __sbss: u32; @@ -485,11 +470,17 @@ pub unsafe extern "C" fn Reset() -> ! { static mut __edata: u32; static __sidata: u32; + } + + extern "Rust" { + // This symbol will be provided by the user via `#[entry]` + fn main() -> !; + + // This symbol will be provided by the user via `#[pre_init]` fn __pre_init(); } - let pre_init: unsafe extern "C" fn() = __pre_init; - pre_init(); + __pre_init(); // Initialize RAM r0::zero_bss(&mut __sbss, &mut __ebss); @@ -551,31 +542,6 @@ pub unsafe extern "C" fn DefaultHandler_() -> ! { #[no_mangle] pub unsafe extern "C" fn DefaultPreInit() {} -/// Macro to define the entry point of the program -/// -/// **NOTE** This macro must be invoked once and must be invoked from an accessible module, ideally -/// from the root of the crate. -/// -/// Usage: `entry!(path::to::entry::point)` -/// -/// The specified function will be called by the reset handler *after* RAM has been initialized. In -/// the case of the `thumbv7em-none-eabihf` target the FPU will also be enabled before the function -/// is called. -/// -/// The signature of the specified function must be `fn() -> !` (never ending function) -#[macro_export] -macro_rules! entry { - ($path:expr) => { - #[export_name = "main"] - pub extern "C" fn __impl_main() -> ! { - // validate the signature of the program entry point - let f: fn() -> ! = $path; - - f() - } - }; -} - /* Exceptions */ #[doc(hidden)] pub enum Exception { @@ -721,206 +687,3 @@ pub static __INTERRUPTS: [unsafe extern "C" fn(); 32] = [{ DefaultHandler }; 32]; - -/// Macro to set or override a processor core exception handler -/// -/// **NOTE** This macro must be invoked from an accessible module, ideally from the root of the -/// crate. -/// -/// # Syntax -/// -/// ``` ignore -/// exception!( -/// // Name of the exception -/// $Name:ident, -/// -/// // Path to the exception handler (a function) -/// $handler:expr, -/// -/// // Optional, state preserved across invocations of the handler -/// state: $State:ty = $initial_state:expr, -/// ); -/// ``` -/// -/// where `$Name` can be one of: -/// -/// - `*` -/// - `NonMaskableInt` -/// - `HardFault` -/// - `MemoryManagement` (a) -/// - `BusFault` (a) -/// - `UsageFault` (a) -/// - `SecureFault` (b) -/// - `SVCall` -/// - `DebugMonitor` (a) -/// - `PendSV` -/// - `SysTick` -/// -/// (a) Not available on Cortex-M0 variants (`thumbv6m-none-eabi`) -/// -/// (b) Only available on ARMv8-M -/// -/// # Usage -/// -/// `exception!(HardFault, ..)` sets the hard fault handler. The handler must have signature -/// `fn(&ExceptionFrame) -> !`. This handler is not allowed to return as that can cause undefined -/// behavior. It's mandatory to set the `HardFault` handler somewhere in the dependency graph of an -/// application. -/// -/// `exception!(*, ..)` sets the *default* handler. All exceptions which have not been assigned a -/// handler will be serviced by this handler. This handler must have signature `fn(irqn: i16)`. -/// `irqn` is the IRQ number (cf. CMSIS); `irqn` will be a negative number when the handler is -/// servicing a core exception; `irqn` will be a positive number when the handler is servicing a -/// device specific exception (interrupt). It's mandatory to set the default handler somewhere -/// in the dependency graph of an application. -/// -/// `exception!($Exception, ..)` overrides the default handler for `$Exception`. All exceptions, -/// except for `HardFault`, can be assigned some `$State`. -/// -/// # Examples -/// -/// - Setting the `HardFault` handler -/// -/// ``` -/// #[macro_use(exception)] -/// extern crate cortex_m_rt as rt; -/// -/// use rt::ExceptionFrame; -/// -/// exception!(HardFault, hard_fault); -/// -/// fn hard_fault(ef: &ExceptionFrame) -> ! { -/// // prints the exception frame as a panic message -/// panic!("{:#?}", ef); -/// } -/// -/// # fn main() {} -/// ``` -/// -/// - Setting the default handler -/// -/// ``` -/// #[macro_use(exception)] -/// extern crate cortex_m_rt as rt; -/// -/// exception!(*, default_handler); -/// -/// fn default_handler(irqn: i16) { -/// println!("IRQn = {}", irqn); -/// } -/// -/// # fn main() {} -/// ``` -/// -/// - Overriding the `SysTick` handler -/// -/// ``` -/// #[macro_use(exception)] -/// extern crate cortex_m_rt as rt; -/// -/// exception!(SysTick, sys_tick, state: u32 = 0); -/// -/// fn sys_tick(count: &mut u32) { -/// println!("count = {}", *count); -/// -/// *count += 1; -/// } -/// -/// # fn main() {} -/// ``` -#[macro_export] -macro_rules! exception { - (* , $handler:expr) => { - #[allow(unsafe_code)] - #[deny(private_no_mangle_fns)] // raise an error if this item is not accessible - #[no_mangle] - pub unsafe extern "C" fn DefaultHandler() { - extern crate core; - - // validate the signature of the user provided handler - let f: fn(i16) = $handler; - - const SCB_ICSR: *const u32 = 0xE000_ED04 as *const u32; - - // NOTE not volatile so the compiler can opt the load operation away if the value is - // unused - f(core::ptr::read(SCB_ICSR) as u8 as i16 - 16) - } - }; - - (HardFault, $handler:expr) => { - #[allow(unsafe_code)] - #[deny(private_no_mangle_fns)] // raise an error if this item is not accessible - #[no_mangle] - pub unsafe extern "C" fn UserHardFault(ef: &$crate::ExceptionFrame) { - // validate the signature of the user provided handler - let f: fn(&$crate::ExceptionFrame) -> ! = $handler; - - f(ef) - } - }; - - ($Name:ident, $handler:expr,state: $State:ty = $initial_state:expr) => { - #[allow(unsafe_code)] - #[deny(private_no_mangle_fns)] // raise an error if this item is not accessible - #[no_mangle] - pub unsafe extern "C" fn $Name() { - static mut STATE: $State = $initial_state; - - // check that this exception exists - let _ = $crate::Exception::$Name; - - // validate the signature of the user provided handler - let f: fn(&mut $State) = $handler; - - f(&mut STATE) - } - }; - - ($Name:ident, $handler:expr) => { - #[allow(unsafe_code)] - #[deny(private_no_mangle_fns)] // raise an error if this item is not accessible - #[no_mangle] - pub unsafe extern "C" fn $Name() { - // check that this exception exists - let _ = $crate::Exception::$Name; - - // validate the signature of the user provided handler - let f: fn() = $handler; - - f() - } - }; -} - -/// Macro to set the function to be called at the beginning of the reset handler. -/// -/// The function must have the signature of `unsafe fn()`. -/// -/// The function passed will be called before static variables are initialized. Any access of static -/// variables will result in undefined behavior. -/// -/// # Examples -/// -/// ``` ignore -/// pre_init!(foo::bar); -/// -/// mod foo { -/// pub unsafe fn bar() { -/// // do something here -/// } -/// } -/// ``` -#[macro_export] -macro_rules! pre_init { - ($handler:path) => { - #[allow(unsafe_code)] - #[deny(private_no_mangle_fns)] // raise an error if this item is not accessible - #[no_mangle] - pub unsafe extern "C" fn __pre_init() { - // validate user handler - let f: unsafe fn() = $handler; - f(); - } - }; -} From 05f65bbf6d04b9832d0c541e2dcaf2ade2dc6a6b Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Fri, 31 Aug 2018 01:58:40 +0200 Subject: [PATCH 2/3] add `#[ramfunc]` attribute this attribute lets you place functions in RAM closes #42 --- link.x.in | 14 ++++++++++++ macros/Cargo.toml | 1 + macros/src/lib.rs | 55 +++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 7 +++++- 4 files changed, 76 insertions(+), 1 deletion(-) diff --git a/link.x.in b/link.x.in index 3d71811e..9db3ebb3 100644 --- a/link.x.in +++ b/link.x.in @@ -115,6 +115,20 @@ SECTIONS /* LMA of .data */ __sidata = LOADADDR(.data); + .ramfunc : ALIGN(4) + { + *(.ramfunc.*); + + . = ALIGN(4); /* 4-byte align the end (VMA) of this section */ + } > RAM AT > FLASH + + /* VMA of .ramfunc */ + __sramfunc = ADDR(.ramfunc); + __eramfunc = ADDR(.ramfunc) + SIZEOF(.ramfunc); + + /* LMA of .ramfunc */ + __siramfunc = LOADADDR(.ramfunc); + /* ### .bss */ .bss : ALIGN(4) { diff --git a/macros/Cargo.toml b/macros/Cargo.toml index 85e8cd1a..b18b94c7 100644 --- a/macros/Cargo.toml +++ b/macros/Cargo.toml @@ -8,6 +8,7 @@ proc-macro = true [dependencies] quote = "0.6.6" +rand = "0.5.5" [dependencies.syn] features = ["extra-traits", "full"] diff --git a/macros/src/lib.rs b/macros/src/lib.rs index 3aa494d6..ef2e59a3 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -3,9 +3,11 @@ extern crate proc_macro; #[macro_use] extern crate quote; +extern crate rand; #[macro_use] extern crate syn; +use rand::Rng; use syn::synom::Synom; use syn::token::{Colon, Comma, Eq, Static}; use syn::{Expr, FnArg, Ident, ItemFn, ReturnType, Type, Visibility}; @@ -460,3 +462,56 @@ pub fn pre_init(args: TokenStream, input: TokenStream) -> TokenStream { pub unsafe fn #ident() #block ).into() } + +/// Attribute to place a function in RAM +/// +/// This attribute can *not* be used on generic functions. +/// +/// # Examples +/// +/// ``` +/// # use cortex_m_rt_macros::ramfunc; +/// #[ramfunc] +/// unsafe fn computation_heavy_function() { +/// // do something here +/// } +/// +/// # fn main() {} +/// ``` +#[proc_macro_attribute] +pub fn ramfunc(args: TokenStream, input: TokenStream) -> TokenStream { + assert_eq!( + args.to_string(), + "", + "`ramfunc` attribute must have no arguments" + ); + + let f: ItemFn = syn::parse(input).expect("`#[ramfunc]` must be applied to a function"); + + assert!( + f.decl.generics.params.is_empty(), + "`#[ramfunc]` can't be applied to generic functions" + ); + // because then all instantiations of the function would end in the same linker section and the + // linker won't be able to GC the unused ones (read comment below for more details) + + // NOTE we want to put *each* function into a *different* section so the linker is able to GC + // unused functions. Unlike the compiler we don't know the crate name or which module this + // function is in so we can't use a mangled version of the path to the function -- we don't know + // its full path! Instead we'll use a random string for the section name of each function. + let mut rng = rand::thread_rng(); + let hash = (0..16) + .map(|_| { + if rng.gen() { + ('a' as u8 + rng.gen::() % 25) as char + } else { + ('0' as u8 + rng.gen::() % 10) as char + } + }).collect::(); + let section_name = format!(".ramfunc.{}", hash); + + quote!( + #[link_section = #section_name] + #f + ).into() +} diff --git a/src/lib.rs b/src/lib.rs index 526b28b9..46d2c5a4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -387,7 +387,7 @@ extern crate r0; use core::fmt; use core::sync::atomic::{self, Ordering}; -pub use macros::{entry, exception, pre_init}; +pub use macros::{entry, exception, pre_init, ramfunc}; /// Registers stacked (pushed into the stack) during an exception #[derive(Clone, Copy)] @@ -470,6 +470,9 @@ pub unsafe extern "C" fn Reset() -> ! { static mut __edata: u32; static __sidata: u32; + static mut __sramfunc: u32; + static mut __eramfunc: u32; + static __siramfunc: u32; } extern "Rust" { @@ -484,7 +487,9 @@ pub unsafe extern "C" fn Reset() -> ! { // Initialize RAM r0::zero_bss(&mut __sbss, &mut __ebss); + // XXX is there a reliable way to do a single `init_data` to initialize both .data and .ramfunc r0::init_data(&mut __sdata, &mut __edata, &__sidata); + r0::init_data(&mut __sramfunc, &mut __eramfunc, &__siramfunc); match () { #[cfg(not(has_fpu))] From 10a4038e1bcc89a7edb0e4d4c3de2dac88eef5a7 Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Fri, 31 Aug 2018 12:07:22 +0200 Subject: [PATCH 3/3] update examples --- macros/src/lib.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/macros/src/lib.rs b/macros/src/lib.rs index ef2e59a3..9dfac032 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -469,13 +469,27 @@ pub fn pre_init(args: TokenStream, input: TokenStream) -> TokenStream { /// /// # Examples /// +/// You can put plain functions in RAM +/// /// ``` /// # use cortex_m_rt_macros::ramfunc; /// #[ramfunc] -/// unsafe fn computation_heavy_function() { +/// fn computation_heavy_function(data: &[u8]) -> u32 { /// // do something here +/// # 0 /// } +/// # fn main() {} +/// ``` /// +/// And you can also put exception handlers in RAM. +/// +/// ``` +/// # use cortex_m_rt_macros::{exception, ramfunc}; +/// #[exception(SysTick)] +/// #[ramfunc] +/// fn handler() { +/// // do something here +/// } /// # fn main() {} /// ``` #[proc_macro_attribute]