Cross-Compiling

Cross-Compiling#

In this guide, we will cross-compile L4Re and the L4Re Microkernel for arm64. We assume a suitable arm64 cross compiler is installed.

Hint

Your distribution most likely provides some cross-compiler packages for selected platforms. Debian cross-compilers (packaged in g++-arm-linux-gnueabihf, g++-aarch64-linux-gnu and g++-riscv64-linux-gnu) have been known to work with L4Re.

If your distribution does not have the right tools or you don’t have the rights to install them, it is possible to use a toolchain located at an arbitrary location. Just interchange all occurences of the installed tools with the path to the binaries in your toolchain.

The cross-compilation of L4Re and the L4Re Mikrokernel is possible with the same sources we used to get a local build. We just need different build directories:

export L4RE_OBJDIR_ARM64=$HOME/l4re_projects/l4re_builds/arm64
export KERNEL_OBJDIR_ARM64=$HOME/l4re_projects/fiasco_builds/arm64

Cross-Compiling L4Re#

We start with initialising a build directory:

cd $L4RE_SRCDIR
make B=$L4RE_OBJDIR_ARM64

Note

Since we now added the second build directory to our sources, we either have to change the O variable in the Makeconf.local file that is located in the source tree, or we just call make in the build tree.

Configuring The Cross-Compiler#

The L4Re build system uses the CROSS_COMPILE make variable for cross-compilation. This variable is expected to contain the prefix of the cross-tools we are using. We want to use tools like aarch64-linux-gnu-gcc, aarch64-linux-gnu-g++ and aarch64-linux-gnu-ld, so the CROSS_COMPILE variable has to hold the value aarch64-linux-gnu-.

cd $L4RE_OBJDIR_ARM64
echo "CROSS_COMPILE = aarch64-linux-gnu-" > Makeconf.local

Note

We are putting the variable directly into the Makeconf.local file, so that we don’t have to provide it via the command line. Since this value is specific for this particular build, we are using the Makeconf.local file in our build directory.

Hint

If you are using a specific toolchain for cross-compilation, your Makeconf.local should look something like:

CROSS_COMPILE = /path/to/gcc/aarch64/toolchain/bin/aarch64-linux-gnu-

Configuring the Build#

Instead of using different sources, we have to configure the build.

cd $L4RE_OBJDIR_AMD64
make config    # Select ARM architecture, Cortex-A57 and QEMU virt platform

We select the Target Architecture “ARM64 Architecture (AArch64)”. This automatically chooses the CPU variant “ARMv8-A type CPU” and the Platform Selection “QEMU ARM Virtual Platform”.

Building#

Building L4Re is now possible by calling make inside the build directory:

cd $L4RE_OBJDIR_AMD64
make -j9

Cross-Compiling The L4Re Microkernel#

Cross-compiling the L4Re Microkernel is analogous to cross-compiling L4Re:

cd $KERNEL_SRCDIR
make B=$KERNEL_OBJDIR_ARM64

cd $KERNEL_OBJDIR_ARM64
echo "CROSS_COMPILE = aarch64-linux-gnu-" > Makeconf.local

make config
# In "Target configuration":
#   Select "ARM processor family" as Architecture
#          "QEMU ARM Virtual Platform" as Platform
#          "ARM Cortex-A57" CPU as CPU

make -j9

Running Hello#

Now that all is cross-built, we run the hello-cfg scenario again in QEMU. For that to work, we need to have qemu-system-aarch64 installed on the system.

To have suitable default options for running QEMU use

cp $L4RE_SRCDIR/conf/Makeconf.boot.example $L4RE_SRCDIR/conf/Makeconf.boot

and then launch the example using

cd $L4RE_OBJDIR_ARM64
make E=hello-cfg qemu MODULE_SEARCH_PATH=$KERNEL_OBJDIR_ARM64 PLATFORM_TYPE=arm_virt

Hint

MODULE_SEARCH_PATH and PLATFORM_TYPE can conveniently be specified in $L4RE_OBJDIR_ARM64/conf/Makeconf.boot.

You might also want to use the QEMU_OPTIONS variable to tune your QEMU experience. It might make sense to configure these for all build directories through the $L4RE_SRCDIR/conf/Makeconf.boot copied above.

Contents