Rust Custom Target for QEMU RISC-V on Apache NuttX RTOS

📝 21 Apr 2024

Last article we were compiling Rust Apps for Apache NuttX RTOS (QEMU Emulator, RISC-V 32-bit). And we hit a baffling error...

$ make
riscv64-unknown-elf-ld: libapps.a
  hello_rust_1.o:
  can't link soft-float modules with double-float modules

Let's solve the problem! We dive inside the internals of C-to-Rust Interop...

Rust compiles for Soft-Float, NuttX expects Double-Float

(Software vs Hardware Floating-Point)
But Rust doesn't support Double-Float (by default)
So we create a Rust Custom Target for Double-Float
Rebuild the Rust Core Library for Double-Float
And our Rust App builds OK with NuttX!

Software vs Hardware Floating-Point

Why did our NuttX Build fail? (Pic above)

## Download the NuttX Source Code
$ mkdir nuttx
$ cd nuttx
$ git clone https://github.com/apache/nuttx nuttx
$ git clone https://github.com/apache/nuttx-apps apps

## Configure NuttX for QEMU RISC-V 32-bit
$ cd nuttx
$ tools/configure.sh rv-virt:nsh
$ make menuconfig
## TODO: Enable "Hello Rust Example"

## Build NuttX bundled with the Rust App
$ make
riscv64-unknown-elf-ld: libapps.a
  hello_rust_1.o:
  can't link soft-float modules with double-float modules

(See the Complete Steps)

GCC Linker failed because it couldn't link the NuttX Binaries with the Rust Binaries.

Here's Why: NuttX Build calls GCC Compiler to compile our C Modules...

## Build NuttX Firmware with Tracing Enabled
$ make --trace
...
## GCC compiles `hello_main.c` to `hello.o`
## for RISC-V 32-bit with Double-Float
riscv64-unknown-elf-gcc \
  -march=rv32imafdc \
  -mabi=ilp32d \
  -c \
  hello_main.c \
  -o ...hello.o \
  ...

(See the GCC Options)

Then NuttX Build calls Rust Compiler to compile our Rust App...

## Build NuttX Firmware with Tracing Enabled
$ make --trace
...
## Rust Compiler compiles `hello_rust_main.rs` to `hello_rust.o`
## for RISC-V 32-bit with Soft-Float
rustc \
  --target riscv32i-unknown-none-elf \
  --edition 2021 \
  --emit obj \
  -g \
  -C panic=abort \
  -O \
  hello_rust_main.rs \
  -o ...hello_rust.o

Which looks like this...

Is there a problem?

Watch closely as we compare GCC Compiler with Rust Compiler (pic above)...

GCC Compiler	Rust Compiler
riscv64-unknown-elf-gcc hello_main.c	rustc hello_rust_main.rs
-march rv32imafdc	--target riscv32i-unknown-none-elf
-mabi ilp32d

Hmmm the Floats look different...

GCC compiles for (Double-Precision) Hardware Floating-Point...

But Rust Compiler emits Software Floating-Point.

That's why GCC Linker won't link the binaries: Hard-Float vs Soft-Float!

GCC Compiler	Rust Compiler
rv32imafdc	riscv32i
- I: Integer	- I: Integer
- F: Single Hard-Float	(Default is Soft-Float)
- D: Double Hard-Float	(Default is Soft-Float)

To verify, we dump the ELF Header for GCC Compiler Output...

