lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P5.6 prereq: port bitwise/shift ops into the comptime VM

Browse Source 
`comptime_vm` exec now handles `bit_and`/`bit_or`/`bit_xor`/`bit_not`/`shl`/`shr`
(a new `bitwise` helper next to `arith`), mirroring the legacy interp's i64 model
exactly: the shift amount clamps to `@min(rhs, 63)` and `shr` is an arithmetic
right shift (sign-extending).

These were unported and bailed; the `shr` gap surfaced via the iOS-device bundler
once P5.5 let it run further (1616). With the port, 1616's strict VM run reaches
the real bundler logic and stops only at the genuinely-unavailable iOS runtime on
macOS (`_UIApplicationMain` / no linked binary under `sx run`), as expected.

New corpus test `examples/0639-comptime-bitwise-shift.sx` folds AND/OR/XOR/NOT/
shl/shr/arith-shr as `::` consts — identical on both evaluators. 704/0 both gates.
This commit is contained in:
agra
2026-06-19 14:20:37 +03:00
parent ba28488d99
commit 994d6498fc
6 changed files with 55 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/ir/comptime_vm.zig
View File

@@ -625,6 +625,11 @@ pub const Vm = struct {
.add, .sub, .mul, .div, .mod => |b| return .{
.value = try arith(std.meta.activeTag(ins.op), ins.ty, frame.get(b.lhs.index()), frame.get(b.rhs.index())),
},
// ── Bitwise + shift (i64, mirroring the legacy interp) ─
.bit_and, .bit_or, .bit_xor, .shl, .shr => |b| return .{
.value = bitwise(std.meta.activeTag(ins.op), frame.get(b.lhs.index()), frame.get(b.rhs.index())),
},
.bit_not => |u| return .{ .value = @bitCast(~@as(i64, @bitCast(frame.get(u.operand.index())))) },
.neg => |u| {
const x = frame.get(u.operand.index());
if (isFloat(ins.ty)) return .{ .value = @bitCast(-@as(f64, @bitCast(x))) };
@@ -1129,6 +1134,24 @@ pub const Vm = struct {
return @bitCast(res);
}
/// 64-bit bitwise AND/OR/XOR and shifts — mirrors the legacy interp's i64
/// model exactly: shifts clamp the amount to `@min(rhs, 63)` and `shr` is an
/// ARITHMETIC right shift (signed `>>`, sign-extending), matching the legacy
/// `.int` representation.
fn bitwise(tag: OpTag, l: Reg, r: Reg) Reg {
const li: i64 = @bitCast(l);
const ri: i64 = @bitCast(r);
const res: i64 = switch (tag) {
.bit_and => li & ri,
.bit_or => li | ri,
.bit_xor => li ^ ri,
.shl => li << @as(u6, @intCast(@min(ri, 63))),
.shr => li >> @as(u6, @intCast(@min(ri, 63))),
else => unreachable,
};
return @bitCast(res);
}
/// Comparison keyed on the operand type: f64 for floats, == / != only for
/// bool, else signed i64 — mirrors the legacy `evalCmp`.
fn cmp(self: *Vm, tag: OpTag, lty: TypeId, l: Reg, r: Reg) Error!bool {