Belajar LLVM - Pre-Requisites Skill & Setup Environment

#Pendahuluan

Selamat datang di series Belajar LLVM! Series ini akan membawa kalian menguasai LLVM — compiler infrastructure modular open-source yang mendasari Clang, Swift, Rust, Zig, Julia, dan Mojo. Total ada 28 episode yang tersusun dalam enam fase, dari fondasi konsep sampai production readiness dan tren ekosistem 2026.

Sebelum menulis satu baris pass atau mendump IR pertama, ada skill dasar dan perangkat yang wajib kalian siapkan. Mengapa prasyarat ini penting? Karena LLVM ditulis dalam C++ dan dibangun dengan CMake/Ninja; tanpa fondasi ini, kalian akan tersesat bahkan sebelum memahami IR. Episode 0 ini adalah peta jalan kalian: kita pastikan skill dasar terpenuhi, menyiapkan toolchain, lalu membangun "Hello World" pertama.

#Skill Dasar yang Wajib Dimiliki

#Modern C++ (RAII, Templates, Smart Pointer)

LLVM ditulis dalam C++17 dan API-nya menggunakan pola C++ modern secara ekstensif. Kalian wajib nyaman dengan:

• RAII — manajemen sumber daya otomatis via constructor/destructor.
• Templates — LLVM API banyak memakai template untuk type inference.
• Smart pointer — std::unique_ptr dan std::shared_ptr untuk ownership model.

Contoh pola yang kalian butuhkan

#include <memory>
#include <vector>
 
class PassManager {
    std::vector<std::unique_ptr<Pass>> passes;
public:
    void addPass(std::unique_ptr<Pass> p) {
        passes.push_back(std::move(p));
    }
};

Jika pola di atas masih asing, selesaikan dulu materi C++ modern sebelum lanjut.

#CMake

Seluruh ekosistem LLVM dibangun dengan CMake. Kalian perlu memahami target, dependency, generator expression, dan opsi build. Tanpa ini, kalian tidak akan bisa membangun LLVM dari source atau menulis plugin out-of-tree.

#Konsep Dasar Kompilasi

Tidak perlu jago teori formal, tetapi kalian harus memahami:

• Perbedaan source code, IR, assembly, dan binary.
• Mengapa optimasi dilakukan di level IR, bukan di source atau assembly.
• Apa itu SSA (Static Single Assignment) — fondasi LLVM IR.

#Perangkat Software yang Disiapkan

#LLVM/Clang Toolchain

Cara paling cepat: install dari repository distro kalian. LLVM 22.1 (rilis Februari 2026) atau lebih baru direkomendasikan.

sudo apt install clang llvm lld lldb    # Debian/Ubuntu
sudo dnf install clang llvm lld lldb    # RHEL/Fedora

Verifikasi versi:

clang --version
llvm-config --version

Pastikan versi ≥ 17 agar mendukung New Pass Manager secara default dan fitur-fitur modern yang kita bahas di episode 7 dan seterusnya.

#CMake + Ninja

sudo apt install cmake ninja-build      # Debian/Ubuntu
sudo dnf install cmake ninja-build      # RHEL/Fedora

CMake ≥3.20 dan Ninja diperlukan untuk membangun LLVM dari source (episode 3).

#Debugger (lldb/gdb)

sudo apt install lldb gdb               # Debian/Ubuntu

Kita akan menggunakan debugger untuk step-through IR di episode 14.

#Editor dengan clangd

clangd adalah language server berbasis Clang yang memberikan autocompletion, go-to-definition, dan diagnistik real-time untuk kode C++ yang memanggil LLVM API. Install extension clangd di VS Code atau Neovim LSP kalian.

which clangd
clangd --version

#Praktik: Hello World — clang vs gcc

Buat file sederhana dan kompilasi dengan kedua compiler untuk membandingkan:

hello.c

#include <stdio.h>
 
int main() {
    printf("Hello, LLVM!\n");
    return 0;
}

clang -o hello-clang hello.c
gcc -o hello-gcc hello.c
./hello-clang
./hello-gcc

Keduanya menghasilkan output yang sama. Sekarang bandingkan ukuran binary dan behavior default:

ls -la hello-clang hello-gcc
file hello-clang hello-gcc

Perhatikan: Clang cenderung menghasilkan binary yang lebih kecil dan error message yang lebih jelas dibanding gcc. Ini adalah salah satu alasan Clang menjadi default di macOS dan banyak distro Linux modern.

#Verifikasi Environment

Sebelum lanjut ke episode 1, jalankan verifikasi menyeluruh:

clang --version
llvm-config --version
cmake --version
ninja --version
clangd --version
lldb --version

Semua command harus mencetak versi tanpa error. Jika ada yang belum terinstall, lengkapi dulu.

#Ringkasan Prasyarat

Rangkuman yang sudah kalian siapkan di episode 0:

• Skill: C++ modern (RAII, templates, smart pointer), CMake dasar, konsep kompilasi & SSA.
• Toolchain: LLVM/Clang ≥17, CMake ≥3.20, Ninja, debugger (lldb/gdb), clangd.
• Praktik: "Hello World" kompilasi via clang vs gcc, perbandingan ukuran & error message.
• Verifikasi: seluruh tool mencetak versi tanpa error.

Jika ada yang belum terpenuhi, berhenti dulu dan lengkapi sebelum melanjutkan. Perjalanan 27 episode ke depan akan jauh lebih lancar dengan pijakan yang kuat ini.

#Penutup

Inti yang harus dibawa pulang:

• LLVM ditulis dalam C++ modern — kalian wajib nyaman dengan RAII, templates, dan smart pointer.
• Toolchain wajib: Clang, LLVM, CMake, Ninja, debugger, dan clangd.
• Konsep dasar kompilasi dan SSA adalah fondasi teori yang kalian butuhkan.
• Verifikasi seluruh tool sebelum lanjut ke episode 1.

Di episode 1 selanjutnya kita akan membahas pengenalan compiler infrastructure & sejarah LLVM — dari Chris Lattner di UIUC tahun 2000, adopsi Apple 2005, hingga ekosistem proyek yang kini mencakup Clang, LLD, LLDB, Polly, Flang, dan MLIR. Pastikan environment kalian sudah siap, karena perjalanan Belajar LLVM baru saja dimulai!