t27b: run-time 128-bit integers (type i128 at run time in phi_f64_literals, eval_arith and source_text) #7915

Activity

1. tri-claw

   added

   queen-shaped

   on Oct 8, 2026
2. gHashTag commented on Oct 10, 2026

   

   gHashTag

   on Oct 10, 2026

   OwnerAuthor

   More actions

   Measured on the t27c lab at master dae6b17, with t27c and t27b built from it and zig 0.16.0. This comment widens #7915 to the whole type i128 cluster of the t27b ledger: three specs share one gap.

   1. What the three specs do with i128 at run time

   The reference passes all three under t27c test-report (8/8, 12/12 and 16/16). t27b refuses each one first at type i128.

   Operation	phi_f64_literals	source_text	eval_arith
   return type -> i128	normalise_rhs (line 52)	digit_value, radix, parse_int (lines 63, 72, 83)	pow2, ty_min, ty_max, wrap, mag, shift_amount, ev_value
   parameter : i128	-	-	one or two per fn: ok, fits, wrap, checked, mag, mul_too_large, shift_amount, arith, ev_trap, ev_value. In arith(op, bits, signed, boolean, a, b), AAPCS64 puts a in x4:x5 and b in x6:x7
   local	untyped const result = normalise_rhs(..)	const base, const d, const x (line 166), var v assigned by v = v * base + d	const m, const ma, const width, const amt
   struct field	Expectation.want (line 14; the struct is never used)	-	EvalArith.value: built in a literal, returned by value, read as .value
   module const of type i128 used at run time	-	NO_INT (-1), I128_MAX (2^127-1), U32_MAX, U64_MAX (2^64-1)	ONE, ZERO, U64_MAX (2^64-1)
   literal outside i64 as a run-time operand	-	2^127-1 and 2^64-1, through the consts	2^64-1 and 2^63 as arguments, for example ev_value(.., 18446744073709551615, ..)
   literal returned or compared	returns 7286977268806824, -52 and 0; compares == 7286977268806824 and == -52	returns 99, 10, 16, 8 and 2	many
   == !=	== with a literal	== and !=	==
   < <= > >=	-	>=, > and <=	all four
   checked +	-	v * base + d	a + b
   checked -	-	I128_MAX - d	ZERO - x, pow2(n) - ONE, m - pow2(n), a - b, width - ONE
   checked *	-	v * base	a * b
   *%	-	-	a *% b, which wraps at 128 bits for (2^64-1)^2
   @divTrunc	-	@divTrunc(I128_MAX - d, base): a 127-bit dividend over a run-time divisor of 2, 8, 10 or 16	@divTrunc(U64_MAX, ma), and @divTrunc(a, b) with negative operands
   @rem	-	-	@rem(a, b), including @rem(-2^63, -1)
   & | ^	-	-	all three
   << >>	-	-	ONE << n, a << n and a >> n. gen-zig prints << @intCast(n) with n a u32, so the amount is a checked cast to u7
   cast to i128	-	@intCast(c - 48), u8 to i128 (always fits)	@intCast(bits), u32 to i128 (always fits)
   cast from i128	-	-	amt as u32, which gen-zig prints as @as(u32, @intCast(amt)), a checked cast

   None of the three uses:

   • unary - or ~ on an i128;
   • +% or -%;
   • / or % on an i128 (Zig refuses both, see gen (Zig): / and % between i128 operands emit plain / and %, which Zig refuses #8066);
   • as i128 (the parser refuses it, see parser: as i128 and as u128 are refused as cast targets #8067);
   • casts between i128 and i64;
   • an i128 in an array, a slice or an optional;
   • conversions between i128 and a float;
   • u128.

   Covered today: nothing at run time. specs/tri/t27b/wide_plan.t27 (#7657, see #7423) folds integers wider than 64 bits only while they stay compile-time values. That covers literals, const X: i128 = .., operators between those, comparisons, and as back to a type of at most 64 bits. It refuses a wide value placed beside a run-time one, which is source_text's refusal at line 296 (I128_MAX beside a call).

   2. Zig 0.16 Debug semantics, measured on the lab (x86_64-linux, the reference host)

   • @sizeOf(i128) is 16 and @alignOf(i128) is 16. struct { t: u8, v: i128 } is 32 bytes, align 16.
   • +, - and * with a result outside i128 panic with integer overflow.
   • @divTrunc(x, 0) and @rem(x, 0) panic with division by zero.
   • @divTrunc(minInt, -1) panics with integer overflow. @rem(minInt, -1) returns 0 and does not panic.
   • << drops the bits shifted out and does not panic (3 << 127 is minInt). >> is arithmetic (-7 >> 1 is -4).
   • << @intCast(n) with n = 128, and @as(u32, @intCast(x)) with x = 2^32, panic with integer does not fit in destination type.

   3. Minimal repro

   module i128_repro;
   
   fn pick(x: bool) -> i128 {
       if (x) {
           return 7286977268806824;
       }
       return -52;
   }
   
   test pick_returns_i128 {
       assert(pick(true) == 7286977268806824);
       assert(pick(false) == -52);
   }
   

   • The reference runs 1 test and passes it.
   • t27b reports unsupported construct type i128 at line 3, then ExprCall(rejected fn) at line 11.

   4. Design note: why this stops at the measurement

   There is no PR this round. Even the smallest honest slice (the repro and phi_f64_literals: a return, a literal and ==) must first decide how an i128 exists at run time. That is a decision about the backend's register model, not a coverage lane:

   • Ty (cli/t27b/src/ir.rs) is a scalar that fits in one register. codegen.rs keeps every scalar in one X, W or D register (temps in x9-x15, homes in x19-x28, arguments in x0-x7), and keeps aggregates in frame memory behind a Ptr.
   • Ty::min, Ty::max and Ty::wrap shift by bits, which overflows at 128.
   • The interpreter (eval.rs with eval_arith.t27) computes exactly in i128. That is enough only for operands of at most 64 bits: an i128 + can need 129 bits.

   There are two designs, and both are exact.

   A. A register pair in codegen. A new Ty::I128 holds lo and hi in two X registers. This is the design the requested instruction sequences need:

   • adds/adcs and subs/sbcs, with the V flag of the high half as the overflow trap;
   • mul/umulh on the halves plus the cross terms, with the overflow check on the 256-bit product;
   • a compare as cmp plus sbcs (or ccmp);
   • division and remainder as a call of a t27 routine with the algorithm of __udivmodti4, spliced in the way libm.t27 is.

   A touches every place codegen moves a value: temps and spills, variable homes, AAPCS64 calls (an i128 takes an even-numbered pair, x0:x1 to x6:x7, and returns in x0:x1), loads and stores (ldp/stp), and Select, Widen and Cast. eval_arith.t27 must also learn 128-bit overflow without 129-bit arithmetic. a64.t27 already has adds, subs, umulh, smulh, ldp and stp; adcs, sbcs and ccmp would be added there.

   Estimate for A, in hand lines: ir.rs ~25, codegen.rs ~300-450, lower.rs ~60-100, eval.rs ~20, tests ~40. That is 450-650 in total.

   B. A 16-byte value in memory, decided in lowering. The value is two u64 words with Zig's size and alignment, held like a struct. Codegen, the IR and the interpreter do not change. Every operation becomes a call of a t27 routine spliced in under t27b's reserved prefix (__t27b_i128_add, _mul, _divtrunc, _cmp, ...). Each routine returns a status, and the lowering turns that status into a trap at the operator's own site and line.

   Estimate for B: lower.rs ~110-150 hand lines (the type, materializing literals and constants, dispatching operators, compares, casts, shifts, @divTrunc and @rem, the trap check, and the splice) plus tests ~20-30. The routines (~350 lines) and the plan are t27.

   B has these costs:

   • a call per operation;
   • no umulh: t27 has no high multiply, so a 64x64 product is built from 32-bit halves;
   • a fn with an i128 parameter uses t27b's internal ABI, so an object file does not export it;
   • the interpreter runs the same routines as the JIT, so the differential test no longer checks i128 arithmetic independently. The routines need their own tests under the reference, as libm.t27 has.
   • the trap check must not count as a run-time assert (see t27c test-report: count executed asserts and flag vacuous passes (sieve C10, T730) #6509).

   Which to pick: B is cheaper for these three specs. A makes i128 a first-class type: fast, exported under AAPCS64, and checked independently by the interpreter.

   Either design needs more than the ~150 hand lines a lane may carry. Under the net <= 0 rule (check_budget() in specs/policy/own_language.t27, see #8236), the same PR must also port an equal amount of lower.rs and codegen.rs into plans. The body of #7915 already refused this as more than a lane's glue budget (#7371), and the net <= 0 rule is stricter. So the choice between A and B goes to the owner first.

   5. Order once a design is chosen

   1. The repro and phi_f64_literals: the representation, a literal, a return, == and !=, and an untyped const of a call.
   2. source_text adds: module constants; var and assignment; @intCast from u8 to i128; ordered compares; checked +, - and *; and @divTrunc. This needs the 128-bit division routine in t27, with _expect_trap cases for a zero divisor and for minInt / -1.
   3. eval_arith adds: i128 parameters (two per fn); a struct field; *%; @rem; &, | and ^; << and >> with the checked u7 amount; and the checked cast to u32.

   Each slice ships its conformance spec under specs/tri/t27b/conformance/ and _expect_trap cases for each new trap, and sets its ledger row to pass.
3. gHashTag

   changed the title [-]t27b: run-time 128-bit integers (i128 returned and compared at run time, specs/port/bootstrap/src/phi_f64_literals.t27)[/-] [+]t27b: run-time 128-bit integers (type i128 at run time in phi_f64_literals, eval_arith and source_text)[/+] on Oct 10, 2026
4. gHashTag commented on Oct 10, 2026

   

   gHashTag

   on Oct 10, 2026

   OwnerAuthor

   More actions

   Owner decision (2026-10-10): option A, register pair.

   • An i128 is a first-class backend type in an even-odd register pair (AAPCS64: arguments in x0:x1, x2:x3, ...; the result in x0:x1). In memory it is 16 bytes with align 16.
   • Operations:
     • add and subtract with adds/adcs and subs/sbcs;
     • multiply with mul/umulh;
     • compare with cmp/ccmp;
     • divide, take the remainder and shift wide with routines written in t27 and generated.
   • The interpreter keeps exact i128 arithmetic, so the JIT/interpreter cross-check still covers it.
   • The instruction choices live in .t27 plans.
   • Each PR stays net <= 0 hand-written lines (policy: hand-written code in any language but t27 may only shrink (Closes #8227) #8236), paid for by porting existing codegen.rs/lower.rs into .t27. That moves epic: t27b in t27 -- port the backend and its tooling from Rust/Python into .t27 #6198 forward too.

   Stages: phi_f64_literals, then source_text, then eval_arith. A pure-port PR comes first if one is needed to make room.
5. gHashTag

   added 3 commits that reference this issue on Oct 10, 2026

   t27b: run-time i128, stage 1 -- a result in x0:x1, literals and compa…

   ...

   501944e

   t27b: run-time i128, stage 2 -- annotated locals, pair constants, @in…

   ...

   b7bdcc7

   t27b: run-time i128 stage 3 -- parameters in register pairs, i128 str…

   ...

   cd88ab1
6. gHashTag commented on Oct 11, 2026

   

   gHashTag

   on Oct 11, 2026

   OwnerAuthor

   More actions

   All three stages of the run-time i128 (option A, the register pair) are on master:

   • stage 1: t27b: run-time i128, stage 1 -- a result in x0:x1, literals and comparisons (Closes #8736) #8750, phi_f64_literals;
   • stage 2: t27b: run-time i128, stage 2 -- annotated locals, pair constants, @intCast, checked + - * and @divTrunc (Closes #8763) #8795, source_text;
   • stage 3: t27b: run-time i128 stage 3 -- parameters in register pairs, i128 struct fields, +% -% *%, @rem, & | ^, shifts and casts; eval_arith passes (Closes #8913) #8954 (see t27b: run-time i128, stage 3 -- parameters in register pairs, i128 struct fields, +% -% *%, @rem, & | ^, shifts and casts (eval_arith) #8913), eval_arith.

   specs/tri/t27b/eval_arith.t27 passes t27b test --check: 13/13, 180 runtime asserts. The t27b ledger's max_not_pass is 0. At the merge commit cd88ab1, the t27b-native ratchet reports no unexpected failure; it is red only for 2 unlisted specs from other PRs. Closing.
7. gHashTag

   closed this as completedon Oct 11, 2026