aarch64-unknown-none-hermitkernel
Tier: 3
Required to build the kernel for HermitCore or RustyHermit. The result is a bare-metal aarch64 binary in ELF format.
Target maintainers
- Stefan Lankes, https://github.com/stlankes
Requirements
This target is cross-compiled. There is no support for std
, but the
library operating system provides a simple allocator to use alloc
.
By default, Rust code generated for this target does not use any vector or
floating-point registers. This allows the generated code to build the library
operaring system, which may need to avoid the use of such
registers or which may have special considerations about the use of such
registers (e.g. saving and restoring them to avoid breaking userspace code
using the same registers). In contrast to aarch64-unknown-none-softfloat
,
the target is completly relocatable, which is a required feature of RustyHermit.
By default, code generated with this target should run on any aarch64
hardware; enabling additional target features may raise this baseline.
On aarch64-unknown-none-hermitkernel
, extern "C"
uses the standard System V calling
convention,
without red zones.
This target generated binaries in the ELF format.
Building the target
Typical you should not use the target directly. The target aarch64-unknown-hermit
builds the user space of RustyHermit and supports red zones and floating-point
operations.
To build and link the kernel to the application, the crate
hermit-sys
should be used by adding the following lines to the Cargo.toml
file of
your application.
[target.'cfg(target_os = "hermit")'.dependencies]
hermit-sys = "0.1.*"
The crate hermit-sys
uses the target aarch64-unknown-none-hermitkernel
to build the kernel.
Building Rust programs
Rust does not yet ship pre-compiled artifacts for this target. To compile for
this target, you need to build the crate hermit-sys
(see
"Building the target" above).
Testing
As aarch64-unknown-none-hermitkernel
does not support std
and does not support running any Rust testsuite.
Cross-compilation toolchains and C code
If you want to compile C code along with Rust you will need an
appropriate aarch64
toolchain.
Rust may be able to use an aarch64-linux-gnu-
toolchain with appropriate
standalone flags to build for this toolchain (depending on the assumptions of
that toolchain, see below), or you may wish to use a separate
aarch64-unknown-none
(or aarch64-elf-
) toolchain.
On some aarch64
hosts that use ELF binaries, you may be able to use the host
C toolchain, if it does not introduce assumptions about the host environment
that don't match the expectations of a standalone environment. Otherwise, you
may need a separate toolchain for standalone/freestanding development, just as
when cross-compiling from a non-aarch64
platform.