imported>Thorsten Klöhn: Import aus Zensical-Doku (Wissen Ahrensburg)

2026-07-17T12:43:16Z

Import aus Zensical-Doku (Wissen Ahrensburg)

Neue Seite

= Compiler: Übersetzen von Hochsprachen zu Maschinencode =

Ein '''Compiler''' übersetzt Quellcode aus Hochsprachen (wie '''C, C++, Rust''') in '''Maschinencode''', den die CPU direkt ausführen kann. Auf Linux sind die wichtigsten Compiler '''GCC, Clang und Rustc'''. Dieser Guide erklärt, wie Compiler funktionieren, welche Phasen sie durchlaufen und wie sie auf Linux eingesetzt werden.


== 📌 Warum Compiler verstehen? ==

{| class="wikitable"
|-
! Aspekt
! Nutzen
|-
| '''Performance-Optimierung'''
| Verstehe, wie Code optimiert wird (<code>-O1</code>, <code>-O2</code>, <code>-O3</code>)
|-
| '''Debugging'''
| Fehlermeldungen und Compiler-Output interpretieren
|-
| '''Interoperabilität'''
| Sprachübergreifenden Code schreiben (C ↔ Rust ↔ C++)
|-
| '''Cross-Compiling'''
| Code für andere Plattformen/Architekturen kompilieren
|-
| '''Sicherheit'''
| Verständnis für Buffer Overflows, Memory Corruption
|-
| '''Embedded Systems'''
| Spezialisierte Compiler für Mikrocontroller
|}

-----


== 🏗️ Compiler-Phasen ==

Ein Compiler durchläuft mehrere Phasen, um Quellcode in ausführbaren Maschinencode umzuwandeln:


=== 1. Preprocessing (Vorbearbeitung) ===

'''Zweck''': Makros, Includes und bedingte Kompilierung auflösen.

'''Typische Aktionen:'''

* <code>#include</code>-Direktiven durch Dateiinhalte ersetzen
* <code>#define</code>-Makros ersetzen
* <code>#ifdef</code>/<code>#endif</code>-Blöcke auflösen
* Kommentare entfernen

'''Beispiel (C):'''

<syntaxhighlight lang="c">// test.c
#include <stdio.h>
#define MAX 100

int main() {
printf("Max: %d\n", MAX);
return 0;
}</syntaxhighlight>
'''Preprocessing-Output anzeigen:'''

<syntaxhighlight lang="bash">gcc -E test.c -o test.i
# oder direkt anzeigen:
gcc -E test.c</syntaxhighlight>
'''Ergebnis (<code>test.i</code> – vereinfacht):'''

<syntaxhighlight lang="c">int main() {
__builtin_printf("Max: %d\n", 100);
return 0;
}</syntaxhighlight>

=== 2. Kompilieren (Parsing & Codegenerierung) ===

'''Zweck''': Quellcode in '''Assembler-Code''' übersetzen.

'''Schritte:'''

# '''Lexikalische Analyse''': Code in Tokens zerlegen
# '''Syntaxanalyse (Parsing)''': Tokens in einen Abstrakten Syntaxbaum (AST) umwandeln
# '''Semantische Analyse''': Typprüfung, Gültigkeitsprüfung
# '''Codegenerierung''': AST in '''Assembler''' umwandeln

'''Beispiel:'''

<syntaxhighlight lang="bash"># C-Code in Assembler übersetzen
gcc -S test.c -o test.s</syntaxhighlight>
'''Ausgabe (<code>test.s</code> – x86-64 AT&T-Syntax):'''

<syntaxhighlight lang="asm"> .text
.globl main
.type main, @function
main:
pushq %rbp
movq %rsp, %rbp
movl $100, %edi
movl $.LC0, %esi
movl $0, %eax
call printf@PLT
movl $0, %eax
popq %rbp
ret
.size main, .-main
.section .rodata
.LC0:
.string "Max: %d\n"</syntaxhighlight>

=== 3. Assemblieren ===

'''Zweck''': Assembler-Code in '''Maschinencode''' (Objektdatei <code>.o</code>) umwandeln.

