In this lesson, you will learn how to abstract your build system to target different embedded architectures by defining standardized toolchain variables and search paths.
When you move beyond a single target, hardcoding paths like /usr/bin/arm-none-eabi-gcc into your Makefiles becomes a maintenance nightmare. To build for multiple architectures (e.g., ARM Cortex-M4 and RISC-V) from the same source tree, you must decouple the compiler identity from the build logic.
Defining Toolchain Variables
The industry standard is to define a set of common variables that represent the toolchain prefix and the binaries themselves. By prefixing these variables with your architecture target, you can swap them dynamically:
# Define the target architecture
ARCH ?= arm-none-eabi
# Define toolchain path variables
CROSS_COMPILE := $(ARCH)-
CC := $(CROSS_COMPILE)gcc
LD := $(CROSS_COMPILE)ld
OBJCOPY := $(CROSS_COMPILE)objcopy
By using the ?= (conditional assignment) operator, you allow developers to override these via the command line—for instance, make ARCH=riscv64-unknown-elf—without modifying a single line of your Makefile.
Configuring Search Paths
Simply defining the toolchain variables is not enough; the build system needs to find the correct system headers and library files specific to that architecture. You should avoid relying on the host's default /usr/include directories. Instead, explicitly use compiler flags to manage the search path:
# Specify the sysroot to ensure internal headers match the target
SYSROOT := $(shell $(CC) -print-sysroot)
CFLAGS += --sysroot=$(SYSROOT)
CFLAGS += -I$(abspath ./include)
By using the compiler's own -print-sysroot or -print-libgcc-file-name capabilities, you ensure that the build system automatically discovers the correct standard library files associated with the cross-compiler, even if the compiler is moved or updated. This approach ensures that your build remains portable across different host development environments, allowing you to seamlessly switch between hardware targets by simply changing a single variable.
Key Takeaway: Decouple your build logic from specific compiler paths by using modular variables and the compiler’s built-in discovery mechanisms to maintain architectural portability.