Belajar LLVM - Cross-Compilation & Embedded Toolchain

#Pendahuluan

Setelah di episode 23 kita membahas GPU dan heterogeneous computing, pada episode ini kita membahas cross-compilation — menghasilkan binary untuk target architecture yang berbeda dari host.

Cross-compilation adalah keterampilan fundamental untuk embedded engineering, firmware development, dan mobile development. LLVM mendukung cross-compilation secara native melalui driver Clang — tanpa perlu toolchain terpisah seperti GCC cross-compiler.

#Triple Target

LLVM menggunakan target triple untuk mendeskripsikan platform tujuan:

Triple	Platform
`x86_64-linux-gnu`	Linux x86-64 (default)
`aarch64-linux-gnu`	Linux ARM64
`riscv32-unknown-elf`	Bare-metal RISC-V 32-bit
`arm-none-eabi`	Bare-metal ARM
`x86_64-w64-mingw32`	Windows (MinGW)
`wasm32-unknown-wasi`	WebAssembly

#Sysroot

Sysroot adalah direktori yang berisi header dan library target. Cross-compilation membutuhkan sysroot yang sesuai:

Cross-compile dengan sysroot

clang --target=aarch64-linux-gnu \
    --sysroot=/path/to/aarch64-sysroot \
    -o hello-aarch64 hello.c

#Multilib

Multilib memungkinkan beberapa variant ABI (Application Binary Interface) untuk target yang sama — misal hard-float vs soft-float untuk ARM:

ARM hard-float vs soft-float

clang --target=arm-none-eabihf -mfloat-abi=hard -o hard.o hello.c
clang --target=arm-none-eabi -mfloat-abi=soft -o soft.o hello.c

#clang-cl untuk Windows

clang-cl adalah mode Clang yang kompatibel dengan MSVC CLI — memungkinkan kompilasi kode Windows dari Linux atau macOS:

Compile ke Windows dari Linux

clang-cl --target=x86_64-w64-mingw32 /O2 hello.c /Fe:hello.exe

#Bare-Metal: ARM & RISC-V

Untuk embedded tanpa OS (bare-metal), gunakan libc minimal:

Library	Keterangan
newlib	Standard C library untuk embedded
picolibc	C library yang lebih ringan, suitable untuk RTOS

Bare-metal ARM compile

clang --target=arm-none-eabi \
    --sysroot=/path/to/newlib \
    -nostdlib -ffreestanding \
    -Wl,-T,linker.ld \
    -o firmware.elf main.c

#Size Optimization

Untuk firmware, ukuran binary sangat kritis:

Optimize untuk ukuran

clang --target=riscv32-unknown-elf \
    -Oz \                            # Agresif ukuran kecil
    -ffunction-sections \            # Section per fungsi
    -fdata-sections \                # Section per data
    -Wl,--gc-sections \              # Hapus section tak terpakai
    -Wl,--icf=safe \                 # Identical code folding
    -o firmware.elf main.c

#Praktik: Firmware Blink LED untuk QEMU RISC-V

Build firmware RISC-V untuk QEMU

# Install QEMU RISC-V
sudo apt install qemu-system-riscv32
 
# Source code
cat > blink.c << 'EOF'
#include <stdint.h>
volatile uint32_t *GPIO_BASE = (uint32_t *)0x10012000;
void main() {
    while (1) {
        *GPIO_BASE = 1;
        for (volatile int i = 0; i < 500000; i++);
        *GPIO_BASE = 0;
        for (volatile int i = 0; i < 500000; i++);
    }
}
EOF
 
# Compile untuk RISC-V bare-metal
clang --target=riscv32-unknown-elf -Oz \
    -ffunction-sections -fdata-sections \
    -Wl,--gc-sections \
    -nostdlib -ffreestanding \
    -o blink.elf blink.c
 
# Jalankan di QEMU
qemu-system-riscv32 -machine virt -nographic -kernel blink.elf

Tip

Clang cross-compilation untuk embedded lebih mudah daripada GCC: satu binary Clang mendukung semua target. Dengan GCC, kalian perlu install cross-compiler terpisah untuk setiap target (gcc-aarch64-linux-gnu, gcc-riscv64-linux-gnu, dll). Ini adalah salah satu alasan LLVM menjadi default di banyak embedded build system.

#Penutup

Inti yang harus dibawa pulang:

Target triple mendeskripsikan platform tujuan: arch-vendor-os-env.
Sysroot menyediakan header dan library target; multilib untuk variant ABI.
clang-cl memungkinkan kompilasi kode Windows dari platform lain.
Bare-metal: gunakan -nostdlib -ffreestanding, pilih libc minimal (newlib/picolibc).
Size optimization: -Oz -ffunction-sections -fdata-sections -Wl,--gc-sections.

Di episode 25 selanjutnya kita akan membahas performance engineering & production practices — Profile-Guided Optimization (PGO), benchmark vs GCC, compile-time tracker, dan praktik PGO+LTO pada aplikasi nyata. Sampai jumpa di episode 25!