• Was benötigen wir für diese Programm?

#include <stdio.h>

int main() {
    printf("Hello World!\n");

    return 0;
}

• Zunächst einmal: Neben GCC gibt es natürlich noch andere Compiler für C/C++

• Übersetzungsprozess kann allgemein grob in zwei Abschnitte unterteilt werden:
  • Frontend (zuständig für die Sprache)
  • Backend (Übersetzung zu systemspezifischen Binäranweisungen)

Frontend: Analyse und Verarbeitung des Quellcodes

• Lexing: Zerlegen des Quellcodes in Einzelstücke (Tokens) und Whitespace
  • Präprozessor ist Teil dieses Schritts
• Parsing: Analyse der Syntax/grammatikalischen Korrektheit
  • Resultat: abstrakter Syntaxbaum (Abstract Syntax Tree, AST)
• Semantische Analyse: Logik- und Datenkorrektheit
  • Beispiel: Typfehler, undeklarierte Variablen

• Zwischen Frontend und Backend gibt es oft noch eine weitere Schicht: Middle-End

• AST wird in eine interne, einheitliche Programmiersprache übersetzt

  → Intermediate Representation

• Grund: Erleichtert Arbeit

  • Ansonsten: ähnliche Konstrukte (z.B. Schleife: for und while) separat im AST behandeln

• Weiterer Vorteil: ASTs müssen „nur“ zu IR übersetzt werden

  • Backend ist losgelöst von der Sprache

  • Einfaches Hinzufügen neuer Programmiersprachen → Erzeugung von AST aus neuer Programmiersprache

  • Sahnehäubchen: Performance hauptsächlich abhängig vom Backend

    → automatisch gut optimierte Programme für alle Sprachen

• Aufgabe im Backend: Analyse und Verarbeitung des Quellcodes
• Umwandlung in Assembly-Code und Erzeugung des Binärprogramms

// Generische C-Funktion
int add(int i) {
    return i + 1;
}

; Für x86-Plattform
add:
    lea eax, [rdi+1]
    ret

• Zusammenführen mehrerer Objektdateien zu Programm: Linking
• Außerdem: Einbinden von libc-Funktionen → printf
• Linking führt folgende Schritte durch:
  • Sammelt alle Object Files ein
  • Durchsucht diese nach fehlenden Symbolen und dann die Bibliotheken
  • „Vergibt” Adressen für Variablen und Funktionen

• Alle erforderlichen Bibliotheken werden beim Starten (Laden) des Programms geladen
• Welche Nebeneffekte hat dies?

Beispiel für die Liste an dynamisch-geladenen Bibliotheken:

al@ganymed:~/coding$ ldd dyn.elf
        linux-vdso.so.1 (0x00007f50f06a2000)
        libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f50f0400000)
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f50f020a000)
        libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f50f0124000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f50f06a4000)
        libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f50f00f7000)

• Alle verwendeten Bibliotheken werden beim Übersetzen „dazu gelegt”
• Dazu zählt auch der Start-Code für ein Programm

• Typische Fehlermeldung des Linkers:

al@ganymed:~/coding$ gcc -Wall -o hello.elf hello.c
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o:
    in function `_start':
(.text+0x17): undefined reference to `main'
collect2: error: ld returned 1 exit status

Ein Beispiel:

// hello.c
#include <stdio.h>


void hello() {
    printf("Hello World!\n");
}

// main.c
extern void hello();

int main() {
    hello();
    return 0;
}

Ergebnisse

• Je größer das Softwareprojekt, desto aufwändiger Eintippen der Compilerbefehle
• Je mehr involvierte Dateien und Compiler-Flags, desto schwerer:
  • 2-5 Dateien: Händisch gut machbar
  • 10-20 Dateien und eine Bibliothek: Schwierig
  • 100+ Dateien und 5 Bibliotheken: Nahezu unmöglich

# ... Setup code

# Targets
foo.elf: foo.c
	gcc -Wall -o foo.elf foo.c

bar.elf: bar.c foo.c
	gcc -Wall -o $@ $<

• Prinzipiell geeignet für beliebige Projektumgebungen

• Build-Systeme speziell für C/C++ sind etwas problematisch:

• Aufgrund des Alters der Sprachen und zeitweise fehlender Funktionalität gibt es eine Reihe von verschiedenen Lösungen

• Unter anderem: make, CMake, Conan

• Keine davon ist wirklich perfekt (besonders im Vergleich zu anderen Programmiersprachen)

• Bekannte Probleme: komplizierte Konfiguration, sehr komplex, externe Pakete (Bibliotheken, Programme) können nicht automatisch installiert werden

Leider gibt es hier keine gute Lösung 🙁

• Compiler können automatisch Programm-Code optimieren
• Viele Optimierungen sind gratis und beschleunigen das kompilierte Programm!
• Anschalten der Optimierungen über die Compiler-Option gcc -O:
  • gcc -O0: Standard, keine Optimierungen
  • gcc -O1: Einige Optimierungen
  • gcc -O2: Sehr viele Optimierungen (beinhaltet O1)
  • gcc -O3: Sehr aggressive Optimierungen (können ggf. das Programm auch langsamer machen)
• Liste mit allen GCC-Optimierungen ist online verfügbar

(Sehr gutes Online-Tool für anschaulichen Vergleich ist Compiler Explorer)

• Wir können jetzt programmieren ✅
  • Gilt insbesondere für die kniffligen Bereiche (Speicherverständnis/Umgang mit Speicher) ✅

• Weg von der C-Datei zum Programm
  • Präprozessor
  • Compiler
  • Linker
• Interner Aufbau eines Compilers
• Compiler-Optimierungen
• Statisches vs. dynamisches Binden