LLVM erklärt: Das Baukastensystem hinter modernen Compilern

Wie Clang, Rust, Swift und Julia auf einer gemeinsamen Infrastruktur aufbauen und was ein eigener Compiler damit kostet
Aktualisiert:
Abstract
- #LLVM
- #Compiler
- #Programmiersprachen
- #Clang
- #Rust
- #Swift
- #Julia
- #Intermediate Representation
- #Code-Generierung
- #Backend
Ein Zwischencode, viele Sprachen, viele Prozessoren: Warum fast jede neue Programmiersprache auf LLVM setzt
Wer heute ein Rust-Programm baut, eine iOS-App in Swift kompiliert oder C++ mit Clang übersetzt, benutzt am Ende dasselbe Stück Software, ohne es zu merken. Die letzte Etappe vom Quelltext zur ausführbaren Datei erledigt in allen drei Fällen LLVM. Auch Julia, Kotlin/Native, Zig und viele Werkzeuge für Grafikkarten und WebAssembly greifen darauf zurück.
Dass so unterschiedliche Sprachen sich einen Unterbau teilen, ist kein Zufall, sondern eine Architekturentscheidung. LLVM zerlegt den Compiler in austauschbare Bausteine. Eine neue Sprache muss nur noch ihren eigenen Teil schreiben und erbt Optimierungen und Prozessorunterstützung, an denen Hunderte Entwickler:innen über zwei Jahrzehnte gearbeitet haben. Was das technisch bedeutet, wie der Einstieg aussieht und für wen sich der Aufwand lohnt, zeigt der folgende Überblick.
Woher LLVM kommt und was der Name heute bedeutet
LLVM entstand ab dem Jahr 2000 als Forschungsprojekt an der University of Illinois in Urbana-Champaign. Chris Lattner entwickelte es zusammen mit seinem Betreuer Vikram Adve. Die erste öffentliche Version erschien 2003. Ursprünglich stand das Kürzel für „Low Level Virtual Machine“. Mit einer virtuellen Maschine im Sinne von Java oder .NET hat das Projekt aber wenig zu tun, deshalb verstehen die Entwickler LLVM längst nur noch als Eigennamen.
Den Sprung aus der Forschung schaffte LLVM, als Apple Lattner 2005 einstellte. Apple brauchte einen Compiler, der sich eng mit Xcode verzahnen ließ, und baute auf LLVM das C-Frontend Clang auf. Später entwarf Lattner bei Apple auch Swift. Heute arbeiten Firmen wie Apple, Google, Intel, AMD, Arm und Microsoft sowie viele Freiwillige gemeinsam an dem Projekt. Der Code steht unter der Apache-Lizenz 2.0 mit LLVM-spezifischen Ausnahmen, die das Einbinden in eigene, auch proprietäre Produkte erleichtern.
LLVM ist dabei kein einzelnes Programm, sondern eine Sammlung von Projekten unter einem Dach. Dazu gehören:
- Clang, der Compiler für C, C++ und Objective-C, samt Werkzeugen wie clang-format und clang-tidy,
- LLD, ein schneller Linker, der die übersetzten Teile zu einer ausführbaren Datei verbindet,
- LLDB, ein Debugger, den unter anderem Xcode verwendet,
- die Sanitizer, Laufzeitprüfungen, die etwa Speicherfehler oder Datenwettläufe in C- und C++-Programmen aufspüren,
- MLIR, ein Rahmenwerk für Zwischencodes auf höherer Ebene, das unter anderem in vielen Compilern für maschinelles Lernen steckt.
Das Prinzip: Frontend, Zwischencode, Backend
Jeder Compiler übersetzt Text, den Menschen lesen können, in Befehle, die ein Prozessor ausführt. Klassisch geschieht das in drei Stufen.
Das Frontend liest den Quelltext, prüft Syntax und Typen und meldet Fehler. Es ist der Teil, der eine Sprache ausmacht: Die Regeln von Rust unterscheiden sich grundlegend von denen von C. Das Middle-End verbessert das Programm, ohne seine Bedeutung zu ändern. Es entfernt Code, der nie ausgeführt wird, rechnet konstante Ausdrücke vorab aus oder fügt kleine Funktionen direkt an der Aufrufstelle ein. Das Backend schließlich erzeugt Maschinencode für eine bestimmte Architektur, also etwa x86-64 im Rechenzentrum, ARM im Smartphone oder RISC-V in eingebetteten Systemen.
Ohne gemeinsamen Unterbau müsste jede Sprache alle drei Stufen selbst bauen. Bei fünf Sprachen und fünf Prozessorfamilien wären das im ungünstigsten Fall 25 Kombinationen. LLVM schiebt dazwischen eine einheitliche Schnittstelle: Jede Sprache liefert ihr Programm in derselben Zwischendarstellung ab, und jedes Backend versteht genau diese Darstellung. Aus 25 Kombinationen werden fünf Frontends plus fünf Backends.
Ein Vergleich aus der Logistik: Ein Versandhändler, der für jeden Lieferanten und jeden Paketdienst eigene Formulare pflegt, verliert schnell den Überblick. Einigen sich alle auf ein einheitliches Versandetikett, muss jeder nur noch dieses eine Format beherrschen. Die LLVM-Zwischendarstellung ist ein solches Etikett.
Die Intermediate Representation im Detail
Die Zwischendarstellung heißt LLVM IR (Intermediate Representation). Sie liegt in drei gleichwertigen Formen vor: als Datenstruktur im Speicher des Compilers, als kompakte Binärdatei (Bitcode) und als lesbarer Text. Die Textform sieht aus wie eine Assemblersprache, ist aber unabhängig von einem bestimmten Prozessor.
Drei Eigenschaften machen sie für Optimierungen besonders geeignet:
- Static Single Assignment (SSA): Jeder Wert wird genau einmal zugewiesen. Statt eine Variable
xmehrmals zu überschreiben, entstehen neue Werte wie%x1und%x2. Dadurch lässt sich leicht verfolgen, woher ein Wert stammt und ob er überhaupt gebraucht wird. - Strenge Typen: Jede Operation kennt den Typ ihrer Operanden, etwa eine 32-Bit-Ganzzahl oder eine Gleitkommazahl doppelter Genauigkeit. Fehler im Frontend fallen so früh auf.
- Unbegrenzt viele Register: Die IR tut so, als hätte der Prozessor beliebig viele Speicherplätze. Erst das Backend verteilt die Werte auf die tatsächlich vorhandenen Register.
Wie das in der Praxis aussieht, lässt sich mit Clang selbst ausprobieren. Der folgende Befehl übersetzt eine C-Datei nicht in Maschinencode, sondern gibt die IR als Text aus:
# IR einer C-Datei erzeugen (Textform, Dateiendung .ll)
clang -S -emit-llvm -O2 summe.c -o summe.ll
# Dieselbe IR mit dem Optimierer weiterbearbeiten (neuer Pass-Manager)
opt -passes='default<O3>' summe.ll -S -o summe-o3.ll
# IR in Assemblercode für eine bestimmte Zielarchitektur übersetzen
llc -mtriple=aarch64-linux-gnu summe-o3.ll -o summe.s
Wer die Datei summe.ll öffnet, erkennt schnell die Struktur: Funktionen beginnen mit define, bestehen aus benannten Grundblöcken und enden mit ret. Ein lohnender Lerneffekt entsteht, wenn Sie dieselbe Funktion einmal mit -O0 und einmal mit -O2 übersetzen und die Ergebnisse vergleichen. Aus einer Schleife, die Zahlen aufsummiert, wird bei eingeschalteter Optimierung oft eine geschlossene Rechenformel oder Vektorcode, der mehrere Werte gleichzeitig verarbeitet.
Seit einigen Hauptversionen hat sich die IR spürbar vereinfacht. Zeiger tragen keinen Typ mehr, man schreibt nur noch ptr statt etwa i32*. Diese sogenannten Opaque Pointers sind seit LLVM 15 Standard. Ältere Tutorials und Codebeispiele, die noch typisierte Zeiger verwenden, lassen sich mit aktuellen Versionen nicht mehr ohne Anpassung übersetzen.
Wie eine Sprache IR erzeugt: ein kleines Beispiel
Wer eine eigene Sprache baut, schreibt die IR nicht als Text, sondern erzeugt sie über die C++-Programmierschnittstelle von LLVM. Das zentrale Werkzeug ist der IRBuilder, der Befehle an der aktuellen Position einfügt. Angenommen, eine kleine Fachsprache für Preisregeln soll aus einem Bruttopreis und einem Steuersatz den Nettopreis berechnen. Der Generator dafür könnte so aussehen:
#include <memory>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Verifier.h>
#include <llvm/Support/raw_ostream.h>
int main() {
llvm::LLVMContext context;
auto module = std::make_unique<llvm::Module>("preisregeln", context);
llvm::IRBuilder<> builder(context);
// Signatur: double netto(double brutto, double satz)
llvm::Type *dbl = builder.getDoubleTy();
auto *fnType = llvm::FunctionType::get(dbl, {dbl, dbl}, /*isVarArg=*/false);
auto *fn = llvm::Function::Create(fnType, llvm::Function::ExternalLinkage,
"netto", module.get());
llvm::Value *brutto = fn->getArg(0);
llvm::Value *satz = fn->getArg(1);
brutto->setName("brutto");
satz->setName("satz");
// Rumpf: brutto / (1.0 + satz)
auto *entry = llvm::BasicBlock::Create(context, "entry", fn);
builder.SetInsertPoint(entry);
llvm::Value *eins = llvm::ConstantFP::get(dbl, 1.0);
llvm::Value *divisor = builder.CreateFAdd(eins, satz, "divisor");
llvm::Value *ergebnis = builder.CreateFDiv(brutto, divisor, "ergebnis");
builder.CreateRet(ergebnis);
// Die Prüfung meldet strukturelle Fehler, bevor sie später Ärger machen
if (llvm::verifyFunction(*fn, &llvm::errs())) {
return 1;
}
module->print(llvm::outs(), nullptr);
return 0;
}
Übersetzt wird das Programm gegen die installierten LLVM-Bibliotheken. Das Hilfsprogramm llvm-config liefert die passenden Compiler- und Linker-Optionen:
clang++ generator.cpp $(llvm-config --cxxflags --ldflags --libs core) -o generator
./generator
Die Ausgabe ist gültige IR, die sich direkt an opt und llc weiterreichen lässt:
; ModuleID = 'preisregeln'
source_filename = "preisregeln"
define double @netto(double %brutto, double %satz) {
entry:
%divisor = fadd double 1.000000e+00, %satz
%ergebnis = fdiv double %brutto, %divisor
ret double %ergebnis
}
Für eine echte Sprache kommt natürlich mehr dazu: Variablen, Verzweigungen, Schleifen und Funktionsaufrufe. Das Prinzip bleibt aber gleich. Jeder Knoten im Syntaxbaum erzeugt über den IRBuilder die passenden Befehle, und LLVM übernimmt den Rest bis zur ausführbaren Datei.
Der Weg zur eigenen Sprache: was LLVM abnimmt und was nicht
Die Arbeitsteilung ist klar verteilt. Vor dem Codegenerator stehen zwei Bausteine, die jedes Sprachprojekt selbst schreiben muss. Der Lexer zerlegt den Quelltext in Tokens, also in Schlüsselwörter, Namen, Zahlen und Operatoren. Der Parser setzt diese Tokens nach den Regeln der Grammatik zu einem abstrakten Syntaxbaum (AST) zusammen, einer Baumstruktur, die zeigt, welcher Ausdruck zu welchem gehört. Danach folgen Namensauflösung und Typprüfung. Diese Schritte machen den Charakter einer Sprache aus, und LLVM hilft dabei nicht.
Ein Lexer muss dabei nicht kompliziert sein. Die folgende Skizze in C++20 erkennt Zahlen, Namen und einzelne Operatorzeichen:
#include <cctype>
#include <string>
#include <string_view>
#include <vector>
enum class TokenArt { Zahl, Name, Operator };
struct Token {
TokenArt art;
std::string text;
};
std::vector<Token> zerlege(std::string_view quelle) {
std::vector<Token> tokens;
std::size_t i = 0;
while (i < quelle.size()) {
const unsigned char c = quelle[i];
if (std::isspace(c)) {
++i;
} else if (std::isdigit(c)) {
const std::size_t start = i;
while (i < quelle.size() &&
(std::isdigit(static_cast<unsigned char>(quelle[i])) || quelle[i] == '.')) {
++i;
}
tokens.push_back({TokenArt::Zahl, std::string(quelle.substr(start, i - start))});
} else if (std::isalpha(c)) {
const std::size_t start = i;
while (i < quelle.size() && std::isalnum(static_cast<unsigned char>(quelle[i]))) {
++i;
}
tokens.push_back({TokenArt::Name, std::string(quelle.substr(start, i - start))});
} else {
tokens.push_back({TokenArt::Operator, std::string(1, quelle[i])});
++i;
}
}
return tokens;
}
Nach dem Codegenerator übernimmt LLVM: Optimierung, Registerverteilung, Befehlsauswahl für die Zielarchitektur und, zusammen mit LLD, das Linken. Zusätzlich bekommt eine neue Sprache Debug-Informationen im Standardformat DWARF, sodass gängige Debugger mit ihr umgehen können. Für interaktive Umgebungen gibt es mit ORC eine Schnittstelle für Just-in-Time-Kompilierung, bei der Code erst zur Laufzeit übersetzt wird. Julia nutzt dieses Prinzip, um numerischen Code beim ersten Aufruf auf die tatsächlichen Datentypen zuzuschneiden.
Der beste Einstieg ist das offizielle Tutorial „Kaleidoscope“ in der LLVM-Dokumentation unter llvm.org/docs/tutorial. Es baut in mehreren Kapiteln eine kleine Sprache mit Lexer, Parser, Codegenerator und JIT auf und wird mit den Versionen gepflegt. Das ist wichtig, denn die C++-Schnittstelle von LLVM gilt ausdrücklich nicht als stabil. Mit jeder Hauptversion können sich Funktionsnamen und Signaturen ändern. Beispiele aus Blogartikeln, die einige Jahre alt sind, kompilieren deshalb häufig nicht mehr. Ein bekanntes Beispiel ist der alte Pass-Manager für Optimierungen, der zugunsten eines neuen Systems entfernt wurde.
Wer LLVM heute nutzt und welche Alternativen es gibt
Die Liste der Sprachen mit LLVM-Unterbau ist lang. Neben Clang für C und C++ gehören Rust, Swift, Julia und Kotlin/Native dazu. Emscripten übersetzt C- und C++-Code über LLVM nach WebAssembly, sodass etwa Bild- oder Videoverarbeitung im Browser laufen kann. Hersteller von Grafikkarten und KI-Beschleunigern nutzen LLVM-Backends für ihre Chips. Auch die Werkzeugketten für Android und für Apple-Plattformen setzen auf Clang. Wie Rust diese Infrastruktur für sichere Systemprogrammierung nutzt, beschreibt unser Beitrag über Rust als Sprache für sichere und schnelle Systeme. Wie C++-Code über LLVM in den Browser gelangt, zeigt der Beitrag zu WebAssembly und JavaScript-Performance.
LLVM ist trotzdem nicht konkurrenzlos. Die GNU Compiler Collection (GCC) bleibt in der Linux-Welt verbreitet und erzeugt bei manchen Programmen schnelleren Code. Microsoft liefert für Windows weiterhin einen eigenen C++-Compiler aus. Einige jüngere Sprachen wollen sich bewusst unabhängiger von LLVM machen: Go hatte schon immer einen eigenen Compiler, Zig arbeitet an eigenen Backends für schnellere Debug-Builds, und für Rust gibt es mit Cranelift ein alternatives Backend, das auf kurze Übersetzungszeiten statt auf maximale Optimierung zielt. Der Hintergrund ist eine bekannte Schwäche von LLVM: Gründliche Optimierung kostet Zeit, und große Projekte warten mitunter lange auf ihre Builds. Mehr zu Zig steht in unserem Beitrag über die Programmiersprache Zig.
Was das für Unternehmen und Entwicklungsteams bedeutet
Für die allermeisten Teams ist LLVM kein Werkzeug, das sie direkt anfassen, sondern eine Grundlage, auf der ihre Sprachen stehen. Trotzdem lohnt es sich, die Architektur zu verstehen. Wer weiß, was zwischen Quelltext und Binärdatei passiert, versteht Fehlermeldungen besser, kann Optimierungsstufen bewusst wählen und Werkzeuge wie die Sanitizer oder clang-tidy gezielt in die Build-Pipeline einbauen. Gerade bei bestehendem C- und C++-Code fängt ein AddressSanitizer im Testlauf Speicherfehler ab, die sonst erst in der Produktion auffallen würden.
Eine eigene Programmiersprache zu entwickeln, ist dagegen selten wirtschaftlich. Der Compiler ist nur ein Teil: Eine Sprache braucht Dokumentation, Editor-Unterstützung, Bibliotheken und Menschen, die sie beherrschen. Sinnvoll ist LLVM für Fachsprachen, die sehr schnell rechnen müssen, etwa für Simulationen, Regelwerke mit Millionen Auswertungen oder Datenpipelines. Auch wer Hardware entwickelt, kommt um ein eigenes Backend kaum herum. Für Konfigurations- oder Abfragesprachen in Fachanwendungen reicht dagegen meist ein Interpreter, der sich in einem Bruchteil der Zeit bauen lässt.
Unsere Einschätzung: Für Entwickler:innen ist LLVM eines der lehrreichsten Open-Source-Projekte überhaupt, und ein Wochenende mit dem Kaleidoscope-Tutorial schärft das Verständnis für jede Sprache, die man täglich benutzt. Für Unternehmen zählt vor allem die indirekte Wirkung: Sprachen wie Rust und Swift sind auch deshalb so schnell erwachsen geworden, weil sie nicht bei null anfangen mussten. Wenn Sie überlegen, Teile einer C- oder C++-Codebasis auf Rust umzustellen, unterstützen wir Sie mit Beratung und Seminaren zur Rust-Entwicklung.
Häufige Fragen zu LLVM
Muss LLVM separat installiert sein, um Rust oder Swift zu verwenden?
Nein, nicht als separate Installation. Die Compiler bringen ihre eigene, passende LLVM-Version mit. Eine eigene LLVM-Installation brauchen Sie nur, wenn Sie direkt mit Clang arbeiten oder selbst Werkzeuge auf Basis der LLVM-Bibliotheken entwickeln.
Ist Clang ein vollständiger Ersatz für GCC?
Für die meisten C- und C++-Projekte ja. Clang unterstützt die aktuellen Sprachstandards weitgehend und ist zu vielen GCC-Optionen kompatibel. Unterschiede gibt es bei einigen GCC-spezifischen Erweiterungen und bei der Leistung des erzeugten Codes, die je nach Programm in die eine oder andere Richtung ausfällt. Ein Vergleich mit der eigenen Codebasis ist aussagekräftiger als jeder allgemeine Benchmark.
Wie aufwendig ist eine eigene kleine Sprache mit LLVM?
Ein Prototyp mit Zahlen, Funktionen und Verzweigungen ist nach dem Kaleidoscope-Tutorial in einigen Tagen machbar, wenn solide C++-Kenntnisse vorhanden sind. Eine Sprache für den produktiven Einsatz mit Fehlermeldungen, Standardbibliothek und Werkzeugen ist dagegen ein Projekt über Monate oder Jahre.
Lässt sich LLVM auch aus anderen Sprachen als C++ ansteuern?
Ja. LLVM bietet eine C-Schnittstelle, die stabiler ist als die C++-API. Darauf bauen Anbindungen für Python, Rust, OCaml und andere Sprachen auf. Für Experimente mit Python ist etwa die Bibliothek llvmlite verbreitet, die auch der Numba-Compiler verwendet.
Kategorien