Linux Toolchains for Cross-Compilation

A toolchain is a set of software tools used in a sequence to create other software, typically compilers, assemblers, and linkers.

Toolchains are created using the Yocto Project and are pre-built for your convenience. Yocto is an open-source collaboration project that provides templates, tools, and methods to help you create custom Linux-based systems for embedded products.

musl allows for static linking with libc/libc++ to create standalone binaries!

As a developer deeply involved in C++ projects, I've encountered numerous distribution challenges that come with creating standalone binaries. After successfully navigating these complexities using Linux toolchains in combination with musl, I decided to share these powerful tools with everyone. This initiative aims to provide developers with reliable tools to compile and distribute C/C++ applications across various platforms, thus simplifying the software distribution process.

We support a wide array of architectures for enhanced compatibility. For Intel 64-bit systems, our toolchains include multiple microarchitecture levels, notably x86_64_v2, the most prevalent today. For more details, see Intel 64-bit Microarchitecture Levels. Additionally, we support Intel 32-bit architectures such as x86_i686 and x86_core2. For ARM systems, we include both soft-float (armv6, armv7) and hard float (armv6hf, armv7hf) versions, as well as arm64 for 64-bit ARM architectures. Our support extends to MIPS and PPC architectures in both big and little endian configurations, along with more modern options like riscv64.

Our toolchains, crafted using the Yocto Project, include essential components such as GCC, make, cmake, binutils, gdb, python3, and perl. Each toolchain is equipped to handle the requirements for compiling C and C++ code. We provide specific versions of these components, as listed below:

Step 1: Install the toolchain on your machine

Install the toolchain on your machine by following the steps in the previous section. Use musl as the C standard library for static linking.

Step 2: Create the source files

Create a new directory for your project and navigate into it:

mkdir hello-worldcd hello-world

Create a new C++ file named main.cpp:

#include <iostream>

int main()
{
std::cout << "Hello, World!" << std::endl;
return 0;
}

Create a CMakeLists.txt file in the same directory:

cmake_minimum_required(VERSION 3.28)
project(hello-world LANGUAGES CXX)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
# Add executable
add_executable(hello-world main.cpp)
# Ensure static linking
set(CMAKE_EXE_LINKER_FLAGS "-static -static-libgcc -static-libstdc++")

This CMake file sets the project name, specifies the required C++ standard, and adds an executable target built from main.cpp. It also sets the linker flags to ensure static linking.

Step 4: Build the project using the toolchain

Source the environment setup script to configure the build environment:

. /path-to-sdk/path-to-environment-setup-script

Create a build directory and navigate into it:

mkdir buildcd build

Run CMake to configure the build environment using the CMake toolchain file specified by the environment variable CMAKE_TOOLCHAIN_FILE. This variable is set during the SDK setup and points to the appropriate toolchain file.

cmake .. -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DCMAKE_VERBOSE_MAKEFILE=TRUE

Build the project:

make

The build process generates an executable named hello-world in the build directory. The binary is statically linked with the C standard library and can be run on the target hardware.

Step 5: Ensure the binary is statically linked

Check the binary for dynamic dependencies using the ldd command:

ldd hello-world

The output should indicate that the binary is statically linked and has no dynamic dependencies.