Lyx Compiler – CLI Referenz

Der Lyx-Compiler (lyxc) ist ein moderner Cross-Compiler für Linux, Windows, macOS und Embedded-Systeme. Er kombiniert Compiler, Linker und statisches Analyse-Werkzeug in einem einzigen Binary.

lyxc [Optionen] <Eingabedatei(en)>

# Einfaches Beispiel
lyxc main.lyx -o main

# Mehrere Quelldateien
lyxc main.lyx utils.lyx protocol.lyx -o app

# Cross-Compilation mit vollständigem Safety-Build
lyxc main.lyx --target=arm64 --target-energy=1 --stack-check --lint -o firmware.elf

Flags können in beliebiger Reihenfolge angegeben werden. Kurzformen (‑o) und Langformen (--output) sind gleichwertig, wo beide existieren.

# Normaler Build (Linux)
lyxc main.lyx -o myapp

# Mit externer C-Bibliothek linken
lyxc main.lyx -o myapp -lm -lpthread

# Shared Library erstellen
lyxc mylib.lyx --shared -o libmylib.so

# Unit vorkompilieren
lyxc --compile-unit src/utils.lyx
# → erzeugt: src/utils.lyu

Lyx unterstützt native Cross-Compilation ohne externe Toolchain-Konfiguration (sofern der Linker installiert ist).

lyxc main.lyx --target=arm64 -o firmware.elf
lyxc main.lyx --target=win64 -o app.exe
lyxc main.lyx --target=riscv -o controller.elf

Erzwingt eine spezifische CPU-Architektur, unabhängig vom Target:

lyxc main.lyx --target=linux --arch=arm64 -o cross.elf

Verfügbare Werte: x86_64, arm64, xtensa, riscv64

Gibt das Sysroot für Cross-Compilation an (Pfad zu den Ziel-System-Bibliotheken):

lyxc main.lyx --target=arm64 --sysroot=/opt/arm64-sysroot -o app.elf

Steuert das Energy-Aware-Backend. Beeinflusst Loop Unrolling, SIMD-Nutzung, Inlining-Aggressivität und Instruktions-Scheduling.

lyxc node.lyx --target=arm64 --target-energy=1 -o sensor.elf   # Batterie-optimiert
lyxc dsp.lyx  --target=linux --target-energy=5 -o dsp.out      # Max-Performance

Deaktiviert alle IR-Optimierungen (Constant Folding, Dead Code Elimination, Loop Unrolling). Nützlich für Debugging und Timing-Messungen.

lyxc main.lyx --no-opt --debug -o main_dbg

Deaktiviert Constant Folding für Fließkomma-Operationen. Verhindert, dass der Compiler Berechnungen umordnet oder zusammenfasst (äquivalent zu globalem @flight_crit für FPU). Pflicht für DO-178C-Zertifizierung mit FPU-Nutzung.

lyxc flight.lyx --no-fp-fold --target=arm64 -o flight.elf

Maximale Größe (in IR-Instruktionen), bis zu der Funktionen automatisch inline gesetzt werden. Standard: 20. Irrelevant bei @inline (immer) und @no_opt (nie).

Diese Flags sind für die Zertifizierung sicherheitskritischer Software essenziell. Sie erzeugen Reports und schärfen die Prüfungen des Compilers.

# Schritt 1: Instrumentieren
lyxc flight.lyx --mcdc-instrument -o flight_instr.elf

# Schritt 2: Tests ausführen (erzeugt flight.cov)
./flight_instr.elf --run-tests

# Schritt 3: Report erstellen
lyxc flight.lyx --coverage-report=flight.cov -o evidence/mcdc_report.txt

$ lyxc flight.lyx --stack-check --call-graph

Stack-Analyse:
  ProcessSensor  → Frame: 48 B, max. Tiefe: 1   → Gesamt:   48 B  ✅
  FilterData     → Frame: 96 B, max. Tiefe: 1   → Gesamt:   96 B  ✅
  ParsePacket    → Frame: 32 B, max. Tiefe: 8   → Gesamt:  256 B  ✅ (limit: 512)
  MergeSort      → Frame: 64 B, max. Tiefe: 10  → Gesamt:  640 B  ✅ (limit: 8192)
  RecursiveCalc  → Tiefe nicht beschränkbar                        ✗ Fehler

Fehler: RecursiveCalc besitzt kein @stack_limit und keine nachweisbare Terminierung.

$ lyxc flight.lyx --provenance -o flight.elf

Provenance-Log: flight.elf.prov
  Quelldatei:     flight.lyx  (SHA-256: a3f7c2...)
  Compiler:       lyxc v0.9.0
  Compile-Zeit:   2026-05-22T14:30:00Z
  Flags:          --target=arm64 --stack-check --no-fp-fold --lint --provenance
  Target:         arm64 (AAPCS64, ELF64)
  Energy-Level:   3 (Standard)
  Units importiert: std.io, std.result, std.math (je mit SHA-256)

