DBYTE 12.4 · NATIVE MACHINE CODE
This release stops treating native code generation like a bag of target-specific tricks. Concrete HIR is lowered into one Native MIR, legalized for the target, optimized at O0 or O1, allocated deterministically, selected into machine instructions, then written by DByte's own object and executable writers.
READ THIS FIRST. v12.4 does not replace the language manual, allocator contract, VM, collections, ABI, ELF or PE documentation. Those contracts already have owners. This release owns the native machine-code path between Concrete HIR and the existing target writers.
00 the shape of the compiler
PARSE + TYPE + OWNERSHIP
|
v
CANONICAL HIR
|
v
CONCRETE HIR
|
v
NATIVE MIR
|
+--> TARGET LEGALIZATION
+--> O0 OR O1
+--> LINEAR-SCAN ALLOCATION
+--> INSTRUCTION SELECTION
+--> PEEPHOLE
`--> DBYTE OBJECT / EXECUTABLE WRITER
There is one semantic input to production native lowering: Concrete HIR. The old direct-HIR DBYTE64 path and the old i686 evaluation-stack path remain useful as differential oracles, but they are not allowed to become alternate language interpreters.
A backend gets to choose registers and encodings. It does not get a vote on what the program means.
10 why Native MIR exists
Native MIR gives the compiler a place where machine constraints can be explicit without corrupting language semantics. Basic blocks are deterministic. Virtual registers have target-sized types. Stack objects are named. Memory effects are visible. Calls and intrinsics are resolved. Relocations exist as relocations instead of accidental strings. Source spans survive long enough to explain a bad lowering.
That matters because optimization and allocation only become trustworthy when the thing being optimized can be inspected. If the compiler hides everything inside one recursive lowering function, every performance fix becomes archaeology.
20 contracts that did not move
| Contract | Owner | 12.4 rule |
|---|---|---|
| Language semantics | 12.0 | Concrete HIR remains authority. |
| Owned runtime / Drop | 12.1 | Optimization may not move or erase ownership effects. |
| Native ABI / object formats | 12.2 | Calling convention and writer contracts remain stable. |
| VM / collections | 12.3 | VM remains a separate execution backend and oracle. |
| Machine-code pipeline | 12.4 | Native MIR through final machine encoding. |
30 what v12.4 proved
| VM corpus | 15 / 15; geometric mean 1.409877x; minimum 0.995889x. |
|---|---|
| NMOS 6502 | 151 / 151 / 151 legal-opcode authority; 4.481502x speedup. |
| Linux native | 14 workloads; geometric mean 1.635904x; minimum 0.987252x. |
| Windows native | 14 workloads; geometric mean 1.639412x; minimum 1.019105x. |
| Stability | Maximum relative MAD: Linux 4.08%, Windows 4.16%. |
| Hardware counters | UNAVAILABLE — PERF_NOT_FOUND. Wall-time, object, relocation, ABI and disassembly gates remained mandatory. |
The point is not that every workload got faster. It did not. The floor matters because a geometric mean can hide a disaster. The release contract therefore carries both an aggregate gate and per-case floors.
40 less machine junk
I686 AGGREGATE text bytes 3033 -> 2482 instructions 1201 -> 769 frame bytes 168 -> 112 X86_64-NONE AGGREGATE text bytes 175203 -> 118338 instructions 35590 -> 28764 frame bytes 308832 -> 7304
Frame reduction on the freestanding x86_64 corpus is not decorative. It is what happens when scalar locals stop being pessimistically treated like permanent memory and the allocator is allowed to keep values in registers until reality says otherwise.
If every local becomes a stack slot because the compiler is scared, the compiler is not conservative. It is lazy.
50 current package
PACKAGE dbyte-v12.4.0-windows-x64.zip BYTES 3855311 ENTRIES 450 RUNTIME 25 SHA256 433b18bbfd5c36304558a71fe169e631757dbd5285ad16c9097b36e64ee1e55f TAG OBJECT 28c074777f46bd9e8885f42c49f903ba34e19254 COMMIT a1a5c2458065f6f295d1c3e77df62a34846226e3
DOWNLOAD WINDOWS X64 · PACKAGE MANIFEST · RAW V12.4 CONTRACT
60 follow the wire
Read Native MIR when you want the representation. Read O0 and O1 when you want the legal transformations. Read register allocation when you want to know where values physically go. Read machine inspection when you distrust the compiler. You should distrust the compiler. Then make it print enough evidence to earn trust.