To successfully cross-compile the embedded Linux system, you must 1. Obtain the cross-compilation toolchain (such as arm-linux-gnueabihf-gcc) suitable for the target architecture, which can be installed through the package manager or built using tools such as Buildroot; 2. Prepare the sysroot of the target system, including header files and library files, and specify the path through --sysroot or environment variables CC and CFLAGS; 3. Use the cross-compiler when compiling a simple program and verify the generated binary file format. For libraries, you need to configure the --host and --sysroot parameters, and set PKG_CONFIG_SYSROOT_DIR and PKG_CONFIG_PATH to ensure the correct dependency search; 4. Use CMake or Meson to build systems in large projects, and define the compiler, target architecture and sysroot paths through toolchain files or cross files to achieve automation; finally, you need to always verify the binary file, avoid soft and hard floating point ABI confusion, use a unified toolchain to generate the environment and correctly configure the path to prevent runtime errors. The key to the entire process is to accurately set the toolchain, sysroot and build system configurations, and it can be reused efficiently after completion.

Cross-compiling for embedded Linux systems is essential when your target device has limited resources—like low RAM, slow CPU, or no native compiler—and you need to build software on a more powerful host machine (usually x86_64) for a different architecture (like ARM, MIPS, or RISC-V).

Here's how to set it up and get it working smoothly.

1. Understand the Cross-Compilation Toolchain

A cross-compilation toolchain is a set of tools (compiler, linker, assembler, etc.) that runs on your host system but produces binaries for a different target architecture.

Key components:

• GCC cross-compiler (eg, arm-linux-gnueabihf-gcc )
• Binutils (assembler, linker, etc.)
• C library (usually glibc or musl, pre-compiled for the target)
• Header files from the target's kernel and C library

You can either:

• Use a pre-built toolchain (recommended for beginners)
• Build your own using tools like crosstool-NG or Buildroot

Example: For a 32-bit ARM device using hard-float ABI, you'd use the arm-linux-gnueabihf- toolchain prefix.

Install a common one on Ubuntu/Debian:

 sudo apt install gcc-arm-linux-gnueabihf

Test it:

 arm-linux-gnueabihf-gcc --version

2. Set Up the Target Root Filesystem (sysroot)

To compile programs that use libraries (like libc , libpthread , etc.), you need access to the target's headers and libraries. This is called the sysroot .

The sysroot is typically a copy of the target's root filesystem, or built using:

• Buildroot
• Yocto Project
• Manually copied from the device

Once you have it, point the compiler to it:

 arm-linux-gnueabihf-gcc -I$SYSROOT/usr/include \
                        -L$SYSROOT/usr/lib \
                        -sysroot $SYSROOT \
                        hello.c -o hello

Or set it globally:

 export CC=arm-linux-gnueabihf-gcc
export CFLAGS="--sysroot=$SYSROOT"

This ensures the compiler and linker find the right headers and libraries.

3. Cross-Compile Simple Programs and Libraries

For a basic C program:

 // hello.c
#include <stdio.h>
int main() {
    printf("Hello, embedded Linux!\n");
    return 0;
}

Compile:

 arm-linux-gnueabihf-gcc --sysroot=$SYSROOT hello.c -o hello

Check the output:

 file hello
# Output: ELF 32-bit LSB executable, ARM, EABI5, ...

For libraries (eg, OpenSSL, zlib):

Use the library's build system with cross-compilation options.

Example with configure :

 ./configure --host=arm-linux-gnueabihf \
           --prefix=/usr \
           --sysroot=$SYSROOT
Make
make install DESTDIR=$SYSROOT

Note: Not all projects handle --sysroot well. You may need to manually set PKG_CONFIG_LIBDIR and adjust paths.

Set environment for pkg-config:

 export PKG_CONFIG_SYSROOT_DIR=$SYSROOT
export PKG_CONFIG_PATH=$SYSROOT/usr/lib/pkgconfig

This helps pkg-config find .pc files in the sysroot.

4. Automate with Build Systems

For larger projects, use build systems that support cross-compilation:

CMake

Create a toolchain file :

 # toolchain-arm.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_VERSION 1)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g)

set(CMAKE_SYSROOT /path/to/sysroot)
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

Then build:

 cmake -DCMAKE_TOOLCHAIN_FILE=toolchain-arm.cmake ..
Make

Meson

Create a cross file arm-linux.ini :

 [binaries]
c = 'arm-linux-gnueabihf-gcc'
cpp = 'arm-linux-gnueabihf-g'
ar = 'arm-linux-gnueabihf-ar'
strip = 'arm-linux-gnueabihf-strip'

[host_machine]
system = 'linux'
cpu_family = 'arm'
cpu = 'armv7'
endian = 'little'

Build:

 meson setup --cross-file arm-linux.ini build
ninja -C build

Final Tips

• Always verify the output binary with file and test on target hardware.
• Watch out for floating-point ABI mismatches (soft vs hard-float).
• Use Buildroot or Yocto to generate consistent toolchains and sysroots.
• Avoid mixing host and target headers/libraries—this causes runtime crashes.
• Debug with strace , gdb , or cross-gdb ( arm-linux-gnueabihf-gdb ) gdbserver on target.

Basically, cross-compiling boils down to:
? Right toolchain
? Correct sysroot
? Proper build system configuration

Once set up, it becomes routine. The trickiest part is getting the sysroot and library paths just right—especially with third-party dependencies.

The above is the detailed content of How to Cross-Compile for Embedded Linux Systems. For more information, please follow other related articles on the PHP Chinese website!