'''Tools:'''

* <code>as</code> (GNU Assembler)
* <code>nasm</code> (Netwide Assembler)

'''Beispiel:'''

<syntaxhighlight lang="bash"># Assemblieren (GCC ruft intern 'as' auf)
gcc -c test.c -o test.o

# Oder manuell:
as test.s -o test.o</syntaxhighlight>
'''Objektdatei analysieren:'''

<syntaxhighlight lang="bash"># Symbole anzeigen
nm test.o

# ELF-Header anzeigen
file test.o

# Disassemblieren
objdump -d test.o</syntaxhighlight>

=== 4. Linken ===

'''Zweck''': Objektdateien und Bibliotheken zu einem '''ausführbaren Programm''' kombinieren.

'''Aufgaben des Linkers:'''

* '''Symbolauflösung''': Referenzen zwischen Objektdateien auflösen
* '''Adresszuweisung''': Speicheradressen für Code und Daten zuweisen
* '''Bibliotheken einbinden''': Statische (<code>.a</code>) oder dynamische (<code>.so</code>) Bibliotheken

'''Beispiel:'''

<syntaxhighlight lang="bash"># Einfaches Linken (GCC ruft intern 'ld' auf)
gcc test.o -o test

# Manuell mit ld:
ld -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc -o test test.o</syntaxhighlight>

-----


== 🔄 Vollständiger Kompilierungsprozess ==


=== Beispiel: C-Programm kompilieren ===

'''Quellcode (<code>hello.c</code>):'''

<syntaxhighlight lang="c">#include <stdio.h>

int main() {
printf("Hello, World!\n");
return 0;
}</syntaxhighlight>
'''Schritt-für-Schritt:'''

<syntaxhighlight lang="bash"># 1. Preprocessing
gcc -E hello.c -o hello.i

# 2. Kompilieren (C → ASM)
gcc -S hello.i -o hello.s

# 3. Assemblieren (ASM → Objektcode)
gcc -c hello.s -o hello.o

# 4. Linken (Objektcode → Executable)
gcc hello.o -o hello

# Alternative: Alles in einem Schritt
gcc hello.c -o hello</syntaxhighlight>

=== Visuelle Darstellung ===

<pre>┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ hello.c │────▶│ hello.i │────▶│ hello.s │────▶│ hello.o │
│ (C-Quellcode) │ │ (Preprocessed) │ │ (Assembler) │ │ (Objektcode) │
└─────────────────┘ └─────────────────┘ └─────────────────┘ └─────────────────┘
│
▼
┌─────────────────┐ ┌─────────────────┐
│ hello │◀────│ Dynamische │
│ (Executable) │ │ Bibliotheken │
│ │ │ (.so) │
└─────────────────┘ └─────────────────┘</pre>

-----


== 🆚 Compiler-Vergleich: GCC vs. Clang vs. Rustc ==


=== GCC (GNU Compiler Collection) ===

