V7 — Native x86-64 Multi-Language Compiler

PBXA64 V7 ALPHA

PBXA64 ist ein nativer Windows-Compiler, der PowerBASIC, C, PILOT und Inline-Assembler direkt in echte x64-Maschinencodes übersetzt – ohne GCC, ohne C-Transpilierung, ohne LLVM. Herauskommen PE32+ Executables und DLLs mit vollem EXPORT/ALIAS/ORDINAL-Support, optimiert durch einen 20-stufigen Optimierungs-Durchlauf und geprüft durch 110 automatisierte Tests.

110/110 Tests 4 Sprach-Frontends 20+ Opt-Durchläufe 408+ Mnemonics PE32+ Linker

PBXA64 V7 herunterladen (ZIP) Dokumentation (CHM) ZIP-Downloads: -- · CHM-Downloads: --

Paket: ~9.8 MB (ZIP)

Digital signiert von Theo Gottwald

110/110 CTest bestanden

10Stufen-Pipeline: Preprocessing → Lexer → Parser → Semantik → IR → Optimierung → CodeGen → Assembler → Linker → PE

4Sprach-Frontends: PowerBASIC, C, PILOT, Inline-Assembler (Intel-Syntax)

110CTest-Tests – alle bestanden, 0 Fehler. Unit-, E2E-, Integrations- und Negativ-Tests

EXE + DLLPE32+ Konsolen-Exes und DLLs mit EXPORT/ALIAS/ORDINAL, TLS, Exception-Daten

Warum PBXA64?

Echter nativer x64-Code

Keine Abhängigkeit von GCC, LLVM oder einer C-Runtime. Der Compiler erzeugt direkt x64-Maschinencodes – vom PowerBASIC-Quelltext zur ausführbaren PE-Datei in einem Durchlauf. Das bedeutet maximale Kontrolle, minimale Binary-Größe und keine Überraschungen durch Drittanbieter-Toolchains.

Multi-Language: 4 Frontends

