Cortex A addition

- Add armv7a architecture handling to the crate.
- Add new `cortex-a-rt` reference run time crate.
- Add basic armv7a checks to CI
- `kmain` renamed to `boot_core` for Cortex-A where multi-processor systems
are common.
- Add armv7a to examples for basic verification with QEMU
- Split example code into dedicated folders for QEMU targets
- Build examples in CI as well

Author: robamu

.cargo/config.toml

@@ -6,6 +6,15 @@ runner = "qemu-system-arm -machine mps3-an536 -cpu cortex-r52 -semihosting -nogr
 runner = "qemu-system-arm -machine versatileab -cpu cortex-r5f -semihosting -nographic -kernel"
 
 [target.armv7r-none-eabi]
-# change to '-mcpu=cortex-r5' to '-mcpu=cortex-r5f' if you use eabi-fpu feature, otherwise
+# change '-mcpu=cortex-r5' to '-mcpu=cortex-r5f' if you use eabi-fpu feature, otherwise
 # qemu-system-arm will lock up
 runner = "qemu-system-arm -machine versatileab -cpu cortex-r5 -semihosting -nographic -kernel"
+
+[target.armv7a-none-eabihf]
+runner = "qemu-system-arm -machine versatileab -cpu cortex-a8 -semihosting -nographic -kernel"
+
+[target.armv7a-none-eabi]
+runner = "qemu-system-arm -machine versatileab -cpu cortex-a8 -semihosting -nographic -kernel"
+
+[unstable]
+build-std = ["core", "alloc"]

.github/workflows/build.yml

@@ -6,17 +6,29 @@ on:
 name: Build
 
 jobs:
+  # Define Rust versions dynamically
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.rust_versions }}
+    steps:
+      - id: set-matrix
+        run: |
+          echo 'rust_versions={"rust": ["stable", "1.82"]}' >> "$GITHUB_OUTPUT"
+
   # Build the workspace for a target architecture
   build:
     runs-on: ubuntu-24.04
+    needs: setup
     strategy:
       matrix:
-        rust: [stable, 1.82]
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
         target:
           - armebv7r-none-eabi
           - armebv7r-none-eabihf
           - armv7r-none-eabi
           - armv7r-none-eabihf
+          - armv7a-none-eabi
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -29,11 +41,51 @@ jobs:
         run: |
           cargo build --target ${{ matrix.target }}
           cargo build --target ${{ matrix.target }} --no-default-features
-          cargo build --target ${{ matrix.target }} --all-features
+
+  build-versatileab:
+    runs-on: ubuntu-24.04
+    needs: setup
+    strategy:
+      matrix:
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install rust
+        run: |
+          rustup install ${{ matrix.rust }}
+          rustup default ${{ matrix.rust }}
+          rustup target add armv7a-none-eabi
+          rustup target add armv7r-none-eabi
+          rustup target add armv7r-none-eabihf
+      - name: Build
+        run: |
+          cargo build --manifest-path ./examples/versatileab/Cargo.toml --target armv7a-none-eabi
+          cargo build --manifest-path ./examples/versatileab/Cargo.toml --target armv7r-none-eabi
+          cargo build --manifest-path ./examples/versatileab/Cargo.toml --target armv7r-none-eabihf
+
+  build-mps3-an536:
+    runs-on: ubuntu-24.04
+    needs: setup
+    strategy:
+      matrix:
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install rust
+        run: |
+          rustup install nightly
+          rustup default nightly
+          rustup component add rust-src --toolchain nightly
+      - name: Build
+        run: |
+          cargo build --manifest-path ./examples/mps3-an536/Cargo.toml --target armv8r-none-eabihf -Zbuild-std=core
 
   # Build the host tools
   build-host:
     runs-on: ubuntu-24.04
+    needs: setup
     strategy:
       matrix:
         rust: [stable, 1.59]
@@ -58,6 +110,8 @@ jobs:
           - armebv7r-none-eabi
           - armebv7r-none-eabihf
           - armv7r-none-eabi
+          - armv7a-none-eabi
+          - armv7a-none-eabihf
           - armv7r-none-eabihf
           - armv8r-none-eabihf
     steps:
@@ -72,22 +126,23 @@ jobs:
         run: |
           cargo build --target ${{ matrix.target }} -Zbuild-std=core
           cargo build --target ${{ matrix.target }} -Zbuild-std=core --no-default-features
