RISC-V support over CLINT (#815)

* Rebase to master

* using interrupt_mod

* bug fixes

* fix other backends

* Add changelog

* forgot about rtic-macros

* backend-specific configuration

* core peripherals optional over macro argument

* pre_init_preprocessing binding

* CI for RISC-V (WIP)

* separation of concerns

* add targets for RISC-V examples

* remove qemu feature

* prepare examples folder

* move examples all together

* move ci out of examples

* minor changes

* add cortex-m

* new xtask: proof of concept

* fix build.yml

* feature typo

* clean rtic examples

* reproduce weird issue

* remove unsafe code in user app

* update dependencies

* allow builds on riscv32imc

* let's fix QEMU

* Update .github/workflows/build.yml

Co-authored-by: Henrik Tjäder <henrik@tjaders.com>

* New build.rs

* removing test features

* adapt ui test to new version of clippy

* add more examples to RISC-V backend

* proper configuration of heapless for riscv32imc

* opt-out examples for riscv32imc

* point to new version of riscv-slic

* adapt new macro bindings

* adapt examples and CI to stable

* fix cortex-m CI

* Review

---------

Co-authored-by: Henrik Tjäder <henrik@tjaders.com>

1 files changed, 28 insertions, 0 deletions

diff --git a/rtic-macros/src/syntax/parse/app.rs b/rtic-macros/src/syntax/parse/app.rs
index efcafbe..469bcb8 100644
--- a/rtic-macros/src/syntax/parse/app.rs
+++ b/rtic-macros/src/syntax/parse/app.rs
@@ -13,6 +13,7 @@ use crate::syntax::{
         App, AppArgs, Dispatcher, Dispatchers, HardwareTask, Idle, IdleArgs, Init, InitArgs,
         LocalResource, SharedResource, SoftwareTask,
     },
+    backend::BackendArgs,
     parse::{self as syntax_parse, util},
     Either, Map, Set,
 };
@@ -24,8 +25,10 @@ impl AppArgs {
         (|input: ParseStream<'_>| -> parse::Result<Self> {
             let mut custom = Set::new();
             let mut device = None;
+            let mut core = true;
             let mut peripherals = true;
             let mut dispatchers = Dispatchers::new();
+            let mut backend = None;
 
             loop {
                 if input.is_empty() {
@@ -59,6 +62,17 @@ impl AppArgs {
                         }
                     }
 
+                    "core" => {
+                        if let Ok(p) = input.parse::<LitBool>() {
+                            core = p.value;
+                        } else {
+                            return Err(parse::Error::new(
+                                ident.span(),
+                                "unexpected argument value; this should be a boolean",
+                            ));
+                        }
+                    }
+
                     "peripherals" => {
                         if let Ok(p) = input.parse::<LitBool>() {
                             peripherals = p.value;
@@ -113,6 +127,18 @@ impl AppArgs {
                             ));
                         }
                     }
+
+                    "backend" => {
+                        if let Ok(p) = input.parse::<BackendArgs>() {
+                            backend = Some(p);
+                        } else {
+                            return Err(parse::Error::new(
+                                ident.span(),
+                                "unable to parse backend configuration",
+                            ));
+                        }
+                    }
+
                     _ => {
                         return Err(parse::Error::new(ident.span(), "unexpected argument"));
                     }
@@ -134,8 +160,10 @@ impl AppArgs {
 
             Ok(AppArgs {
                 device,
+                core,
                 peripherals,
                 dispatchers,
+                backend,
             })
         })
         .parse2(tokens)