{| class="wikitable"
|-
! Feature
! Beschreibung
|-
| '''Sprachen'''
| C, C++, Objective-C, Fortran, Ada, Go, D, ...
|-
| '''Standard'''
| De-facto-Standard auf Linux
|-
| '''Optimierungen'''
| Sehr reif, gute Optimierungen für etablierte Architekturen
|-
| '''Plattformen'''
| x86, ARM, RISC-V, PowerPC, ...
|-
| '''Lizenz'''
| GPL
|-
| '''Frontend'''
| Eigenes Frontend für jede Sprache
|-
| '''Backend'''
| Eigenes Codegenerierungs-Backend
|-
| '''Debug-Info'''
| DWARF
|-
| '''Besonderheiten'''
| <code>-fno-stack-protector</code>, <code>-fomit-frame-pointer</code>
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># C-Programm kompilieren
gcc hello.c -o hello

# C++-Programm kompilieren
g++ hello.cpp -o hello

# Mit Optimierungen
gcc -O3 hello.c -o hello

# Mit Debug-Symbolen
gcc -g hello.c -o hello</syntaxhighlight>

=== Clang/LLVM ===

{| class="wikitable"
|-
! Feature
! Beschreibung
|-
| '''Sprachen'''
| C, C++, Objective-C, Rust (über <code>rustc</code>), Swift, ...
|-
| '''Standard'''
| Wird immer beliebter, besonders in macOS und BSD
|-
| '''Optimierungen'''
| LLVM-Backend (modular, gute Optimierungen)
|-
| '''Plattformen'''
| x86, ARM, RISC-V, WebAssembly, ...
|-
| '''Lizenz'''
| Apache 2.0 (freizügiger als GPL)
|-
| '''Frontend'''
| Clang (C/C++), kannst andere Frontends nutzen
|-
| '''Backend'''
| LLVM (modular, unterstützt viele Architekturen)
|-
| '''Debug-Info'''
| DWARF
|-
| '''Besonderheiten'''
| Bessere Fehlermeldungen, statische Analyse (<code>-Weverything</code>)
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># C-Programm kompilieren
clang hello.c -o hello

# C++-Programm kompilieren
clang++ hello.cpp -o hello

# Assembler-Output anzeigen
clang -S hello.c -o hello.s

# Mit Sanitizern (Fehlererkennung)
clang -fsanitize=address -g hello.c -o hello</syntaxhighlight>

=== Rustc ===

{| class="wikitable"
|-
! Feature
! Beschreibung
|-
| '''Sprache'''
| Rust
|-
| '''Standard'''
| Offizieller Rust-Compiler
|-
| '''Optimierungen'''
| LLVM-Backend (gleiche Optimierungen wie Clang)
|-
| '''Plattformen'''
| x86, ARM, RISC-V, WebAssembly, ...
|-
| '''Lizenz'''
| MIT/Apache 2.0
|-
| '''Frontend'''
| Rust-Compiler (eigenes Frontend)
|-
| '''Backend'''
| LLVM (Standard) oder alternative Backends
|-
| '''Debug-Info'''
| DWARF
|-
| '''Besonderheiten'''
| Memory Safety, Zero-Cost Abstractions, <code>no_std</code> Support
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># Rust-Programm kompilieren
rustc hello.rs -o hello

# Release-Modus (optimiert)
rustc --release hello.rs -o hello

# Assembler-Output anzeigen
rustc --emit asm hello.rs -o hello.s

# Cross-Compiling
rustup target add x86_64-unknown-linux-musl
cargo build --target x86_64-unknown-linux-musl</syntaxhighlight>

=== Vergleichstabelle ===

{| class="wikitable"
|-
! Kriterium
! GCC
! Clang
! Rustc
|-
| '''Geschwindigkeit'''
| ⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐
|-
| '''Optimierungen'''
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
|-
| '''Fehlermeldungen'''
| ⭐⭐⭐
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
|-
| '''Plattformunterstützung'''
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
|-
| '''Sprachunterstützung'''
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐
| ⭐⭐ (nur Rust)
|-
| '''Modularität'''
| ⭐⭐
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐
|-
| '''Statische Analyse'''
| ⭐⭐
| ⭐⭐⭐⭐⭐
| ⭐⭐⭐⭐⭐
|-
| '''Embedded-Unterstützung'''
| ⭐⭐⭐⭐
| ⭐⭐⭐
| ⭐⭐⭐⭐
|}

-----


== ⚙️ Compiler-Optionen ==


=== Optimierungsstufen ===

{| class="wikitable"
|-
! Option
! Beschreibung
! Typische Verwendung
|-
| <code>-O0</code>
| Keine Optimierung
| Debugging
|-
| <code>-O1</code>
| Grundlegende Optimierungen
| Entwicklung
|-
| <code>-O2</code>
| Aggressive Optimierungen
| Release
|-
| <code>-O3</code>
| Sehr aggressive Optimierungen
| Performance-kritische Code
|-
| <code>-Os</code>
| Optimieren für Größe
| Embedded Systems
|-
| <code>-Ofast</code>
| <code>-O3</code> + unsichere Optimierungen
| Benchmarks
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># Ohne Optimierung (Debug)
gcc -O0 -g hello.c -o hello

# Release mit Optimierungen
gcc -O2 hello.c -o hello

# Minimale Binärgröße
gcc -Os hello.c -o hello</syntaxhighlight>

=== Debug-Optionen ===

{| class="wikitable"
|-
! Option
! Beschreibung
|-
| <code>-g</code>
| Debug-Symbole hinzufügen
|-
| <code>-g3</code>
| Mehr Debug-Info (inkl. Makros)
|-
| <code>-ggdb</code>
| GDB-spezifische Debug-Info
|-
| <code>-DDEBUG</code>
| <code>DEBUG</code>-Macro definieren
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># Mit Debug-Symbolen kompilieren
gcc -g hello.c -o hello

# Debuggen mit GDB
gdb ./hello</syntaxhighlight>

=== Warnungen ===

{| class="wikitable"
|-
! Option
! Beschreibung
|-
| <code>-Wall</code>
| Alle wichtigsten Warnungen aktivieren
|-
| <code>-Wextra</code>
| Zusätzliche Warnungen
|-
| <code>-Werror</code>
| Warnungen als Fehler behandeln
|-
| <code>-Wpedantic</code>
| Strengere Standard-Konformität
|-
| <code>-Weverything</code> (Clang)
| Alle möglichen Warnungen
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># Alle Warnungen aktivieren
gcc -Wall -Wextra -Werror hello.c -o hello

# Clang: Alle Warnungen
clang -Wall -Wextra -Wpedantic -Weverything hello.c -o hello</syntaxhighlight>

=== Zielplattform & Architektur ===

{| class="wikitable"
|-
! Option
! Beschreibung
|-
| <code>-m32</code>
| 32-Bit Code generieren
|-
| <code>-m64</code>
| 64-Bit Code generieren
|-
| <code>-march=native</code>
| Optimieren für aktuelle CPU
|-
| <code>-mtune=native</code>
| Tuning für aktuelle CPU
|-
| <code>--target=<triple></code> (Rust)
| Cross-Compiling
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># 32-Bit Code generieren
gcc -m32 hello.c -o hello

# Für aktuelle CPU optimieren
gcc -march=native -O2 hello.c -o hello

# Rust: Cross-Compiling für ARM
rustup target add arm-unknown-linux-gnueabihf
cargo build --target arm-unknown-linux-gnueabihf</syntaxhighlight>

=== Standard-Bibliotheken ===

{| class="wikitable"
|-
! Option
! Beschreibung
|-
| <code>-static</code>
| Statisch linken
|-
| <code>-shared</code>
| Dynamische Bibliothek erstellen
|-
| <code>-l<name></code>
| Bibliothek <code><name>.a</code> oder <code><name>.so</code> einbinden
|-
| <code>-L<path></code>
| Bibliothekspfad hinzufügen
|-
| <code>-I<path></code>
| Include-Pfad hinzufügen
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># Statisch linken
gcc -static hello.c -o hello

# Dynamische Bibliothek erstellen
gcc -shared -fPIC -o libhello.so hello.c

# Mitlibrary linken
gcc main.c -L. -lhello -o main</syntaxhighlight>

-----


== 🔄 Cross-Compiling ==


=== Grundlagen ===

'''Cross-Compiling''' bedeutet, Code auf '''Plattform A''' zu kompilieren, der auf '''Plattform B''' läuft.

'''Typische Anwendungsfälle:'''

* Embedded Systems (Raspberry Pi, Mikrocontroller)
* Mobile Geräte (Android, iOS)
* Different architectures (ARM, RISC-V, WebAssembly)


=== Toolchains installieren ===

{| class="wikitable"
|-
! Zielplattform
! Toolchain (Debian/Ubuntu)
! Beispiel
|-
| '''x86_64 → ARM (32-bit)'''
| <code>gcc-arm-linux-gnueabi</code>
| <code>sudo apt install gcc-arm-linux-gnueabi</code>
|-
| '''x86_64 → ARM (64-bit)'''
| <code>gcc-aarch64-linux-gnu</code>
| <code>sudo apt install gcc-aarch64-linux-gnu</code>
|-
| '''x86_64 → RISC-V'''
| <code>gcc-riscv64-linux-gnu</code>
| <code>sudo apt install gcc-riscv64-linux-gnu</code>
|-
| '''x86_64 → WebAssembly'''
| <code>emscripten</code>
| [https://emscripten.org/docs/getting_started/downloads.html Emscripten installieren]
|-
| '''x86_64 → Windows'''
| <code>mingw-w64</code>
| <code>sudo apt install mingw-w64</code>
|}


=== Cross-Compiling mit GCC ===

'''Beispiel: Für ARM64 kompilieren'''

<syntaxhighlight lang="bash"># Toolchain installieren
sudo apt install gcc-aarch64-linux-gnu

# Für ARM64 kompilieren
aarch64-linux-gnu-gcc hello.c -o hello_arm64

# Ausführen mit QEMU
qemu-aarch64 ./hello_arm64</syntaxhighlight>

=== Cross-Compiling mit Rust ===

'''Beispiel: Für ARM kompilieren'''

<syntaxhighlight lang="bash"># Zielplattform hinzufügen
rustup target add arm-unknown-linux-gnueabihf

# Für ARM kompilieren
cargo build --target arm-unknown-linux-gnueabihf

# oder mit rustc
rustc --target arm-unknown-linux-gnueabihf hello.rs -o hello_arm</syntaxhighlight>

=== Cross-Compiling mit Clang ===

'''Beispiel: Für RISC-V kompilieren'''

<syntaxhighlight lang="bash"># Toolchain installieren
sudo apt install clang llvm

# Für RISC-V kompilieren
clang --target=riscv64-unknown-linux-gnu hello.c -o hello_riscv

# Ausführen mit QEMU
qemu-riscv64 ./hello_riscv</syntaxhighlight>

-----


== 📦 Bibliotheken: Statisch vs. Dynamisch ==


=== Statische Bibliotheken (<code>.a</code>) ===

* '''Vorteile''': Selbstständige Binaries, keine Abhängigkeiten
* '''Nachteile''': Größere Binaries, keine Updates ohne Neukompilierung

'''Beispiel:'''

<syntaxhighlight lang="bash"># Statische Bibliothek erstellen
gcc -c libhello.c -o libhello.o
ar rcs libhello.a libhello.o

# Mit statischer Bibliothek linken
gcc main.c -L. -l:libhello.a -o main</syntaxhighlight>

=== Dynamische Bibliotheken (<code>.so</code>) ===

* '''Vorteile''': Kleinere Binaries, geteilte Bibliotheken, Updates möglich
* '''Nachteile''': Abhängigkeiten, Ladezeit

'''Beispiel:'''

<syntaxhighlight lang="bash"># Dynamische Bibliothek erstellen
gcc -shared -fPIC -o libhello.so libhello.c

# Mit dynamischer Bibliothek linken
gcc main.c -L. -lhello -o main

# Bibliothek laden (um LD_LIBRARY_PATH erweitern)
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./main</syntaxhighlight>

=== <code>ldd</code> – Abhängigkeiten anzeigen ===

<syntaxhighlight lang="bash"># Abhängigkeiten eines Programms anzeigen
ldd ./main

# Beispielausgabe:
# linux-vdso.so.1 (0x00007ffc3a3f1000)
# libhello.so => ./libhello.so (0x00007f1234567000)
# libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f1234123000)
# /lib64/ld-linux-x86-64.so.2 (0x00007f1234789000)</syntaxhighlight>

-----


== 🔍 Compiler-Output analysieren ==


=== Assembler-Output vergleichen ===

'''Godbolt Compiler Explorer''' (https://godbolt.org/) ist das beste Tool, um zu sehen, wie verschiedene Compiler Code in Assembler umwandeln.

'''Beispiel:'''

# Gehe zu [https://godbolt.org/ godbolt.org]
# Wähle die Sprache (C, C++, Rust)
# Wähle den Compiler (GCC, Clang, Rustc)
# Füge deinen Code ein
# Vergleiche den Assembler-Output


=== Beispiel: Schleifen-Optimierung ===

'''C-Code:'''

<syntaxhighlight lang="c">int sum(int n) {
int result = 0;
for (int i = 0; i < n; i++) {
result += i;
}
return result;
}</syntaxhighlight>
'''Assembler-Output (GCC -O0 vs. -O3):'''

<code>-O0</code> (keine Optimierung):

<syntaxhighlight lang="asm">sum:
pushq %rbp
movq %rsp, %rbp
movl %edi, -20(%rbp)
movl $0, -8(%rbp)
movl $0, -4(%rbp)
jmp .L2
.L3:
movl -4(%rbp), %eax
addl %eax, -8(%rbp)
addl $1, -4(%rbp)
.L2:
movl -4(%rbp), %eax
cmpl -20(%rbp), %eax
jl .L3
movl -8(%rbp), %eax
popq %rbp
ret</syntaxhighlight>
<code>-O3</code> (optimiert):

<syntaxhighlight lang="asm">sum:
lea -1(%rdi), %eax
imul %rdi, %rax
shr %rax
ret</syntaxhighlight>
<blockquote>'''Hinweis''': Die optimierte Version nutzt die mathematische Formel <code>n*(n-1)/2</code> für die Summe der ersten <code>n-1</code> Zahlen!
</blockquote>

=== <code>objdump</code> für Binär-Analyse ===

<syntaxhighlight lang="bash"># Vollständiges Disassemblieren
objdump -d ./programm

# Mit Source-Code anzeigen (wenn -g verwendet wurde)
objdump -d -S ./programm

# ELF-Header anzeigen
objdump -f ./programm

# Alle Sections anzeigen
objdump -h ./programm

# Symbole anzeigen
objdump -t ./programm</syntaxhighlight>

=== <code>readelf</code> für ELF-Dateien ===

<syntaxhighlight lang="bash"># ELF-Header anzeigen
readelf -h ./programm

# Sections anzeigen
readelf -S ./programm

# Symbole anzeigen
readelf -s ./programm

# Dynamische Abhängigkeiten anzeigen
readelf -d ./programm</syntaxhighlight>

-----


== 💡 Compiler-Tipps & Best Practices ==


=== 1. Immer mit Warnungen kompilieren ===

<syntaxhighlight lang="bash"># Minimal für C/C++
gcc -Wall -Wextra -Werror hello.c -o hello

# Für maximale Sicherheit (Clang)
clang -Wall -Wextra -Wpedantic -Weverything -Werror hello.c -o hello</syntaxhighlight>

=== 2. Debug-Symbole verwenden ===

<syntaxhighlight lang="bash"># Mit Debug-Info kompilieren
gcc -g hello.c -o hello

# Für GDB optimiert
gcc -ggdb hello.c -o hello</syntaxhighlight>

=== 3. Optimierungen verstehen ===

* '''<code>-O0</code>''': Für Debugging (keine Optimierungen, 1:1 Mapping zwischen Code und ASM)
* '''<code>-O1</code>''': Grundlegende Optimierungen (z. B. dead code elimination)
* '''<code>-O2</code>''': Aggressive Optimierungen (Standard für Release)
* '''<code>-O3</code>''': Sehr aggressive Optimierungen (kann Code verlangsamen!)
* '''<code>-Os</code>''': Optimieren für Größe (wichtig für Embedded)


=== 4. Cross-Compiling korrekt einrichten ===

* '''Toolchain installieren''': <code>sudo apt install gcc-<arch>-linux-gnu</code>
* '''Umgebungsvariablen setzen''': <code>CC=aarch64-linux-gnu-gcc</code>
* '''Testen mit QEMU''': <code>qemu-<arch> ./programm</code>


=== 5. Statische Analyse nutzen ===

'''Clang-Tidy:'''

<syntaxhighlight lang="bash"># Installieren
sudo apt install clang-tidy

# Ausführen
clang-tidy hello.cpp --checks=* -fix</syntaxhighlight>
'''Cppcheck (für C/C++):'''

<syntaxhighlight lang="bash">sudo apt install cppcheck
cppcheck --enable=all hello.c</syntaxhighlight>

=== 6. Sanitizer für Fehlererkennung ===

{| class="wikitable"
|-
! Sanitizer
! Zweck
! GCC/Clang Option
|-
| '''AddressSanitizer'''
| Speicherfehler (Use-after-free, Buffer Overflow)
| <code>-fsanitize=address</code>
|-
| '''UndefinedBehaviorSanitizer'''
| Undefiniertes Verhalten
| <code>-fsanitize=undefined</code>
|-
| '''ThreadSanitizer'''
| Data Races
| <code>-fsanitize=thread</code>
|-
| '''MemorySanitizer'''
| Uninitialisierte Speicherzugriffe
| <code>-fsanitize=memory</code>
|}

'''Beispiel:'''

<syntaxhighlight lang="bash"># AddressSanitizer aktivieren
gcc -fsanitize=address -g hello.c -o hello
./hello

# ThreadSanitizer (nur Clang)
clang -fsanitize=thread -g hello.c -o hello -pthread</syntaxhighlight>

-----


== 📚 Lernressourcen ==


=== Bücher ===

* '''[https://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811 Compilers: Principles, Techniques, and Tools]''' – Der "Dragon Book" (Klassiker)
* '''[https://craftinginterpreters.com/ Crafting Interpreters]''' – Online-Buch über Interpreter/Compiler
* '''[https://www.gnu.org/software/gnu-c-manual/ The GNU C Programming Tutorial]''' – C mit GCC
* '''[https://doc.rust-lang.org/book/ch20-00-final-project-a-web-server.html Rust Book – Advanced Topics]''' – Rust-spezifische Themen


=== Online-Kurse ===

* '''[https://www.coursera.org/learn/compilers Stanford Compilers (Coursera)]''' – Compiler-Konzepte
* '''[https://www.nand2tetris.org/ Nand2Tetris]''' – Baue einen Computer von Grund auf
* '''[https://godbolt.org/ Compiler Explorer (Godbolt)]''' – Interaktives Lernen
* '''[https://llvm.org/docs/tutorial/ LLVM Tutorial]''' – LLVM-basierte Compiler


=== Videos ===

* '''[https://www.youtube.com/watch?v=bSkpMdDe4T8 Matt Godbolt – What Has My Compiler Done?]''' – CppCon 2019
* '''[https://www.youtube.com/watch?v=0566fV3QpG4 The Primeagen – Learning Compilers]''' – Einführung in Compiler
* '''[https://www.youtube.com/c/LiveOverflow LiveOverflow – Compiler Explorations]''' – Reverse Engineering & Compiler


=== Tools ===

* '''[https://godbolt.org/ Godbolt Compiler Explorer]''' – Assembler-Output vergleichen
* '''[https://wandbox.org/ Wandbox]''' – Online-Compiler für C/C++/Rust
* '''[https://replit.com/ Replit]''' – Online-IDE mit Compiler
* '''[https://godbolt.org/ Compiler Explorer (ARM/RISC-V)]''' – Cross-Architecture

-----


== 🔗 Verwandte Themen ==

* [[Entwicklung / Systemprogrammierung / Assembler / Grundlagen|Assembler]] – Die niedrigste Ebene unter den Compilern
* [[Entwicklung / Systemprogrammierung / Rust & C/C++ / Rust, C & C++ Integration|Rust, C++ & C Integration]] – Sprachübergreifende Programmierung
* [[Entwicklung / Systemprogrammierung / Linux / Linux-Systemprogrammierung|Linux-Systemprogrammierung]] – Wie Compiler mit dem OS interagieren

-----

''Letzte Aktualisierung: {{ git_revision_date_localized() }}''

Entwicklung / Systemprogrammierung / Compiler - Versionsgeschichte

imported>Thorsten Klöhn: Import aus Zensical-Doku (Wissen Ahrensburg)