-          cargo build --target ${{ matrix.target }} -Zbuild-std=core --all-features
 
   # Gather all the above build jobs together for the purposes of getting an overall pass-fail
   build-all:
     runs-on: ubuntu-24.04
-    needs: [build, build-tier3, build-host]
+    needs: [build, build-tier3, build-host, build-versatileab, build-mps3-an536]
     steps:
       - run: /bin/true
 
   # Build the docs for the workspace
   docs:
     runs-on: ubuntu-24.04
+    needs: setup
     strategy:
       matrix:
-        rust: [stable, 1.82]
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
         target:
+          - armv7a-none-eabi
           - armebv7r-none-eabi
           - armebv7r-none-eabihf
           - armv7r-none-eabi
@@ -109,9 +164,10 @@ jobs:
   # Build the docs for the host tools
   docs-host:
     runs-on: ubuntu-24.04
+    needs: setup
     strategy:
       matrix:
-        rust: [stable, 1.82]
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -170,14 +226,16 @@ jobs:
   # Run clippy on the workpace
   clippy:
     runs-on: ubuntu-24.04
+    needs: setup
     strategy:
       matrix:
-        rust: [stable, 1.82]
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
         target:
           - armebv7r-none-eabi
           - armebv7r-none-eabihf
           - armv7r-none-eabi
           - armv7r-none-eabihf
+          - armv7a-none-eabi
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -196,9 +254,10 @@ jobs:
   # Run clippy on the host tools
   clippy-host:
     runs-on: ubuntu-24.04
+    needs: setup
     strategy:
       matrix:
