V9 Beta — Ein Compiler für Win32 und Win64

PBXA64 V9 BETA

PBXA64 ist ein nativer x64-Windows-Compiler, der Programme für Win32 (x86/i686, PE32) und Win64 (x64, PE32+) erzeugt. Die Dual-Target-Ausgabe gilt für PowerBASIC, das typisierte C-Frontend und den Assembler.

91/91 CTest 1.099/1.099 Samples Win32 + Win64 C-Coverage 80%+ PE32 + PE32+

V9 Highlights

V9 erweitert das typisierte C-Frontend um globale Objekte, Arrays, Zeiger, Aggregate, Initialisierer, Casts, sizeof, typisierte Aufrufe und Diagnosen. Die ausgelieferte C-Laufzeit implementiert jetzt die string.h- und stdlib.h-Oberfläche — Speicher, Strings, Allokation, Prozessende und Integer-Konvertierung.

Korrigierte BMI1/BMI2-VEX-Präfixe, Operandenbreiten und erweiterte Registercodierung, gehärtete Win32-Laufzeiterzeugung und deterministisches Release-Staging. CHM-Hilfe und Release-Includes aktualisiert; alle Beispiele fail-closed qualifiziert: 91/91 CTest, 12/12 Native-Matrix-Fälle und 1.099/1.099 Samples für Win32 und Win64.

PBX-Compiler herunterladen (ZIP) All-in-One: PBXA32, PBXA64, PBXB64, ScharffBasic und PBX-Editor Vorgänger-Bundle: V1 (optional) Bundle-Downloads: --

Ältere Versionen

V8 ZIP V7 ZIP SHA-256

PBX-Compiler-Paket: 62,5 MB (ZIP) — PBXA32, PBXA64, PBXB64 und ScharffBasic inklusive PBX-Editor, CHM-Hilfe (DE+EN), 400 Beispiele, 354 Includes und 34 C17-Header

Digital signiert von Theo Gottwald

91/91 CTest und 12/12 Native-Matrix bestanden

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

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

91/91CTest bestanden, ergänzt durch 12/12 Native-Matrix-Fälle und 1.099/1.099 Samples

EXE + DLLPE32- und PE32+-Ausgabe mit EXPORT/ALIAS/ORDINAL, TLS und Exception-Daten

Native Cross-Compilation

Ein x64-Compiler, zwei Windows-Ziele

PBXA64 selbst läuft als 64-Bit-Anwendung. Mit einem Schalter bestimmst du, ob dein Projekt als kompaktes x86/i686-Programm für Win32 oder als natives x64-Programm für Win64 entsteht. PowerBASIC, C und Assembler durchlaufen dabei dieselbe geprüfte Toolchain.

Win32

--target=win32
x86 / i686 / PE32

Win64

--target=win64
x64 / PE32+

Dasselbe Programm für beide Ziele

PBXA64.exe --target=win32 program.bas -o program32.exe PBXA64.exe --target=win64 program.bas -o program64.exe

Die Release-Matrix kompiliert PowerBASIC, C und ASM für beide Zielarchitekturen mit -O0 und -O2.

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/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

Keine externe Regex-DLL

REGEXPR 1.25 direkt integriert

PBXA64 V9 enthält eine erweiterte NFA-Engine für reguläre Ausdrücke. Sie bietet bis zu 64 Capture-Gruppen, benannte Gruppen, UTF-8/UCP, Lookaround, Rückverweise sowie gierige, faule und possessive Quantifizierer.

PowerBASIC-Code verwendet die Statements REGEXPR/REGREPL oder die kompakten Funktionen REGEX$/REGEXREPLACE$. Die C-Schnittstelle unterstützt zusätzlich Match, Search, Replace, Split und Find-All.

Online-Referenz öffnen

Capture-Gruppe lesen und Namen umstellen

FUNCTION PBMAIN() AS LONG LOCAL sourceText AS STRING, familyName AS STRING, reordered AS STRING sourceText = "Ada Lovelace" familyName = REGEX$("([A-Za-z]+) ([A-Za-z]+)", sourceText, 2) PRINT familyName ' Lovelace reordered = REGEXREPLACE$("([A-Za-z]+) ([A-Za-z]+)", _ sourceText, "$2, $1") PRINT reordered ' Lovelace, Ada FUNCTION = 0 END FUNCTION

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) |-> Zielwahl (--target=win32 oder --target=win64) |-> i686- oder x64-Codegenerator (Instruktionsauswahl, Registerallokation, MIR) |-> Assembler (Intel-Syntax, COFF-Ausgabe) |-> Linker (Objekte zusammenführen, Symbole auflösen) |-> PE32 oder 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/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/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 V9!" 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 jetzt im PBX-Compiler herunterladen

Das digital signierte All-in-One-Paket enthält PBXA32, PBXA64, PBXB64 und ScharffBasic samt PBX-Editor und aktueller CHM-Hilfe (DE+EN) — PBXA64 V9 mit Target-Headern, Laufzeit, WinAPI-Includes und Beispielen.

Dokumentation

Downloads pro Tag

Tägliche Download-Statistik für alle Produkte der letzten 28 Tage (rollierend). Release-Markierungen kennzeichnen neue Produktversionen.