Pass a0..a2 to main()

Cargo.toml

@@ -12,7 +12,7 @@ license = "ISC"
 [dependencies]
 r0 = "1.0.0"
 riscv = "0.8"
-riscv-rt-macros = { path = "macros", version = "0.1.6" }
+riscv-rt-macros = { path = "macros", version = "0.2.0" }
 
 [dev-dependencies]
 panic-halt = "0.2.0"

asm.S

@@ -58,9 +58,7 @@ _abs_start:
     li  x7, 0
     li  x8, 0
     li  x9, 0
-    li  x10,0
-    li  x11,0
-    li  x12,0
+    // a0..a2 (x10..x12) skipped
     li  x13,0
     li  x14,0
     li  x15,0
@@ -87,23 +85,23 @@ _abs_start:
     .option pop
 
     // Check hart id
-    csrr a2, mhartid
+    csrr t2, mhartid
     lui t0, %hi(_max_hart_id)
     add t0, t0, %lo(_max_hart_id)
-    bgtu a2, t0, abort
+    bgtu t2, t0, abort
 
     // Allocate stacks
     la sp, _stack_start
     lui t0, %hi(_hart_stack_size)
     add t0, t0, %lo(_hart_stack_size)
 #ifdef __riscv_mul
-    mul t0, a2, t0
+    mul t0, t2, t0
 #else
-    beqz a2, 2f  // Jump if single-hart
-    mv t1, a2
-    mv t2, t0
+    beqz t2, 2f  // Jump if single-hart
+    mv t1, t2
+    mv t3, t0
 1:
-    add t0, t0, t2
+    add t0, t0, t3
     addi t1, t1, -1
     bnez t1, 1b
 2:

macros/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["riscv", "runtime", "startup"]
 license = "MIT OR Apache-2.0"
 name = "riscv-rt-macros"
 repository = "https://github.com/rust-embedded/riscv-rt"
-version = "0.1.6"
+version = "0.2.0"
 
 [lib]
 proc-macro = true

macros/src/lib.rs

@@ -9,7 +9,7 @@ extern crate proc_macro2;
 extern crate syn;
 
 use proc_macro2::Span;
-use syn::{parse, spanned::Spanned, ItemFn, ReturnType, Type, Visibility};
+use syn::{parse, spanned::Spanned, FnArg, ItemFn, PathArguments, ReturnType, Type, Visibility};
 
 use proc_macro::TokenStream;
 
@@ -48,27 +48,49 @@ use proc_macro::TokenStream;
 pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
     let f = parse_macro_input!(input as ItemFn);
 
+    // check the function arguments
+    if f.sig.inputs.len() > 3 {
+        return parse::Error::new(
+            f.sig.inputs.last().unwrap().span(),
+            "`#[entry]` function has too many arguments",
+        )
+        .to_compile_error()
+        .into();
+    }
+    for arg in &f.sig.inputs {
+        match arg {
+            FnArg::Receiver(_) => {
+                return parse::Error::new(arg.span(), "invalid argument")
+                    .to_compile_error()
+                    .into();
+            }
+            FnArg::Typed(t) => {
+                if !is_simple_type(&t.ty, "usize") {
+                    return parse::Error::new(t.ty.span(), "argument type must be usize")
+                        .to_compile_error()
+                        .into();
+                }
+            }
+        }
+    }
+
     // check the function signature
     let valid_signature = f.sig.constness.is_none()
         && f.sig.asyncness.is_none()
         && f.vis == Visibility::Inherited
         && f.sig.abi.is_none()
-        && f.sig.inputs.is_empty()
         && f.sig.generics.params.is_empty()
         && f.sig.generics.where_clause.is_none()
         && f.sig.variadic.is_none()
         && match f.sig.output {
             ReturnType::Default => false,
-            ReturnType::Type(_, ref ty) => match **ty {
-                Type::Never(_) => true,
-                _ => false,
-            },
+            ReturnType::Type(_, ref ty) => matches!(**ty, Type::Never(_)),
         };
 
     if !valid_signature {
         return parse::Error::new(
             f.span(),
-            "`#[entry]` function must have signature `[unsafe] fn() -> !`",
+            "`#[entry]` function must have signature `[unsafe] fn([arg0: usize, ...]) -> !`",
         )
         .to_compile_error()
         .into();
@@ -83,18 +105,32 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
     // XXX should we blacklist other attributes?
     let attrs = f.attrs;
     let unsafety = f.sig.unsafety;
+    let args = f.sig.inputs;
     let stmts = f.block.stmts;
 
     quote!(
         #[export_name = "main"]
         #(#attrs)*
-        pub #unsafety fn __risc_v_rt__main() -> ! {
+        pub #unsafety fn __risc_v_rt__main(#args) -> ! {
             #(#stmts)*
         }
     )
     .into()
 }
 
+#[allow(unused)]
+fn is_simple_type(ty: &Type, name: &str) -> bool {
+    if let Type::Path(p) = ty {
+        if p.qself.is_none() && p.path.leading_colon.is_none() && p.path.segments.len() == 1 {
+            let segment = p.path.segments.first().unwrap();
+            if segment.ident == name && segment.arguments == PathArguments::None {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 /// Attribute to mark which function will be called at the beginning of the reset handler.
 ///
 /// **IMPORTANT**: This attribute can appear at most *once* in the dependency graph. Also, if you

src/lib.rs

@@ -361,11 +361,11 @@ extern "C" {
 /// never returns.
 #[link_section = ".init.rust"]
 #[export_name = "_start_rust"]
-pub unsafe extern "C" fn start_rust() -> ! {
+pub unsafe extern "C" fn start_rust(a0: usize, a1: usize, a2: usize) -> ! {
     #[rustfmt::skip]
     extern "Rust" {
         // This symbol will be provided by the user via `#[entry]`
-        fn main() -> !;
+        fn main(a0: usize, a1: usize, a2: usize) -> !;
 
         // This symbol will be provided by the user via `#[pre_init]`
         fn __pre_init();
@@ -386,7 +386,7 @@ pub unsafe extern "C" fn start_rust() -> ! {
 
     _setup_interrupts();
 
-    main();
+    main(a0, a1, a2);
 }
 
 /// Registers saved in trap handler