-        rust: [stable, 1.82]
+        rust: ${{ fromJSON(needs.setup.outputs.matrix).rust }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4

Cargo.toml

@@ -1,10 +1,12 @@
 [workspace]
 exclude = [
   "arm-targets",
+  "examples/versatileab",
+  "examples/mps3-an536",
 ]
 members = [
   "cortex-ar",
-  "cortex-r-examples",
   "cortex-r-rt",
+  "cortex-a-rt",
 ]
 resolver = "2"

README.md

@@ -1,4 +1,4 @@
-# Rust on Arm Cortex-R
+# Rust on Arm Cortex-R and Cortex-A
 
 This repository provides support for:
 
@@ -17,9 +17,10 @@ There are currently three libraries here:
 
 * [cortex-ar](./cortex-ar/) - support library for Cortex-R and Cortex-A CPUs (like [cortex-m])
 * [cortex-r-rt](./cortex-r-rt/) - run-time library for Cortex-R CPUs (like [cortex-m-rt])
+* [cortex-a-rt](./cortex-a-rt/) - run-time library for Cortex-A CPUs (like [cortex-m-rt])
 * [arm-targets](./arm-targets/) - a helper library for your build.rs that sets various `--cfg` flags according to the current target
 
-There are also example programs for QEMU in the [cortex-r-examples](./cortex-r-examples/) folder.
+There are also example programs for QEMU in the [examples](./-examples/) folder.
 
 [cortex-m]: https://crates.io/crates/cortex-m
 [cortex-m-rt]: https://crates.io/crates/cortex-m-rt

arm-targets/Cargo.toml

@@ -9,7 +9,8 @@ edition = "2021"
 license = "MIT OR Apache-2.0"
 name = "arm-targets"
 readme = "README.md"
-repository = "https://github.com/rust-embedded/cortex-r.git"
+repository = "https://github.com/rust-embedded/cortex-ar.git"
+homepage = "https://github.com/rust-embedded/cortex-ar.git"
 rust-version = "1.59"
 version = "0.1.0"
 

arm-targets/src/lib.rs

@@ -2,18 +2,39 @@
 //!
 //! Hopefully Rust will stabilise these kinds of target features, and this won't
 //! be required.
+#[derive(Default)]
+pub struct TargetInfo {
+    profile: Option<Profile>,
+    arch: Option<Arch>,
+    isa: Option<Isa>,
+}
+
+impl TargetInfo {
+    pub fn profile(&self) -> Option<Profile> {
+        self.profile
+    }
 
+    pub fn arch(&self) -> Option<Arch> {
+        self.arch
+    }
+
+    pub fn isa(&self) -> Option<Isa> {
+        self.isa
+    }
+}
 /// Process the ${TARGET} environment variable, and emit cargo configuration to
 /// standard out.
-pub fn process() {
+pub fn process() -> TargetInfo {
     let target = std::env::var("TARGET").expect("build script TARGET variable");
-    process_target(&target);
+    process_target(&target)
 }
 
 /// Process a given target string, and emit cargo configuration to standard out.
-pub fn process_target(target: &str) {
+pub fn process_target(target: &str) -> TargetInfo {
+    let mut target_info = TargetInfo::default();
     if let Some(isa) = Isa::get(target) {
         println!(r#"cargo:rustc-cfg=arm_isa="{}""#, isa);
+        target_info.isa = Some(isa);
     }
     println!(
         r#"cargo:rustc-check-cfg=cfg(arm_isa, values({}))"#,
@@ -22,6 +43,7 @@ pub fn process_target(target: &str) {
 
     if let Some(arch) = Arch::get(target) {
         println!(r#"cargo:rustc-cfg=arm_architecture="{}""#, arch);
+        target_info.arch = Some(arch);
     }
     println!(
         r#"cargo:rustc-check-cfg=cfg(arm_architecture, values({}))"#,
@@ -30,14 +52,17 @@ pub fn process_target(target: &str) {
 
     if let Some(profile) = Profile::get(target) {
         println!(r#"cargo:rustc-cfg=arm_profile="{}""#, profile);
+        target_info.profile = Some(profile);
     }
     println!(
         r#"cargo:rustc-check-cfg=cfg(arm_profile, values({}))"#,
         Profile::values()
     );
+    target_info
 }
 
 /// The Arm Instruction Set
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Isa {
     /// A64 instructions are executed by Arm processors in Aarch64 mode
     A64,
@@ -91,6 +116,7 @@ impl core::fmt::Display for Isa {
 /// The Arm Architecture
 ///
 /// As defined by a particular revision of the Arm Architecture Reference Manual (ARM).
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Arch {
     /// Armv6-M (also known as ARMv6-M)
     Armv6M,
@@ -129,6 +155,8 @@ impl Arch {
             Some(Arch::Armv7R)
         } else if target.starts_with("armv8r-") {
             Some(Arch::Armv8R)
+        } else if target.starts_with("armv7a-") {
+            Some(Arch::Armv7A)
         } else if target.starts_with("aarch64-") || target.starts_with("aarch64be-") {
             Some(Arch::Armv8A)
         } else {
@@ -188,6 +216,7 @@ impl core::fmt::Display for Arch {
 }
 
 /// The Arm Architecture Profile.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Profile {
     /// Microcontrollers
     M,

cortex-a-rt/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [unreleased]
+
+Initial release
+
+[unreleased]: https://github.com/rust-embedded/cortex-ar/compare/cortex-a-rt-v0.1.0...HEAD
+[v0.1.0]: https://github.com/rust-embedded/cortex-ar/releases/tag/cortex-a-rt-v0.1.0

cortex-a-rt/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+authors = [
+  "Robin Mueller <[email protected]>",
+  "Jonathan Pallant <[email protected]>",
+  "The Cortex-R Team <[email protected]>"
+]
+description = "Run-Time support for Arm Cortex-A"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+name = "cortex-a-rt"
+readme = "README.md"
+repository = "https://github.com/rust-embedded/cortex-ar.git"
+homepage = "https://github.com/rust-embedded/cortex-ar.git"
+rust-version = "1.82"
+version = "0.1.0"
+
+[dependencies]
+cortex-ar = {version = "0.1.0", path = "../cortex-ar"}
+semihosting = {version = "0.1.18", features = ["stdio"]}
+
+[features]
+# Enable the FPU on start-up, even on a soft-float EABI target
+eabi-fpu = []
+# Specify that the target VFP has double precision support. If the target has NEON support, it
+# also requires double precision support for the VFP.
+vfp-dp = []
+
+[build-dependencies]
+arm-targets = {version = "0.1.0", path = "../arm-targets"}

cortex-a-rt/README.md

@@ -0,0 +1,26 @@
+# Arm Cortex-A Run-Time
+
+## Features
+
+- `vfp-dp`: Enables support for the double-precision VFP floating point support. If your target
+  CPU has this feature or support for NEON which also implies double-precision support, this
+  feature should be activated.
+
+## Minimum Supported Rust Version (MSRV)
+
+This crate is guaranteed to compile on stable Rust 1.82.0 and up. It *might*
+compile with older versions but that may change in any new patch release.
+
+## Licence
+
+* Copyright (c) Ferrous Systems
+* Copyright (c) The Rust Embedded Devices Working Group developers
+
+Licensed under either [MIT](./LICENSE-MIT) or [Apache-2.0](./LICENSE-APACHE) at
+your option.
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you shall be licensed as above, without any
+additional terms or conditions.