Commit 2f90fcd8393b493eafa3879b9ca6b2d644721f83 | zig

author	Daniel Kongsgaard <dakongsgaard@gmail.com> 2026-10-15 22:27:42+02:00
committer	Ali Chraghi <alichraghi@proton.me> 2026-10-25 09:50:54+01:00
log	2f90fcd8393b493eafa3879b9ca6b2d644721f83
tree	5f605e17c1cc40afb2719c5fe65b26dd2b696dc6
parent	064c78505596ae2bbfec63236df3b93a85e79aad

spirv: fix negative integers in switch

2 files changed, 89 insertions(+), 26 deletions(-)

src
- codegen
  - spirv
    CodeGen.zig
test
- cases
  - spirv_switch_negative_ints.zig

src/codegen/spirv/CodeGen.zig+41-26

 @@ -1137,6 +1137,42 @@ fn constBool(cg: *CodeGen, value: bool, repr: Repr) !Id {
     }
 }
+/// Returns the OpSwitch literal int corresponding to ref (case of the switch),
+/// where ty is the type we switch on and words is the width of the literal
+/// (words = 1 means up to 32 bits, and 2 means 64 bits).
+fn literalInt(cg: *CodeGen, ty: Type, words: u32, ref: Air.Inst.Ref) spec.LiteralContextDependentNumber {
+    const zcu = cg.zcu;
+    const target = cg.zcu.getTarget();
+    var int_ty: Type = ty;
+    var value: Value = .fromInterned(ref.toInterned().?);
+    const int_val: u64 = blk: switch (int_ty.zigTypeTag(zcu)) {
+        .bool, .int => if (int_ty.isSignedInt(zcu)) switch (target.os.tag) {
+            // Kernel only supports unsigned ints, so use the unsigned backing type.
+            .opencl, .amdhsa => switch (cg.backingIntBits(int_ty.intInfo(zcu).bits).@"0") {
+                inline 8, 16, 32, 64 => |bits| @as(@Int(.unsigned, bits), @truncate(@as(u64, @bitCast(value.toSignedInt(zcu))))),
+                else => unreachable,
+            },
+            else => @bitCast(value.toSignedInt(zcu)),
+        } else value.toUnsignedInt(zcu),
+        .@"enum" => {
+            // Handle proper backingInt conversion in the .int case.
+            int_ty = int_ty.backingIntType(zcu);
+            value = value.backingInt(zcu);
+            continue :blk .int;
+        },
+        .error_set => value.getErrorInt(zcu),
+        .pointer => value.toUnsignedInt(zcu),
+        else => unreachable,
+    };
+    return switch (words) {
+        1 => .{ .uint32 = @truncate(int_val) },
+        2 => .{ .uint64 = int_val },
+        else => unreachable,
+    };
+}
 /// Emits an integer constant.
 /// This function, unlike cg.constInt, takes care to bitcast
 /// the value to an unsigned int first for Kernels.
 @@ -7864,19 +7900,7 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
             const label = case_labels.at(case.idx);
             for (case.items) |item| {
-                const value: Value = .fromInterned(item.toInterned().?);
+                const int_lit = cg.literalInt(cond_ty, cond_words, item);
-                const int_val: u64 = switch (cond_ty.zigTypeTag(zcu)) {
-                    .bool, .int => if (cond_ty.isSignedInt(zcu)) @bitCast(value.toSignedInt(zcu)) else value.toUnsignedInt(zcu),
-                    .@"enum" => value.backingInt(zcu).toUnsignedInt(zcu),
-                    .error_set => value.getErrorInt(zcu),
-                    .pointer => value.toUnsignedInt(zcu),
-                    else => unreachable,
-                };
-                const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) {
-                    1 => .{ .uint32 = @intCast(int_val) },
-                    2 => .{ .uint64 = int_val },
-                    else => unreachable,
-                };
                 cg.body.writeOperand(spec.LiteralContextDependentNumber, int_lit);
                 cg.body.writeOperand(Id, label);
             }
 @@ -8098,25 +8122,16 @@ fn airLoopSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
     cg.body.writeOperand(Id, cond_indirect);
     cg.body.writeOperand(Id, switch_default);
+    // Emit the non-range cases into the OpSwitch.
+    // Cases with ranges are handled by the conditional chain below.
     {
         var it = switch_br.iterateCases();
         while (it.next()) |case| {
             if (case.ranges.len > 0) continue;
             const label = case_labels.at(case.idx);
             for (case.items) |item| {
-                const value: Value = .fromInterned(item.toInterned().?);
+                const int_lit = cg.literalInt(cond_ty, cond_words, item);
-                const int_val: u64 = switch (cond_ty.zigTypeTag(zcu)) {
-                    .bool, .int => if (cond_ty.isSignedInt(zcu)) @bitCast(value.toSignedInt(zcu)) else value.toUnsignedInt(zcu),
-                    .@"enum" => value.backingInt(zcu).toUnsignedInt(zcu),
-                    .error_set => value.getErrorInt(zcu),
-                    .pointer => value.toUnsignedInt(zcu),
-                    else => unreachable,
-                };
-                const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) {
-                    1 => .{ .uint32 = @intCast(int_val) },
-                    2 => .{ .uint64 = int_val },
-                    else => unreachable,
-                };
                 cg.body.writeOperand(spec.LiteralContextDependentNumber, int_lit);
                 cg.body.writeOperand(Id, label);
             }

test/cases/spirv_switch_negative_ints.zig created+48

...	@@ -0,0 +1,48 @@
1	// This tests that switches allow negative values when compiling for SPIR-V.
2	// We use i32 to test the one-word OpSwitch literal path, which used to fail.
3
4	const E = enum(i32) { neg = -1, pos = 1 };
5
6	export fn intSwitch() void {
7	var x: i32 = -1;
8	_ = &x;
9	var y: i32 = switch (x) {
10	-1 => 1,
11	else => 0,
12	};
13	_ = &y;
14	}
15
16	export fn intLoopSwitch() void {
17	var x: i32 = -1;
18	_ = &x;
19	blk: switch (x) {
20	-1 => continue :blk 0,
21	else => {},
22	}
23	}
24
25	export fn enumSwitch() void {
26	var e: E = .neg;
27	_ = &e;
28	var y: i32 = switch (e) {
29	.neg => 1,
30	.pos => 2,
31	};
32	_ = &y;
33	}
34
35	export fn enumLoopSwitch() void {
36	var e: E = .neg;
37	_ = &e;
38	blk: switch (e) {
39	.neg => continue :blk .pos,
40	.pos => {},
41	}
42	}
43
44	// compile
45	// output_mode=Obj
46	// backend=selfhosted
47	// target=spirv64-opencl,spirv64-vulkan
48	// emit_bin=true