Schreibe Code in PowerBASIC, C (inline via #CCODE), PILOT (#PCODE) oder Inline-Assembler (#ASM) – alles im selben Projekt. Der Compiler mischt die Sprachen auf IR-Ebene und erzeugt ein gemeinsames PE. Perfekt für bildungsorientierte Anwendungen und Mixed-Language-Projekte.

20+ Optimierungs-Durchläufe

Constant Folding, Dead Code Elimination, Mem2Reg, Copy Propagation, CFG Cleanup, Strength Reduction, Instruction Combining, Branch Simplification, SCCP, GVN, DSE, ADCE, Reassociation, Load Forwarding, SROA, Inlining (CGSCC), LICM, FMA Contraction, Auto-Vectorization, PGO – alle Durchläufe arbeiten auf einer eigens entwickelten MGC-Zwischendarstellung (IR).

Eigener PE32+-Linker

Kein externer Linker nötig. Der integrierte Linker verarbeitet COFF-Objekte, extrahiert Archive (.lib), löst Symbole auf, generiert Import-Tabellen, TLS-, Exception- (.pdata/.xdata), Load-Config- und Reloc-Sektionen. Inklusive Post-Link-Optimierung (DCE, ICF, Strip) und LTO.

Sprach-Frontends im Detail

PowerBASIC (.pb, .bas, .pbi)

Vollständiger PowerBASIC-Dialekt: #DIM ALL, DECLARE/LIB/ALIAS, FUNCTION PBMAIN, SUB/FUNCTION, LOCAL/GLOBAL/SHARED/STATIC, TYPE/UNION/ENUM, Makro-Präprozessor, bedingte Übersetzung, #ASM/#CCODE/#PCODE-Direktiven, #OVERRIDE zum Ersetzen eingebauter Funktionen, MODULE-System (Delphi-Stil) mit INTERFACE/IMPLEMENTATION.

Weitere Frontends

C (#CCODE): C-Lexer/Parser, struct/union/typedef/enum/pointer/array, externe Funktionsdeklarationen, Initialisierer, Übersetzung in MGC-IR.
PILOT (#PCODE): Bildungsorientierte PILOT-Sprache: T:/A:/M:/Y:/N:/J:/U:/E:-Befehle, bedingte Suffixe, Pattern Matching.
Inline-ASM (#ASM): Intel-Syntax-x64-Blöcke mit CLOBBER/UNSAFE/ALLOW_PRIVILEGED, Variablenbindung (%var, {var}), ASMDATA-Direktiven.

Datentypen

Typ	Größe	Beschreibung
BYTE	1	Vorzeichenloser 8-Bit-Wert
WORD / INTEGER	2	Vorzeichenloser/Signed 16-Bit
DWORD / LONG	4	Vorzeichenloser/Signed 32-Bit
QUAD	8	Signed 64-Bit
SINGLE	4	IEEE 754 32-Bit-Gleitkomma
DOUBLE	8	IEEE 754 64-Bit-Gleitkomma
STRING	16	Dynamischer Deskriptor (ptr + len)
WSTRING	16	UTF-16-Deskriptor
VARIANT	16	COM VARIANT
ASCIIZ PTR / Zeigertypen	8	BYTE PTR, WORD PTR, DWORD PTR, LONG PTR, QUAD PTR

Alle Befehle & Builtins

Kontrollstrukturen

IF / THEN / ELSE / ELSEIF END IF / ENDIF SELECT CASE FOR / NEXT WHILE / WEND DO / LOOP GOTO GOSUB / RETURN EXIT (FOR/DO/WHILE/FUNCTION) ITERATE (FOR/DO) ON ERROR / RESUME / RESUME NEXT DATA / READ / RESTORE

String-Befehle & -Funktionen (44+)

LEN STRPTR VARPTR TRIM$ / LTRIM$ / RTRIM$ UCASE$ / LCASE$ REPEAT$ STRDELETE$ STRINSERT$ STRREVERSE$ BIN$ / OCT$ / HEX$ REPLACE$ TALLY / VERIFY / SCAN$ MID$ / LEFT$ / RIGHT$ SPACE$ CHR$ / ASC VAL / STR$ FORMAT$ BUILD$ / CLIP$ / RETAIN$ SHRINK$ / NUL$ / DEC$ MKI$ / MKL$ / MKQ$ MKS$ / MKD$ CVI / CVL / CVQ / CVS / CVD JOIN$ / SPLIT PEEK$ / INPUT$ INKEY$ / WAITKEY$ COMMAND$ / ENVIRON$ CURDIR$ / DIR$ TAB$ MID$ (Statement)

Mathematik-Builtins

ABS / MIN / MAX / CLAMP INT / FIX / SGN / FRAC SIN / COS / TAN / ATN SQR / EXP / LOG / LOG10 POW RND / RANDOMIZE ROUND FREEFILE IIF / CHOOSE / SWITCH

Arrays

DIM (feste Arrays) REDIM (dynamische Arrays) LBOUND / UBOUND ARRAY ASSIGN ARRAY SORT ARRAY COPY ARRAY SCAN ARRAY REVERSE ARRAY DELETE ARRAY INSERT

Datei-I/O

OPEN (OUTPUT/APPEND/INPUT) OPEN (RANDOM/BINARY) CLOSE / RESET PRINT # / WRITE # / INPUT # LINE INPUT # GET # / PUT # SEEK # LOF / EOF / LOC KILL / NAME MKDIR / CHDIR / RMDIR DIR$ FILECOPY GETATTR / SETATTR FREEFILE FLUSH / SETEOF REMAIN$ OPEN (Unicode ENCODING)

Threading & Parallelisierung

THREAD FUNCTION XLAUNCH WAITFOR THREAD CLOSE THREAD SUSPEND THREAD RESUME THREAD STATUS

COM / OOP

CLASS (VTabellen) IUnknown LET / SET / GET VariantInit / VariantClear CoCreateInstance SysAllocStringByteLen SysFreeString

GUI / DDT / Grafik

DIALOG NEW / DIALOG SHOW CONTROL ADD GRAPHIC WINDOW LINE / BOX / PAINT CIRCLE MENU NEW BAR / POPUP ATTACH

Netzwerk (Winsock)

TCP OPEN / SEND / RECV UDP OPEN / SEND / RECV TCP NOTIFY TCP LINE INPUT TCP PRINT

Sonstige Befehle

SLEEP SWAP INCR / DECR PRINT / PRINT USING LIKE (Wildcard-Vergleich) POKE / PEEK CODEFTR / CODEPTR CALLBACK DATE$ / TIME$ / TIMER RANDOMIZE XOR / EQV / IMP

Makro-Präprozessor & #OVERRIDE

Präprozessor-Direktiven

#DEFINE #UNDEF #IF / #ELSEIF / #ELSE #ENDIF $IF / $ELSE / $ENDIF #INCLUDE #INCLUDE ONCE #DIM ALL #DEBUG #TOOLS #OPTIMIZE #STACK #REGISTER #ALIGN %DEF() Abfrage

Der Präprozessor unterstützt Objekt-ähnliche Makros, einzeilige Makros, MACRO/MACROFUNCTION mit MACROTEMP, Äritätsprüfung, Rekursionsschutz und Duplikaterkennung.

#OVERRIDE – Builtins ersetzen

Mit #OVERRIDE kann jede eingebaute Funktion (LEN, ASC, TRIM$, UCASE$, LCASE$, REPEAT$, MID$, LEFT$, RIGHT$, SPACE$, CHR$, STR$, VAL, BIN$, OCT$, HEX$, FORMAT$, INSTR, TALLY, VERIFY, SCAN$, REPLACE$, STRDELETE$, STRINSERT$, STRREVERSE$, LTRIM$, RTRIM$, JOIN$, SPLIT, CLIP$, RETAIN$, SHRINK$, NUL$, DEC$, BUILD$, MKI$…MKD$, CVI…CVD, PEEK$) durch eigenen PowerBASIC- oder #ASM-Code ersetzt werden – mit Dispatch nach exaktem Parametertyp.

' Eigene TRIM$-Implementierung #OVERRIDE TRIM$ FUNCTION MyTrim(s AS STRING) AS STRING ' Benutzerdefinierte Trim-Logik FUNCTION = s END FUNCTION

Compiler-Pipeline & Optimierung

Quelltext (.pb/.bas/.pbi/.c/.pilot) |-> Präprozessor (Makroexpansion, #IF, #INCLUDE, #OVERRIDE) |-> Lexer (Tokenisierung) |-> Parser (AST-Aufbau, rekursiv absteigend) |-> Semantische Analyse (Typ-Prüfung, Symbol-Auflösung, #DIM ALL) |-> IR (PB HIR → MGC IR Bridge) |-> Optimierer (20+ Durchläufe) |-> Codegenerator (Instruktionsauswahl, Registerallokation, MIR) |-> Assembler (Intel-Syntax, COFF-Ausgabe) |-> Linker (Objekte zusammenführen, Symbole auflösen, PE32+ schreiben) |-> PE32+ EXE/DLL

Optimierungs-Durchläufe (20+)

Constant Folding Dead Code Elimination Mem2Reg Copy Propagation CFG Cleanup Strength Reduction InstCombine Branch Simplify SCCP GVN Dead Store Elim. ADCE Reassociation Load Forwarding SROA Inlining LICM FMA Contraction Vectorization PGO

Optimierungs-Stufen

Stufe	Beschreibung
`-O0`	Keine Optimierung (Standard)
`-O1`	Safe Scalar Pipeline
`-O2`	SSA Optimizer Pipeline
`-O3`	O2 + Late Scalar Cleanup

Zusätzlich: --pgo-generate, --pgo-use, --flto=full|thin, --verify-each-pass, --time-passes

Integrierter Assembler (408+ Mnemonics)

ISA-Familie	Mnemonics	Abgedeckt
Core GPR	~400	Datentransfer, Arithmetik, Logik, Shift/Rotate, Bit-Operationen, Sprünge, Stack/Flags
SSE/SSE2/SSE3/SSSE3/SSE4	~300	Skalare/vektorielle FP-Operationen, Ganzzahl-SIMD
AVX/AVX2/AVX-512/FMA	~500	Erweiterte Vektoroperationen, FMA-Verschmelzung
BMI1/BMI2	~16	Bit-Manipulation
AES-NI / SHA / Crypto	~25	Hardware-beschleunigte Kryptographie
Systembefehle	~50	CPUID, RDTSC, SGDT, SWAPGS, etc.
SGX / VMX / CET	~40	Enclave-/Virtualisierungs-/Shadow-Stack-Befehle
MMX	~60	Ganzzahl-SIMD (x86-Kompatibilität)
x87 FPU	~80	Legacy-Fließkomma
Cache / Prefetch	~20	PREFETCH, CLFLUSH, MFENCE, etc.

Unterstützte Operanden: x64 GPRs (8/16/32/64-Bit), XMM-Register, 6 Adressierungsmodi, 21 Operand-Varianten, Segment-Überschreibungen (fs:, gs:), relative Calls/Jumps, ASMDATA-Direktiven (db, dw, dd, dq, ascii, asciz).

PE32+-Linker — Features

COFF-Objekt-Laden .lib-Archiv-Extraktion Symbol-Auflösung (weak/strong) Relokationen (ADDR64/REL32/SECREL) Import-Tabelle (IID/INT/ILT/IAT) PE32+-Header + Section-Table TLS-Directory Load Config Directory Exception-Daten (.pdata/.xdata) Debug-Info + CodeView Base Relocations (.reloc) DLL-Export-Tabelle (.edata) Resource-Compilation Post-Link DCE / ICF / Strip LTO (Link-Time Optimization) PE-Verifikation

DLL-Output

' Ein Quelltext → EXE + DLL #COMPILE EXE "app.exe" #COMPILE DLL "math.dll" EXPORT ALL FUNCTION AddOne(BYVAL x AS LONG) AS LONG FUNCTION = x + 1 END FUNCTION SUB Ping() EXPORT ALIAS "PB_Ping" END SUB

Unterstützt EXPORT, EXPORT ALIAS "Name", EXPORT ORDINAL n. Der Compiler erzeugt aus einem Quelltext mehrere Ausgabedateien.

Kommandozeilen-Optionen

Option	Beschreibung
`-o <file>`	Ausgabedatei festlegen
`-c`	Nur compilieren (Objektdatei)
`-S`	Nur Assembler-Ausgabe
`/exe` / `/dll`	EXE oder DLL erzeugen
`-O0` … `-O3`	Optimierungsstufe
`--flto=full\|thin`	Link-Time Optimization
`--pgo-generate` / `--pgo-use`	Profilgesteuerte Optimierung
`-g` / `/debug`	Debug-Informationen
`--dump-tokens/--dump-ast/--dump-ir`	IR-Dumps für Debugging
`--diagnostic-format=text\|json\|sarif`	Diagnostikformat wählen
`-Wall / -Wextra / -Werror`	Warnungssteuerung
`--subsystem=console\|windows`	Subsystem wählen
`--entry=<symbol>`	Einsprungspunkt festlegen
`--nodefaultlibs`	Standard-WinAPI-Imports deaktivieren

Beispiele

Hallo Welt (Konsolen-EXE)

#COMPILE EXE "hello.exe" #DIM ALL FUNCTION PBMAIN() AS LONG PRINT "Hello from PBXA64 V7!" FUNCTION = 0 END FUNCTION

Threading mit XLAUNCH (Multi-Parameter + Strings)

THREAD FUNCTION Worker(n AS LONG, msg AS STRING) AS LONG PRINT "Thread " & STR$(n) & ": " & msg FUNCTION = n * 2 END FUNCTION FUNCTION PBMAIN() AS LONG LOCAL h AS LONG XLAUNCH Worker(42, "Hallo aus dem Thread!") TO h WAITFOR h PRINT "Thread fertig" FUNCTION = 0 END FUNCTION

XLAUNCH unterstützt beliebig viele Parameter, auch STRING, WSTRING, LONG, QUAD, DOUBLE und benutzerdefinierte Typen. Das Handle wird mit TO an eine LONG-Variable gebunden.

DLL mit EXPORT

#COMPILE DLL "math.dll" #DIM ALL FUNCTION AddOne(BYVAL x AS LONG) EXPORT AS LONG FUNCTION = x + 1 END FUNCTION

WinAPI + Inline-ASM

#ASM mov rax, %x add rax, 1 mov %x, rax #ENDASM

PBXA64 V7 jetzt herunterladen

110/110 Tests bestanden. Signiertes Binary. Inklusive Hilfe (CHM), WinAPI .pbi-Dateien und Beispielen.

Download ZIP V7 Dokumentation