$ lyxc add.lyx --emit-asm --target=linux

; fn Add(a: int64, b: int64): int64
Add:
    push  rbp
    mov   rbp, rsp
    mov   rax, rdi
    add   rax, rsi
    pop   rbp
    ret

$ lyxc add.lyx --emit-asm --target=arm64

Add:
    stp   x29, x30, [sp, #-16]!
    mov   x29, sp
    add   x0, x0, x1
    ldp   x29, x30, [sp], #16
    ret

$ lyxc main.lyx --trace-passes -o main

Pass: Parser            2.3 ms   (823 Nodes)
Pass: Semantic          1.1 ms   (0 Fehler, 2 Warnungen)
Pass: IR-Gen            3.4 ms   (1204 IR-Instruktionen)
Pass: Constant-Fold     0.4 ms   (37 Faltungen)
Pass: DCE               0.2 ms   (12 Instruktionen entfernt)
Pass: Loop-Unroll       0.6 ms   (8 Schleifen, Faktor 4×)
Pass: Register-Alloc    1.8 ms
Pass: Code-Emit         2.1 ms   (3.2 KB Code)
Pass: Linker            0.9 ms
Gesamt:                12.8 ms → main (3.6 KB)

$ lyxc flight.lyx --symbol-sizes --target=arm64

Symbol-Größen:
  Funktionen:
    ProcessFlightData    312 B
    FilterAltitude        88 B
    ParsePacket          156 B
    main                  64 B
  Globale Variablen:
    g_sensor_buffer     2048 B
    g_config              32 B
  Gesamt Code:           620 B
  Gesamt Daten:         2080 B

Der integrierte Linter läuft als Teil des Compile-Prozesses oder eigenständig.

$ lyxc main.lyx --lint-only

main.lyx:12: Warnung [unused-var] 'temp' wird nie gelesen
main.lyx:28: Warnung [risky-cast] int64 → uint8 (mögliche Truncation)
main.lyx:41: Warnung [unbounded-loop] while ohne 'limit' in @dal(B)-Modul
main.lyx:55: Fehler   [unsafe-in-dal] unsafe-Block in @dal(A)-Modul nicht erlaubt

3 Warnungen, 1 Fehler

lyxc main.lyx -o main
./main

lyxc main.lyx --debug --debug-level=2 --no-opt -o main_dbg
./main_dbg
# Bei Absturz: vollständiger Stack-Trace mit Zeilennummern

lyxc main.lyx --lint-only --lint-strict
# Exit-Code 0 = sauber, 1 = Warnungen/Fehler → Pipeline schlägt fehl

lyxc main.lyx \
    --target=arm64 \
    --target-energy=3 \
    -o app.elf

# Auf dem Zielgerät ausführen:
scp app.elf pi@raspberrypi:~/
ssh pi@raspberrypi ./app.elf

lyxc sensor.lyx \
    --target=esp32 \
    --target-energy=1 \
    --static \
    --stack-check \
    -o sensor.elf

lyxc flight_control.lyx \
    --target=arm64 \
    --no-fp-fold \
    --stack-check \
    --call-graph \
    --static-analysis \
    --lint --lint-strict \
    --mcdc-instrument \
    --integrity-check \
    --provenance \
    --symbol-sizes \
    --emit-map \
    -o evidence/fcc.elf

# MC/DC-Nachweis (nach Test-Durchlauf):
./evidence/fcc.elf --run-tests
lyxc flight_control.lyx --coverage-report=fcc.cov -o evidence/mcdc_report.txt

# Level 1: Batterie-optimiert
lyxc dsp.lyx --target-energy=1 --symbol-sizes -o dsp_low.elf

# Level 5: Maximum-Performance
lyxc dsp.lyx --target-energy=5 --symbol-sizes -o dsp_high.elf

# Größenvergleich
ls -lh dsp_low.elf dsp_high.elf
# dsp_low.elf:  8.2 KB  (wenig Unrolling, kein SIMD)
# dsp_high.elf: 24.1 KB (8× Unrolling, AVX2-Instruktionen)

lyxc main.lyx --trace-passes --emit-ir --emit-asm -o main 2>build.log
grep "Pass:" build.log | sort -k3 -n   # Langsamste Passes zuerst

lyxc main.lyx \
    --provenance \
    --call-graph \
    --target=arm64 \
    -o release/main.elf

cat release/main.elf.prov   # Vollständiger Audit-Trail

Weiterführende Seiten:

• Compiler selbst kompilieren – make-Targets, FPC, Cross-Compilation
• Aerospace & Safety – @flight_crit, DO-178C
• Aerospace Tutorial – vollständiger Zertifizierungs-Workflow
• Energy-Aware Programmiermodell – --target-energy im Detail
• Memory Management – --stack-check und @stack_limit
• DO-178C Compliance – MC/DC, Call-Graph, Provenance