## Dump the ELF Header for GCC Output
$ riscv64-unknown-elf-readelf \
  --file-header --arch-specific \
  ../apps/examples/hello/*hello.o                 

## GCC Compiler Output is
## Double-Precision Hardware Floating-Point
Flags: 0x5, RVC, double-float ABI

(See the GCC ELF Header)

And the ELF Header for Rust Compiler Output...

## Dump the ELF Header for Rust Compiler Output
$ riscv64-unknown-elf-readelf \
  --file-header --arch-specific \
  ../apps/examples/hello_rust/*hello_rust.o

## Rust Compiler Output is
## Software Floating-Point
Flags: 0x0

(See the Rust ELF Header)

Indeed we have a problem: Double-Float and Soft-Float won't mix! Let's fix this...

Rust Won't Double-Float

What if we ask Rust Compiler to compile for Double-Float? RV32IMAFDC (Pic above)

Let's harmonise Rust Compiler with GCC Compiler...

Our Build Target is QEMU Emulator
Which offically supports riscv32gc
"gc" in "riscv32gc" denotes IMAFDC

Hence we could do this...

## Compile `hello_rust_main.rs` to `hello_rust.o`
## for Double-Precision Hardware Floating-Point
rustc \
  --target riscv32gc-unknown-none-elf \
  --edition 2021 \
  --emit obj \
  -g \
  -C panic=abort \
  -O \
  hello_rust_main.rs \
  -o hello_rust.o

Sorry nope it won't work...

Error loading target specification: 
  Could not find specification for target "riscv32gc-unknown-none-elf". 
  Run `rustc --print target-list` for a list of built-in targets

That's because riscv32gc isn't a Built-In Rust Target...

## List the Built-In Rust Targets for RISC-V
$ rustup target list | grep riscv

## Nope no riscv32gc!
riscv32i-unknown-none-elf
riscv32imac-unknown-none-elf
riscv32imc-unknown-none-elf
riscv64gc-unknown-linux-gnu
riscv64gc-unknown-none-elf
riscv64imac-unknown-none-elf

But we can create a Custom Rust Target for riscv32gc.

(Coming up next section)

Won't GCC Compiler have the same problem with Double-Float?

When we list the Built-In GCC Targets...

## List the Built-In Targets for GCC RISC-V.
## ABI means Application Binary Interface
$ riscv64-unknown-elf-gcc --target-help

Supported ABIs (for use with the -mabi= option):
  ilp32 ilp32d ilp32e ilp32f lp64 lp64d lp64f

We see that GCC supports Double-Float: ilp32d

ilp32: 32-bit Int, Long and Pointer
d: Double-Precision Hardware Floating-Point

That's why we saw ilp32d earlier...

## GCC compiles for RISC-V 32-bit (Double-Float)
riscv64-unknown-elf-gcc \
  -march=rv32imafdc \
  -mabi=ilp32d \
  ...

We'll make something similar for Rust Compiler...

(More about Application Binary Interface)

Custom Target for Rust

To compile Rust for Double-Float, we need a Custom Target: riscv32gc

How to create the Custom Target?

According to the Official Rust Docs, we shall...

Copy from a Built-In Rust Target

(Like riscv32i)
Tweak it to fit our Custom Rust Target

(Which becomes riscv32gc)

This is how we dump a Built-In Rust Target: riscv32i

## Dump the Built-In Rust Target:
## riscv32i (32-bit RISC-V with Soft-Float)
$ rustc \
  +nightly \
  -Z unstable-options \
  --print target-spec-json \
  --target riscv32i-unknown-none-elf

{
  "arch":        "riscv32",
  "atomic-cas":  false,
  "cpu":         "generic-rv32",
  "data-layout": "e-m:e-p:32:32-i64:64-n32-S128",
  "eh-frame-header":        false,
  "emit-debug-gdb-scripts": false,
  "is-builtin":             true,
  "linker":         "rust-lld",
  "linker-flavor":  "ld.lld",
  "llvm-target":    "riscv32",
  "max-atomic-width":     0,
  "panic-strategy":       "abort",
  "relocation-model":     "static",
  "target-pointer-width": "32"
}

That's the Rust Definition of riscv32i: 32-bit RISC-V with Soft-Float.

We do the same for riscv64gc: 64-bit RISC-V with Double-Float...

## Dump the Built-In Rust Target:
## riscv64gc (64-bit RISC-V with Double-Float)
$ rustc \
  +nightly \
  -Z unstable-options \
  --print target-spec-json \
  --target riscv64gc-unknown-none-elf  

{
  "arch":        "riscv64",
  "code-model":  "medium",
  "cpu":         "generic-rv64",
  "data-layout": "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128",
  "eh-frame-header":        false,
  "emit-debug-gdb-scripts": false,
  "features":      "+m,+a,+f,+d,+c",
  "is-builtin":    true,
  "linker":        "rust-lld",
  "linker-flavor": "ld.lld",
  "llvm-abiname":  "lp64d",
  "llvm-target":   "riscv64",
  "max-atomic-width":     64,
  "panic-strategy":       "abort",
  "relocation-model":     "static",
  "supported-sanitizers": [ "kernel-address" ],
  "target-pointer-width": "64"
}

Which has more goodies inside: features, llvm-abiname, ...

We're mashing the Two Targets into a New Target?

Exactly! Based on the above, we create our Rust Custom Target: riscv32gc-unknown-none-elf.json

{
  "arch":        "riscv32",
  "cpu":         "generic-rv32",
  "data-layout": "e-m:e-p:32:32-i64:64-n32-S128",
  "eh-frame-header":        false,
  "emit-debug-gdb-scripts": false,
  "features":      "+m,+a,+f,+d,+c",
  "linker":        "rust-lld",
  "linker-flavor": "ld.lld",
  "llvm-abiname":  "ilp32d",
  "llvm-target":   "riscv32",
  "max-atomic-width":     0,
  "panic-strategy":       "abort",
  "relocation-model":     "static",
  "target-pointer-width": "32"
}

Which is riscv32i plus these changes...

Remove "is-builtin": true

(It's a Custom Target, not Built-In)
Remove "atomic-cas": false

(Enable Atomic Compare-And-Swap)
Add "features": "+m,+a,+f,+d,+c"

(Because we need IMAFDC)
Add "llvm-abiname": "ilp32d"

(ilp32d comes from make --trace)

(More about llvm-abiname)

In Summary: We spliced Two Built-In Targets into Custom Target riscv32gc...

	riscv32i (Built-In)	riscv64gc (Built-In)	riscv32gc (Custom)
arch	riscv32	riscv64	riscv32
atomic-cas	false
cpu	generic-rv32	generic-rv64	generic-rv32
data-layout	e-m:e-p:32...	e-m:e-p:64...	e-m:e-p:32...
features		+m,+a,+f,+d,+c	+m,+a,+f,+d,+c
is-builtin	true	true
llvm-abiname		lp64d	ilp32d
llvm-target	riscv32	riscv64	riscv32
max-atomic-width		64	0
target-pointer-width	32	64	32

Build the Rust Core Library

Are we ready to rebuild with Double-Float?

Not quite, we're not done with the System Library...

## Rust Compiler fails to compile with our Custom Target `riscv32gc`
$ rustc \
  --target riscv32gc-unknown-none-elf.json \
  --edition 2021 \
  --emit obj \
  -g \
  -C panic=abort \
  -O \
  hello_rust_main.rs \
  -o hello_rust.o

## That's because Rust Core Library for `riscv32gc` is missing
error[E0463]: can't find crate for `core`

Why? Remember...

GCC Compiler supports Double-Float...

Because it's bundled with C Standard Library for Double-Float
Thus Rust Compiler will support Double-Float...

Only when it has the Rust Core Library for Double-Float

And the Rust Core Library comes from?

We call Rust Compiler to build the Rust Core Library for Double-Float riscv32gc...

## Download our Custom Target for `riscv32gc`
rm -f riscv32gc-unknown-none-elf.json
wget https://raw.githubusercontent.com/lupyuen/nuttx-rust-app/main/riscv32gc-unknown-none-elf.json

## Custom Target needs Nightly Build of Rust Compiler
rustup override set nightly
rustup component add rust-src --toolchain nightly

## Verify our Custom Target, make sure it's OK
rustc \
  --print cfg \
  --target riscv32gc-unknown-none-elf.json

## `cargo build` requires a Rust Project, so we create an empty one.
rm -rf app
cargo new app

## Build the Rust Core Library for `riscv32gc`
## Include the `alloc` library, which will support Heap Memory in future.
## Ignore the error: `can't find crate for std`
pushd app
cargo build \
  -Zbuild-std=core,alloc \
  --target ../riscv32gc-unknown-none-elf.json \
  || true
popd

(See the Build Script)

Rust Core Library for Double-Float riscv32gc is done!

## Show the Rust Core Library for `riscv32gc`
$ ls app/target/riscv32gc-unknown-none-elf/debug/deps 

alloc-254848389e7e2c53.d
app-cf88b81a5fca23b3.d
compiler_builtins-d5922d64507adf16.d
core-ec2ec78e26b8c830.d
liballoc-254848389e7e2c53.rlib
liballoc-254848389e7e2c53.rmeta
libcompiler_builtins-d5922d64507adf16.rlib
libcompiler_builtins-d5922d64507adf16.rmeta
libcore-ec2ec78e26b8c830.rlib
libcore-ec2ec78e26b8c830.rmeta
librustc_std_workspace_core-3cc5bcc9f701a6e7.rlib
librustc_std_workspace_core-3cc5bcc9f701a6e7.rmeta
rustc_std_workspace_core-3cc5bcc9f701a6e7.d

Now we rebuild our Rust App with the Custom Target (linked to our Rust Core Library)...

## Compile our Rust App with Rust Core Library for `riscv32gc`
## We changed the Target to `riscv32gc-unknown-none-elf.json`
## TODO: Change `../apps` to the NuttX Apps Folder
rustc \
  --target riscv32gc-unknown-none-elf.json \
  --edition 2021 \
  --emit obj \
  -g \
  -C panic=abort \
  -O \
  ../apps/examples/hello_rust/hello_rust_main.rs \
  -o ../apps/examples/hello_rust/*hello_rust.o \
  \
  -C incremental=app/target/riscv32gc-unknown-none-elf/debug/incremental \
  -L dependency=app/target/riscv32gc-unknown-none-elf/debug/deps \
  -L dependency=app/target/debug/deps \
  --extern noprelude:alloc=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/liballoc-*.rlib` \
  --extern noprelude:compiler_builtins=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/libcompiler_builtins-*.rlib` \
  --extern noprelude:core=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-*.rlib` \
  -Z unstable-options

(See the Build Script)

(We'll talk about the loooong options)

Are we Double-Floating yet?

Yep we have a Yummy Double-Float with 2 scoops of ice cream...

## Dump the ELF Header of our Compiled Rust App
## TODO: Change `../apps` to the NuttX Apps Folder
$ riscv64-unknown-elf-readelf \
  --file-header --arch-specific \
  ../apps/examples/hello_rust/*hello_rust.o

## We have Double-Float `riscv32gc` yay!
Flags: 0x5, RVC, double-float ABI

(See the ELF Header)

How did we get the Rust Compiler Options?

We copied the above options from cargo build -v...

"Rust Compiler Options"

rustc vs cargo build: What's the diff?

rustc is the Rust Compiler that compiles Rust Programs to Rust Binaries

(Works like GCC Compiler)
cargo build wraps around rustc for Multi-Step Builds

(Like for Rust Core Library)

We could have called rustc for building the Rust Core Library. But it will be a bunch of steps with many many options.

NuttX Links OK with Rust

We compiled our Rust App with Double-Float riscv32gc...

Is our NuttX Build hunky dory now?

Yep NuttX builds OK now! GCC Compiler and Rust Compiler are harmonised to Double-Float...

## Copy the Rust Binary that will be linked with NuttX
## TODO: Change `../apps` to the NuttX Apps Folder
cp \
  ../apps/examples/hello_rust/*hello_rust.o \
  ../apps/examples/hello_rust/*hello_rust_1.o

## NuttX should link correctly now.
## TODO: Change `../nuttx` to the NuttX Kernel Folder
pushd ../nuttx
make
popd

(See the Build Script)

We boot NuttX in QEMU Emulator for 32-bit RISC-V...

## For macOS:
brew install qemu

## For Debian and Ubuntu:
sudo apt install qemu-system-riscv32

## Boot NuttX in QEMU RISC-V (32-bit)
## TODO: Change `../nuttx` to the NuttX Kernel Folder
pushd ../nuttx
qemu-system-riscv32 \
  -semihosting \
  -M virt,aclint=on \
  -cpu rv32 \
  -bios none \
  -kernel nuttx \
  -nographic
popd

Our Rust App works wonderfully on NuttX! (Pic below)

NuttShell (NSH) NuttX-12.4.0-RC0

nsh> hello_rust
Hello, Rust!!

## Exit QEMU: Press `Ctrl-A` then `x`

(See the NuttX Log)

Phew so much work to build a tiny Rust App?

Yeah. And integrating this into the NuttX Makefiles will be challenging.

(How would Linux Kernel handle Custom Rust Targets?)

(More about Hard-Float Targets in RISC-V)

Rust Build for 64-bit RISC-V

From 32-bit to 64-bit: We tried compiling our Rust App for 64-bit RISC-V QEMU...

## Build NuttX for QEMU RISC-V 64-bit 
$ tools/configure.sh rv-virt:nsh64
$ make menuconfig
## TODO: Enable "Hello Rust Example"
$ make

RUSTC:  hello_rust_main.rs error: Error loading target specification: 
  Could not find specification for target "riscv64i-unknown-none-elf". 
  Run `rustc --print target-list` for a list of built-in targets

But Rust Compiler says that riscv64i isn't a valid Rust Target for 64-bit RISC-V.

Exercise for the Reader:

Is riscv64i the correct target for QEMU?

(Hint: See this)

[10 points]
How should we Fix the Build?

[10 points]
Do we need a Custom Target?

(Hint: Answer is printed in this article somewhere)

[10 points]
Will it run on Ox64 BL808 SBC?

[10 points]

What's Next

Today we learnt a bit more about C-to-Rust Interop (pic above)...

NuttX failed to link our Rust App because Rust compiles for Soft-Float, NuttX expects Double-Float

(Software vs Hardware Floating-Point)
But Rust doesn't support Double-Float

(Built-In Target doesn't exist for 32-bit RISC-V)
So we created a Rust Custom Target for Double-Float: RISCV32GC

(By mashing up RISCV32I and RISCV64GC)
We rebuilt the Rust Core Library for Double-Float

(With cargo build)
And our Rust App builds OK with NuttX

(Runs perfectly on QEMU Emulator for RISC-V)

Many Thanks to my GitHub Sponsors (and the awesome NuttX Community) for supporting my work! This article wouldn't have been possible without your support.

Sponsor me a coffee
Discuss this article on Hacker News
My Current Project: "Apache NuttX RTOS for Ox64 BL808"
My Other Project: "NuttX for Star64 JH7110"
Older Project: "NuttX for PinePhone"
Check out my articles
RSS Feed

Got a question, comment or suggestion? Create an Issue or submit a Pull Request here...

lupyuen.github.io/src/rust4.md

Appendix: Build NuttX for QEMU

Follow these steps to build NuttX for QEMU Emulator (32-bit RISC-V) bundled with our Rust App (pic above)...

#!/usr/bin/env bash
#  Build NuttX for QEMU RISC-V 32-bit with Rust App

## TODO: Set PATH
export PATH="$HOME/xpack-riscv-none-elf-gcc-13.2.0-2/bin:$PATH"

set -e  #  Exit when any command fails
set -x  #  Echo commands

## Build NuttX
function build_nuttx {

  ## Go to NuttX Folder
  pushd ../nuttx

  ## Build NuttX
  make -j 8

  ## Return to previous folder
  popd
}

## Build Rust App for QEMU RISC-V 32-bit with Rust Custom Target
function build_rust_riscv32 {

  ## Go to NuttX Folder
  pushd ../nuttx

  ## Download our Custom Target for `riscv32gc`
  rm -f riscv32gc-unknown-none-elf.json
  wget https://raw.githubusercontent.com/lupyuen/nuttx-rust-app/main/riscv32gc-unknown-none-elf.json

  ## Custom Target needs Nightly Build of Rust Compiler
  rustup override set nightly
  rustup component add rust-src --toolchain nightly

  ## Verify our Custom Target, make sure it's OK
  rustc \
    --print cfg \
    --target riscv32gc-unknown-none-elf.json

  ## `cargo build` requires a Rust Project, so we create an empty one.
  rm -rf app
  cargo new app

  ## Build the Rust Core Library for `riscv32gc`
  ## Include the `alloc` library, which will support Heap Memory in future.
  ## Ignore the error: `can't find crate for std`
  pushd app
  cargo build \
    -Zbuild-std=core,alloc \
    --target ../riscv32gc-unknown-none-elf.json \
    || true
  popd

  ## Compile our Rust App with Rust Core Library for `riscv32gc`
  ## We changed the Target to `riscv32gc-unknown-none-elf.json`
  rustc \
    --target riscv32gc-unknown-none-elf.json \
    --edition 2021 \
    --emit obj \
    -g \
    -C panic=abort \
    -O \
    ../apps/examples/hello_rust/hello_rust_main.rs \
    -o ../apps/examples/hello_rust/*hello_rust.o \
    \
    -C incremental=app/target/riscv32gc-unknown-none-elf/debug/incremental \
    -L dependency=app/target/riscv32gc-unknown-none-elf/debug/deps \
    -L dependency=app/target/debug/deps \
    --extern noprelude:alloc=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/liballoc-*.rlib` \
    --extern noprelude:compiler_builtins=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/libcompiler_builtins-*.rlib` \
    --extern noprelude:core=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-*.rlib` \
    -Z unstable-options

  ## NuttX Build need us to copy hello_rust.o to hello_rust_1.o
  cp \
    ../apps/examples/hello_rust/*hello_rust.o \
    ../apps/examples/hello_rust/*hello_rust_1.o

  ## Return to previous folder
  popd
}

## Configure the NuttX Build
make distclean
tools/configure.sh rv-virt:nsh

## Enable the Hello Rust App
kconfig-tweak --enable CONFIG_EXAMPLES_HELLO_RUST

## Update the Kconfig Dependencies
make olddefconfig

## Build NuttX. Ignore the error: `can't link soft-float modules with double-float modules`
build_nuttx || true

## Build the Rust App with Custom Target
build_rust_riscv32

## Link the Rust App with NuttX
build_nuttx

## Show the size
riscv-none-elf-size nuttx

## Export the Binary Image to nuttx.bin
riscv-none-elf-objcopy \
  -O binary \
  nuttx \
  nuttx.bin

## Copy the config
cp .config nuttx.config

## Dump the NuttX Kernel Disassembly to nuttx.S
riscv-none-elf-objdump \
  --syms --source --reloc --demangle --line-numbers --wide \
  --debugging \
  nuttx \
  >nuttx.S \
  2>&1

## Dump the Rust App Disassembly to hello_rust_1.S
riscv-none-elf-objdump \
  --syms --source --reloc --demangle --line-numbers --wide \
  --debugging \
  ../apps/examples/hello_rust/*1.o \
  >hello_rust_1.S \
  2>&1

## Start the emulator
qemu-system-riscv32 \
  -semihosting \
  -M virt,aclint=on \
  -cpu rv32 \
  -kernel nuttx \
  -nographic \
  -bios none

(See the Build Script)

Appendix: Rust Compiler Options

How did we get the Rust Compiler Options for riscv32gc?

Earlier we compiled our Rust App with Rust Core Library for riscv32gc...

"Build the Rust Core Library"

And we saw these Rust Compiler Options...

## Compile our Rust App with Rust Core Library for `riscv32gc`
## We changed the Target to `riscv32gc-unknown-none-elf.json`
## TODO: Change `../apps` to the NuttX Apps Folder
rustc \
  --target riscv32gc-unknown-none-elf.json \
  --edition 2021 \
  --emit obj \
  -g \
  -C panic=abort \
  -O \
  ../apps/examples/hello_rust/hello_rust_main.rs \
  -o ../apps/examples/hello_rust/*hello_rust.o \
  \
  -C incremental=app/target/riscv32gc-unknown-none-elf/debug/incremental \
  -L dependency=app/target/riscv32gc-unknown-none-elf/debug/deps \
  -L dependency=app/target/debug/deps \
  --extern noprelude:alloc=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/liballoc-*.rlib` \
  --extern noprelude:compiler_builtins=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/libcompiler_builtins-*.rlib` \
  --extern noprelude:core=`ls app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-*.rlib` \
  -Z unstable-options

The above options were copied from cargo build -v, here's how...

Remember we ran cargo build to compile the Rust Core Library?

## Download our Custom Target for `riscv32gc`
rm -f riscv32gc-unknown-none-elf.json
wget https://raw.githubusercontent.com/lupyuen/nuttx-rust-app/main/riscv32gc-unknown-none-elf.json

## Custom Target needs Nightly Build of Rust Compiler
rustup override set nightly
rustup component add rust-src --toolchain nightly

## Verify our Custom Target, make sure it's OK
rustc \
  --print cfg \
  --target riscv32gc-unknown-none-elf.json

## `cargo build` requires a Rust Project, so we create an empty one.
rm -rf app
cargo new app

## Build the Rust Core Library for `riscv32gc`
## Include the `alloc` library, which will support Heap Memory in future.
## Ignore the error: `can't find crate for std`
pushd app
cargo build \
  -Zbuild-std=core,alloc \
  --target ../riscv32gc-unknown-none-elf.json \
  || true
popd

cargo build will call rustc with a whole bunch of options.
We switched it to cargo build -v, which will dump the rustc options.
Hence we see the options that will compile a Rust App with our Rust Core Library for riscv32gc...

(TODO: Will these options change in future versions of cargo?)

## Build the Rust Core Library for `riscv32gc`
## And the Empty Rust Project for `riscv32gc`
## `-v` will dump the `rustc` options
$ cargo build -v \
  -Zbuild-std=core,alloc \
  --target ../riscv32gc-unknown-none-elf.json

   Compiling compiler_builtins v0.1.101
   Compiling core v0.0.0 ($HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/library/core)

     ## Generate the Rust Build Script for `riscv32gc`

     Running `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc
       --crate-name build_script_build
       --edition=2018 
       $HOME/.cargo/registry/src/index.crates.io-6f17d22bba15001f/compiler_builtins-0.1.101/build.rs
       --error-format=json
       --json=diagnostic-rendered-ansi,artifacts,future-incompat
       --diagnostic-width=94
       --crate-type bin
       --emit=dep-info,link
       -C embed-bitcode=no
       -C debuginfo=2
       -C split-debuginfo=unpacked
       --cfg 'feature="compiler-builtins"'
       --cfg 'feature="core"'
       --cfg 'feature="default"'
       --cfg 'feature="rustc-dep-of-std"'
       -C metadata=9bd0bac7535b33a8
       -C extra-filename=-9bd0bac7535b33a8
       --out-dir $HOME/riscv/nuttx-rust-app/app/target/debug/build/compiler_builtins-9bd0bac7535b33a8
       -Z force-unstable-if-unmarked
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps
       --cap-lints allow`

     ## Build the Rust Core Library for `riscv32gc`

     Running `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc
       --crate-name core
       --edition=2021 
       $HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/lib.rs
       --error-format=json
       --json=diagnostic-rendered-ansi,artifacts,future-incompat
       --diagnostic-width=94
       --crate-type lib
       --emit=dep-info,metadata,link
       -C embed-bitcode=no
       -C debuginfo=2
       -C metadata=d271c6ebb87f9b41
       -C extra-filename=-d271c6ebb87f9b41
       --out-dir $HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       --target $HOME/riscv/nuttx-rust-app/riscv32gc-unknown-none-elf.json
       -Z force-unstable-if-unmarked
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps
       --cap-lints allow`

     Running `$HOME/riscv/nuttx-rust-app/app/target/debug/build/compiler_builtins-9bd0bac7535b33a8/build-script-build`
     
   Compiling rustc-std-workspace-core v1.99.0 ($HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/library/rustc-std-workspace-core)

     ## Build the Rust Workspace Core for `riscv32gc`

     Running `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc
       --crate-name rustc_std_workspace_core
       --edition=2021 
       $HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/library/rustc-std-workspace-core/lib.rs
       --error-format=json
       --json=diagnostic-rendered-ansi,artifacts,future-incompat
       --diagnostic-width=94
       --crate-type lib
       --emit=dep-info,metadata,link
       -C embed-bitcode=no
       -C debuginfo=2
       -C metadata=52e0df2b2cc19b6e
       -C extra-filename=-52e0df2b2cc19b6e
       --out-dir $HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       --target $HOME/riscv/nuttx-rust-app/riscv32gc-unknown-none-elf.json
       -Z force-unstable-if-unmarked
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps
       --extern core=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-d271c6ebb87f9b41.rmeta
       --cap-lints allow`

     ## Build the Rust Compiler Builtins for `riscv32gc`

     Running `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc
       --crate-name compiler_builtins
       --edition=2018 
       $HOME/.cargo/registry/src/index.crates.io-6f17d22bba15001f/compiler_builtins-0.1.101/src/lib.rs
       --error-format=json
       --json=diagnostic-rendered-ansi,artifacts,future-incompat
       --diagnostic-width=94
       --crate-type lib
       --emit=dep-info,metadata,link
       -C embed-bitcode=no
       -C debuginfo=2
       --cfg 'feature="compiler-builtins"'
       --cfg 'feature="core"'
       --cfg 'feature="default"'
       --cfg 'feature="rustc-dep-of-std"'
       -C metadata=cd0d33c2bd30ca51
       -C extra-filename=-cd0d33c2bd30ca51
       --out-dir $HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       --target $HOME/riscv/nuttx-rust-app/riscv32gc-unknown-none-elf.json
       -Z force-unstable-if-unmarked
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps
       --extern core=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/librustc_std_workspace_core-52e0df2b2cc19b6e.rmeta
       --cap-lints allow
       --cfg 'feature="unstable"'
       --cfg 'feature="mem"'`

   Compiling alloc v0.0.0 ($HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/library/alloc)

     ## Build the Rust Alloc Library for `riscv32gc`
     ## Which will support Heap Memory in future

     Running `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc
       --crate-name alloc
       --edition=2021 
       $HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/library/alloc/src/lib.rs
       --error-format=json
       --json=diagnostic-rendered-ansi,artifacts,future-incompat
       --diagnostic-width=94
       --crate-type lib
       --emit=dep-info,metadata,link
       -C embed-bitcode=no
       -C debuginfo=2
       -C metadata=5d7bc2e4f3c29e08
       -C extra-filename=-5d7bc2e4f3c29e08
       --out-dir $HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       --target $HOME/riscv/nuttx-rust-app/riscv32gc-unknown-none-elf.json
       -Z force-unstable-if-unmarked
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps
       --extern compiler_builtins=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcompiler_builtins-cd0d33c2bd30ca51.rmeta
       --extern core=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-d271c6ebb87f9b41.rmeta
       --cap-lints allow`

   Compiling app v0.1.0 ($HOME/riscv/nuttx-rust-app/app)

     ## Compile our Empty Rust Project with Rust Core Library for `riscv32gc`
     ## These are the options that we copied into NuttX Build...

     Running `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc
       --crate-name app
       --edition=2021
       src/main.rs
       --error-format=json
       --json=diagnostic-rendered-ansi,artifacts,future-incompat
       --diagnostic-width=94
       --crate-type bin
       --emit=dep-info,link
       -C embed-bitcode=no
       -C debuginfo=2
       -C metadata=1ff442e6481e1397
       -C extra-filename=-1ff442e6481e1397
       --out-dir $HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       --target $HOME/riscv/nuttx-rust-app/riscv32gc-unknown-none-elf.json
       -C incremental=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/incremental
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps
       -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps
       --extern 'noprelude:alloc=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/liballoc-5d7bc2e4f3c29e08.rlib'
       --extern 'noprelude:compiler_builtins=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcompiler_builtins-cd0d33c2bd30ca51.rlib'
       --extern 'noprelude:core=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-d271c6ebb87f9b41.rlib'
       -Z unstable-options`

## Ignore this error. Rust Standard Library and `println` won't work for `riscv32gc`

error[E0463]: can't find crate for `std`
  |
  = note: the `riscv32gc-unknown-none-elf` target may not support the standard library
  = note: `std` is required by `app` because it does not declare `#![no_std]`
  = help: consider building the standard library from source with `cargo build -Zbuild-std`

error: cannot find macro `println` in this scope
 --> src/main.rs:2:5
  |
2 |     println!("Hello, world!");
  |     ^^^^^^^

error: `#[panic_handler]` function required, but not found

For more information about this error, try `rustc --explain E0463`.
error: could not compile `app` (bin "app") due to 3 previous errors

Caused by:
  process didn't exit successfully: `$HOME/.rustup/toolchains/nightly-x86_64-apple-darwin/bin/rustc --crate-name app --edition=2021 src/main.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --diagnostic-width=94 --crate-type bin --emit=dep-info,link -C embed-bitcode=no -C debuginfo=2 -C metadata=1ff442e6481e1397 -C extra-filename=-1ff442e6481e1397 --out-dir $HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps --target $HOME/riscv/nuttx-rust-app/riscv32gc-unknown-none-elf.json -C incremental=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/incremental -L dependency=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps -L dependency=$HOME/riscv/nuttx-rust-app/app/target/debug/deps --extern 'noprelude:alloc=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/liballoc-5d7bc2e4f3c29e08.rlib' --extern 'noprelude:compiler_builtins=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcompiler_builtins-cd0d33c2bd30ca51.rlib' --extern 'noprelude:core=$HOME/riscv/nuttx-rust-app/app/target/riscv32gc-unknown-none-elf/debug/deps/libcore-d271c6ebb87f9b41.rlib' -Z unstable-options` (exit status: 1)

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

rust4.md

rust4.md

Rust Custom Target for QEMU RISC-V on Apache NuttX RTOS

Software vs Hardware Floating-Point

Rust Won't Double-Float

Custom Target for Rust

Build the Rust Core Library

NuttX Links OK with Rust

Rust Build for 64-bit RISC-V

What's Next

Appendix: Build NuttX for QEMU

Appendix: Rust Compiler Options

Files

rust4.md

Latest commit

History

rust4.md

File metadata and controls

Rust Custom Target for QEMU RISC-V on Apache NuttX RTOS

Software vs Hardware Floating-Point

Rust Won't Double-Float

Custom Target for Rust

Build the Rust Core Library

NuttX Links OK with Rust

Rust Build for 64-bit RISC-V

What's Next

Appendix: Build NuttX for QEMU

Appendix: Rust Compiler Options