V10 Release — Ein Compiler für Windows x64

PBXA64 V10 RELEASE

PBXA64 V10 erzeugt native Win64-/x64-Programme (PE32+) aus PowerBASIC, typisiertem C und Assembler. Die x32-/Win32-Zielspur wurde entfernt; 32-Bit-Zielangaben werden kontrolliert abgewiesen.

Signatur gültig CHM DE + EN Win64 / x64 C: dokumentierter Teilumfang PE32+

V10 Highlights

V10 entfernt den x32-/Win32-Zielpfad: nicht unterstützte 32-Bit-Targets werden mit DRV0205 abgewiesen. Korrigierte x64-Encodings umfassen SSE-Shifts, ALU-Immediates, REX-Reihenfolge, x87-Formen und Bereichsprüfungen. Assemblergrenzen, COFF-Namen und Relokationszahlen wurden gehärtet. X-Code verbessert Masken, Konversionsbreiten, Makros und DIVMOD-Aliasing; die Assembleroptimierung wurde beschleunigt.

PBX-Compiler V8 herunterladen (ZIP) All-in-One: PBXA32, PBXA64, PBXB64, PBXC64, ScharffBasic, PBX-Editor Vorgänger-Bundles: V7 · V6 · V5 · V2 · V1 (optional) Bundle-Downloads: --

Ältere Versionen

V2 Bundle ZIP V8 archive ZIP V7 archive ZIP SHA-256

PBX-Compiler V8: 349.086.784 Bytes (332,9 MiB / 349,1 MB). Enthält PBXA32 V24, PBXA64 V10, PBXB64 V23, PBXC64 RC50, ScharffBasic und den PBX-Editor samt Hilfen, Includes und Beispielen.

Distribution V8; EXE gültig signiert, Compilerzertifikat V.1-UNQUALIFIED

Historische V10-ReleaseNotes: 840/840 CTest berichtet; hier nicht erneut ausgeführt. Formale Identität bleibt V.1-UNQUALIFIED.

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

PB / C / ASMDokumentierte Release-Eingänge; eingebettetes X-Code

V10Signierter x64-Compiler, V.1-UNQUALIFIED

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

Windows x64 / Win64

Ein klarer 64-Bit-Zielpfad

PowerBASIC, typisiertes C und Assembler teilen den nativen x64-Ausgabepfad. Die V10-ReleaseNotes dokumentieren die Entfernung der 32-Bit-Spur; win32/i686 wird mit DRV0205 abgewiesen.

PBXA64.exe --target=x86_64-pc-windows-msvc program.bas -o program64.exe

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.

Release-Eingänge und historische eingebettete Dialekte

Schreibe Code in PowerBASIC, C (inline via #CCODE), PILOT (#PCODE; historische Referenz, keine gesonderte aktuelle Paketqualifikation) 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), historische Referenz: 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 V10 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) |-> Zielpfad (Windows x64 / Win64) |-> x64-Codegenerator (Instruktionsauswahl, Registerallokation, MIR) |-> Assembler (Intel-Syntax, COFF-Ausgabe) |-> Linker (Objekte zusammenführen, Symbole auflösen) |-> 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 V10!" 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 All-in-One-Paket der Distribution V8 enthält PBXA32, PBXA64, PBXB64, PBXC64 und ScharffBasic samt PBX-Editor und aktueller CHM-Hilfe (DE+EN) — PBXA64 V10 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.

Aktueller Download und Releasegrenzen

PBX-Compiler V8: 349.086.784 Bytes (332,9 MiB / 349,1 MB). Enthält PBXA32 V24, PBXA64 V10, PBXB64 V23, PBXC64 RC50, ScharffBasic und den PBX-Editor samt Hilfen, Includes und Beispielen.

Paketlabel V10; EXE-Ressource 0.74.0-V74. Die Signatur der ausgelieferten EXE ist gültig. Der Compiler meldet weiterhin V.1-UNQUALIFIED: Authenticode ist kein Nachweis vollständiger Compilerqualifikation. Die Testzahlen in den ReleaseNotes beschreiben historische Läufe und wurden hier nicht neu ausgeführt.

CHM Deutsch CHM English V8-Paketprüfsumme