Merge pull request #276 from rust-embedded/tests-build

Add tests for new build methods in `riscv-rt`

Author: romancardenas

.github/workflows/tests.yaml

@@ -4,10 +4,10 @@ on:
   pull_request:
   merge_group:
 
-name: Run macro tests (tests)
+name: Run tests (build and trybuild)
 
 jobs:
-  run-tests:
+  run-trybuild:
     strategy:
       matrix:
         os: [ macos-latest, ubuntu-latest ] # windows shows weird linking errors 
@@ -16,12 +16,62 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
       - name: Run tests
-        run: cargo test --package tests
+        run: cargo test --package tests-trybuild
+  run-build:
+    strategy:
+      matrix:
+        # All generated code should be running on stable now, MRSV is 1.61.0
+        toolchain: [ stable, nightly, 1.61.0 ]
+        target:
+          - riscv32i-unknown-none-elf
+          - riscv32im-unknown-none-elf
+          - riscv32imc-unknown-none-elf
+          - riscv32imac-unknown-none-elf
+          - riscv32imafc-unknown-none-elf
+          - riscv64imac-unknown-none-elf
+          - riscv64gc-unknown-none-elf
+        example:
+          - empty
+        include:
+          # Nightly is only for reference and allowed to fail
+          - toolchain: nightly
+            experimental: true
+        exclude:
+          - toolchain: 1.61.0
+            target: riscv32im-unknown-none-elf
+          - toolchain: 1.61.0
+            target: riscv32imafc-unknown-none-elf
+    runs-on: ubuntu-latest
+    continue-on-error: ${{ matrix.experimental || false }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ matrix.toolchain }}
+          targets: ${{ matrix.target }}
+      - name: Build (no features)
+        run: RUSTFLAGS="-C link-arg=-Tdevice.x -C link-arg=-Tmemory.x -C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }}
+      - name: Build (include device.x)
+        run: RUSTFLAGS="-C link-arg=-Tmemory.x -C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features device
+      - name: Build (include memory.x)
+        run: RUSTFLAGS="-C link-arg=-Tdevice.x -C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features memory
+      - name: Build (include device.x and memory.x)
+        run: RUSTFLAGS="-C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features device,memory
+      
+      - name: Build (custom interrupts and exceptions)
+        run: RUSTFLAGS="-C link-arg=-Tdevice.x -C link-arg=-Tmemory.x -C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features no-interrupts,no-exceptions
+      - name: Build (custom interrupts and exceptions, include device.x)
+        run: RUSTFLAGS="-C link-arg=-Tmemory.x -C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features no-interrupts,no-exceptions,device
+      - name: Build (custom interrupts and exceptions, include memory.x)
+        run: RUSTFLAGS="-C link-arg=-Tdevice.x -C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features no-interrupts,no-exceptions,memory
+      - name: Build (custom interrupts and exceptions, include device.x and memory.x)
+        run: RUSTFLAGS="-C link-arg=-Tlink.x" cargo build --package tests-build --target ${{ matrix.target }} --example ${{ matrix.example }} --features no-interrupts,no-exceptions,device,memory
 
   # Job to check that all the builds succeeded
   tests-check:
     needs:
-    - run-tests
+    - run-trybuild
+    - run-build
     runs-on: ubuntu-latest
     if: always()
     steps:

Cargo.toml

@@ -7,5 +7,6 @@ members = [
     "riscv-rt",
     "riscv-semihosting",
     "riscv-target-parser",
-    "tests",
+    "tests-build",
+    "tests-trybuild",
 ]

tests-build/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tests-build"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+panic-halt = "1.0"
+riscv = { path = "../riscv", version = "0.13.0" }
+riscv-rt = { path = "../riscv-rt", version = "0.14.0" }
+
+[features]
+single-hart = ["riscv-rt/single-hart"]
+v-trap = ["riscv-rt/v-trap"]
+device = ["riscv-rt/device"]
+memory = ["riscv-rt/memory"]
+no-exceptions = ["riscv-rt/no-exceptions"]
+no-interrupts = ["riscv-rt/no-interrupts"]

tests-build/build.rs

@@ -0,0 +1,22 @@
+use std::{env, fs::File, io::Write, path::PathBuf};
+
+fn main() {
+    // Put device.x 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");
+
+    // Put memory.x somewhere the linker can find it
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+    println!("cargo:rerun-if-changed=memory.x");
+
+    println!("cargo:rerun-if-changed=build.rs");
+}

tests-build/device.x

@@ -0,0 +1,26 @@
+/* Core interrupt sources and trap handlers */
+PROVIDE(MachineSoft = DefaultHandler);
+PROVIDE(MachineTimer = DefaultHandler);
+PROVIDE(MachineExternal = DefaultHandler);
+PROVIDE(_start_MachineSoft_trap = _start_DefaultHandler_trap);
+PROVIDE(_start_MachineTimer_trap = _start_DefaultHandler_trap);
+PROVIDE(_start_MachineExternal_trap = _start_DefaultHandler_trap);
+
+/* External interrupt sources */
+PROVIDE(Gpio = DefaultHandler);
+PROVIDE(Uart = DefaultHandler);
+PROVIDE(I2c = DefaultHandler);
+
+/* Exception sources */
+PROVIDE(InstructionMisaligned = ExceptionHandler);
+PROVIDE(InstructionFault = ExceptionHandler);
+PROVIDE(IllegalInstruction = ExceptionHandler);
+PROVIDE(Breakpoint = ExceptionHandler);
+PROVIDE(LoadMisaligned = ExceptionHandler);
+PROVIDE(LoadFault = ExceptionHandler);
+PROVIDE(StoreMisaligned = ExceptionHandler);
+PROVIDE(StoreFault = ExceptionHandler);
+PROVIDE(MachineEnvCall = ExceptionHandler);
+PROVIDE(InstructionPageFault = ExceptionHandler);
+PROVIDE(LoadPageFault = ExceptionHandler);
+PROVIDE(StorePageFault = ExceptionHandler);

tests-build/examples/empty.rs

@@ -0,0 +1,69 @@
+#![no_std]
+#![no_main]
+
+extern crate panic_halt;
+
+use riscv_rt::{core_interrupt, entry, exception, external_interrupt};
+use tests_build::{CoreInterrupt, Exception, ExternalInterrupt};
+
+/* EXAMPLES OF USING THE core_interrupt MACRO FOR CORE INTERRUPT HANDLERS.
+IF v-trap ENABLED, THE MACRO ALSO DEFINES _start_COREINTERRUPT_trap routines */
+
+/// Handler with the simplest signature.
+#[core_interrupt(CoreInterrupt::MachineSoft)]
+fn supervisor_soft() {
+    // do something here
+    loop {}
+}
+
+/// Handler with the most complete signature.
+#[core_interrupt(CoreInterrupt::MachineTimer)]
+unsafe fn supervisor_timer() -> ! {
+    // do something here
+    loop {}
+}
+
+/* EXAMPLES OF USING THE external_interrupt MACRO FOR EXTERNAL INTERRUPT HANDLERS. */
+
+/// Handler with the simplest signature.
+#[external_interrupt(ExternalInterrupt::Gpio)]
+fn external_gpio() {
+    // do something here
+    loop {}
+}
+
+/// Handler with the most complete signature.
+#[external_interrupt(ExternalInterrupt::Uart)]
+unsafe fn external_uart() -> ! {
+    // do something here
+    loop {}
+}
+
+/* EXAMPLES OF USING THE exception MACRO FOR EXCEPTION HANDLERS. */
+
+/// Handler with the simplest signature.
+#[exception(Exception::InstructionMisaligned)]
+fn instruction_misaligned() {
+    // do something here
+    loop {}
+}
+
+/// Handler with the most complete signature.
+#[exception(Exception::IllegalInstruction)]
+unsafe fn illegal_instruction(_trap: &riscv_rt::TrapFrame) -> ! {
+    // do something here
+    loop {}
+}
+
+// The reference to TrapFrame can be mutable if the handler needs to modify it.
+#[exception(Exception::Breakpoint)]
+unsafe fn breakpoint(_trap: &mut riscv_rt::TrapFrame) -> ! {
+    // do something here
+    loop {}
+}
+
+#[entry]
+fn main() -> ! {
+    // do something here
+    loop {}
+}

tests-build/memory.x

@@ -0,0 +1,12 @@
+MEMORY
+{
+    RAM : ORIGIN = 0x80000000, LENGTH = 16K
+    FLASH : ORIGIN = 0x20000000, LENGTH = 4M
+}
+
+REGION_ALIAS("REGION_TEXT", FLASH);
+REGION_ALIAS("REGION_RODATA", FLASH);
+REGION_ALIAS("REGION_DATA", RAM);
+REGION_ALIAS("REGION_BSS", RAM);
+REGION_ALIAS("REGION_HEAP", RAM);
+REGION_ALIAS("REGION_STACK", RAM);

tests-build/src/lib.rs

@@ -0,0 +1,43 @@
+#![no_std]
+#![no_main]
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[riscv::pac_enum(unsafe ExternalInterruptNumber)]
+pub enum ExternalInterrupt {
+    Gpio = 0,
+    Uart = 1,
+    I2c = 2,
+}
+
+#[cfg(not(feature = "no-interrupts"))]
+pub use riscv::interrupt::Interrupt as CoreInterrupt;
+
+#[cfg(feature = "no-interrupts")]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[riscv::pac_enum(unsafe CoreInterruptNumber)]
+pub enum CoreInterrupt {
+    MachineSoft = 3,
+    MachineTimer = 7,
+    MachineExternal = 11,
+}
+
+#[cfg(not(feature = "no-exceptions"))]
+pub use riscv::interrupt::Exception;
+
+#[cfg(feature = "no-exceptions")]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[riscv::pac_enum(unsafe ExceptionNumber)]
+pub enum Exception {
+    InstructionMisaligned = 0,
+    InstructionFault = 1,
+    IllegalInstruction = 2,
+    Breakpoint = 3,
+    LoadMisaligned = 4,
+    LoadFault = 5,
+    StoreMisaligned = 6,
+    StoreFault = 7,
+    MachineEnvCall = 11,
+    InstructionPageFault = 12,
+    LoadPageFault = 13,
+    StorePageFault = 15,
+}

tests/Cargo.toml renamed to tests-trybuild/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "tests"
+name = "tests-trybuild"
 version = "0.1.0"
 edition = "2021"