diff --git a/test/behavior/abs.zig b/test/behavior/abs.zig
index 55c7ebf6a7b0704fa88c83e7afec14584eb00d55..5f840bb06537e481afc2d79563d98d5c386b0931 100644
--- a/test/behavior/abs.zig
+++ b/test/behavior/abs.zig
@@ -54,6 +54,7 @@ test "@abs signed C ABI integers" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 9d4886ee954d42be8f7684091577305b568056be..bca8094052fd8ef06db380be7dd95c98297cef2f 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -7,6 +7,8 @@ const assert = std.debug.assert;
 var foo: u8 align(4) = 100;
 
 test "global variable alignment" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     comptime assert(@typeInfo(@TypeOf(&foo)).pointer.attrs.@"align" == 4);
     comptime assert(@TypeOf(&foo) == *align(4) u8);
     {
@@ -16,6 +18,8 @@ test "global variable alignment" {
 }
 
 test "large abi alignment of global" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         var global: @This() = undefined;
         x: u64 align(64),
@@ -51,6 +55,8 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
 }
 
 test "implicitly-aligned pointer is coercible to equivalent explicitly-aligned pointer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const A = *u32;
     const B = *align(@alignOf(u32)) u32;
 
@@ -83,6 +89,8 @@ test "implicitly-aligned pointer is coercible to equivalent explicitly-aligned p
 }
 
 test "implicitly decreasing pointer alignment" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
     try expect(addUnaligned(&a, &b) == 7);
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 04e014b5157ef2e15bfc3ae10ff10c4d5e2f9c32..8f6a0898b362259f1e7733cc6359d33d5451d4ab 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -7,6 +7,7 @@ const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
 test "array to slice" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
     const a_slice: []align(1) const u32 = @as(*const [1]u32, &a)[0..];
@@ -21,6 +22,7 @@ test "array to slice" {
 test "arrays" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var array: [5]u32 = undefined;
 
@@ -259,6 +261,7 @@ fn doSomeMangling(array: *[4]u8) void {
 
 test "implicit cast zero sized array ptr to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     {
         var b = "".*;
@@ -969,6 +972,7 @@ test "runtime index of array of zero-bit values" {
 }
 
 test "@splat array" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1036,22 +1040,30 @@ test "@splat zero-length array" {
 }
 
 test "initialize slice with reference to empty array initializer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: []const u8 = &.{};
     comptime assert(a.len == 0);
 }
 
 test "initialize many-pointer with reference to empty array initializer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: [*]const u8 = &.{};
     _ = a; // nothing meaningful to test; points to zero bits
 }
 
 test "initialize sentinel-terminated slice with reference to empty array initializer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: [:0]const u8 = &.{};
     comptime assert(a.len == 0);
     comptime assert(a[0] == 0);
 }
 
 test "initialize sentinel-terminated many-pointer with reference to empty array initializer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: [*:0]const u8 = &.{};
     comptime assert(a[0] == 0);
 }
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 33df2caa3a65b32605426cf085353ad65a0801f5..455c2629a57c9aa14fa0f8089c9fc2ea01f70c15 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -305,6 +305,7 @@ test "compile time global reinterpret" {
 }
 
 test "cast undefined" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const array: [100]u8 = undefined;
@@ -640,6 +641,7 @@ fn emptyFn() void {}
 
 const addr1 = @as(*const u8, @ptrCast(&emptyFn));
 test "comptime cast fn to ptr" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const addr2 = @as(*const u8, @ptrCast(&emptyFn));
     comptime assert(addr1 == addr2);
 }
@@ -918,6 +920,7 @@ test "labeled block with runtime branch forwards its result location type to bre
 
 test "try in labeled block doesn't cast to wrong type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         a: u32,
@@ -1278,6 +1281,7 @@ test "@Int returned from block" {
 }
 
 test "comptime variable initialized with addresses of literals" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     comptime var st = .{
         .foo = &1,
         .bar = &2,
@@ -1327,6 +1331,8 @@ test "proper value is returned from labeled block" {
 }
 
 test "const inferred array of slices" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const T = struct { v: bool };
 
     const decls = [_][]const T{
@@ -1339,6 +1345,7 @@ test "const inferred array of slices" {
 
 test "var inferred array of slices" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const T = struct { v: bool };
 
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 28b45428d6b111a327561769781d5c045f49e17e..079ff9c799e2cfb5f65f53c229e02e973d10c2c1 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -162,6 +162,7 @@ test "@bitCast packed structs at runtime and comptime" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Full = packed struct {
         number: u16,
@@ -222,6 +223,7 @@ test "bitcast packed struct to integer and back" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const LevelUpMove = packed struct {
         move_id: u9,
@@ -555,6 +557,7 @@ test "@bitCast of extern struct containing pointer" {
 
 test "@bitCast of extern struct to float" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const S = extern struct {
@@ -575,6 +578,7 @@ test "@bitCast of extern struct to float" {
 
 test "@bitCast of float to extern struct" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const S = extern struct {
diff --git a/test/behavior/call.zig b/test/behavior/call.zig
index e1152ad910695f425c8de60894d7ecc92fe9d0f9..4846d475af9548e24a518ff035a6288aa64c7352 100644
--- a/test/behavior/call.zig
+++ b/test/behavior/call.zig
@@ -408,6 +408,7 @@ test "recursive inline call with comptime known argument" {
 
 test "inline while with @call" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn inc(a: *u32) void {
@@ -735,6 +736,7 @@ test "tail call function pointer" {
 test "tail call with potentially extended types" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
         if (builtin.cpu.arch.isMIPS() or builtin.cpu.arch.isPowerPC() or builtin.cpu.arch.isWasm()) {
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 2e5871d9dd2ae26b8f9b1739ce84a847b5a9f535..b5afb2673f4e9eea85c1e9ad90f4900e89913814 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -103,6 +103,7 @@ test "comptime_int @floatFromInt" {
 }
 
 test "@floatFromInt" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -131,6 +132,7 @@ fn testIntFromFloat(comptime F: type, f: F, comptime I: type, i: I) !void {
 }
 
 test "@intFromFloat > 128 bits" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
@@ -156,6 +158,7 @@ fn testFloatFromInt(comptime I: type, i: I, comptime F: type, expected: F) !void
 }
 
 test "@floatFromInt > 128 bits" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
@@ -216,6 +219,8 @@ test "@floatFromInt(f80)" {
 }
 
 test "type coercion from int to float" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const check = struct {
         // Check that an integer value can be coerced to a float type and
         // then converted back to the original value without rounding issues.
@@ -539,6 +544,8 @@ test "return u8 coercing into ?u32 return type" {
 }
 
 test "cast from ?[*]T to ??[*]T" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: ??[*]u8 = @as(?[*]u8, null);
     try expect(a != null and a.? == null);
 }
@@ -597,6 +604,7 @@ fn testPeerResolveArrayConstSlice(b: bool) !void {
 }
 
 test "implicitly cast from T to anyerror!?T" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -622,6 +630,7 @@ fn castToOptionalTypeError(z: i32) !void {
 }
 
 test "implicitly cast from [0]T to anyerror![]T" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testCastZeroArrayToErrSliceMut();
@@ -1420,6 +1429,7 @@ test "comptime float casts" {
 }
 
 test "pointer reinterpret const float to int" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     // The hex representation is 0x3fe3333333333303.
@@ -1613,6 +1623,7 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
 }
 
 test "implicit cast *[0]T to E![]const u8" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x = @as(anyerror![]const u8, &[0]u8{});
@@ -1807,6 +1818,7 @@ test "cast compatible optional types" {
 }
 
 test "coerce undefined single-item pointer of array to error union of slice" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const a = @as([*]u8, undefined)[0..0];
@@ -1817,6 +1829,7 @@ test "coerce undefined single-item pointer of array to error union of slice" {
 }
 
 test "pointer to empty struct literal to mutable slice" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x: []i32 = &.{};
@@ -1970,6 +1983,7 @@ test "peer type resolution forms error union" {
 }
 
 test "@constCast without a result location" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const x: i32 = 1234;
     const y = @constCast(&x);
     try expect(@TypeOf(y) == *i32);
@@ -1977,6 +1991,7 @@ test "@constCast without a result location" {
 }
 
 test "@constCast optional" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const x: u8 = 10;
     const m: ?*const u8 = &x;
     const p = @constCast(m);
@@ -2053,6 +2068,7 @@ test "peer type resolution: float and comptime-known fixed-width integer" {
 }
 
 test "peer type resolution: float and runtime-known fixed-width integer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2163,6 +2179,7 @@ test "peer type resolution: array and vector with same child type" {
 }
 
 test "peer type resolution: array with smaller child type and vector with larger child type" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -2343,6 +2360,7 @@ test "peer type resolution: array and tuple" {
 }
 
 test "peer type resolution: vector and tuple" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -2734,6 +2752,7 @@ test "cast builtins can wrap result in optional" {
 }
 
 test "cast builtins can wrap result in error union" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2809,6 +2828,7 @@ test "cast builtins can wrap result in error union and optional" {
 }
 
 test "@floatCast on vector" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -2897,6 +2917,7 @@ test "@intFromPtr on vector" {
 }
 
 test "@floatFromInt on vector" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -2916,6 +2937,7 @@ test "@floatFromInt on vector" {
 }
 
 test "@intFromFloat on vector" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -2935,6 +2957,7 @@ test "@intFromFloat on vector" {
 }
 
 test "@intFromBool on vector" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -3061,6 +3084,7 @@ test "peer type resolution: slice of sentinel-terminated array" {
 }
 
 test "@intFromFloat boundary cases" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -3092,6 +3116,7 @@ test "@intFromFloat boundary cases" {
 }
 
 test "@intFromFloat vector boundary cases" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig
index 841030a9e1a02fd23587b852bd73d2cdedfd5fdf..cd0f36c68a6fe6526b68624766c4178f7b37dee3 100644
--- a/test/behavior/cast_int.zig
+++ b/test/behavior/cast_int.zig
@@ -19,6 +19,7 @@ test "@intCast i32 to u7" {
 }
 
 test "coerce i8 to i32 and @intCast back" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -34,6 +35,7 @@ test "coerce i8 to i32 and @intCast back" {
 }
 
 test "coerce non byte-sized integers accross 32bits boundary" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     {
@@ -144,6 +146,7 @@ fn testIntCast(comptime S: type, a: S, comptime D: type, expected: D) !void {
 
 test "@intCast <= 64 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testIntCast(i32, minInt(i32), i64, minInt(i32));
     try testIntCast(i32, maxInt(i32), i64, maxInt(i32));
@@ -170,6 +173,7 @@ test "@intCast <= 64 bits" {
 test "@intCast > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testIntCast(u8, 123, u140, 123);
     try testIntCast(u64, 1 << 63, u140, 1 << 63);
diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig
index 769075aefff3c23691fa8474e16e62f1328d37a6..882f5e4f69ae9a1579d1dde4535a00e6a423cdcf 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -431,6 +431,8 @@ test "type pun @ptrFromInt" {
 }
 
 test "type pun null pointer-like optional" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const p: ?*u8 = null;
     // note that expectEqual hides the bug
     try testing.expect(@as(*const ?*i8, @ptrCast(&p)).* == null);
@@ -553,6 +555,8 @@ test "comptime store of packed struct with void field into array" {
 }
 
 test "comptime store of reinterpreted zero-bit type" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(comptime T: type) void {
             comptime var buf: T = undefined;
diff --git a/test/behavior/decl_literals.zig b/test/behavior/decl_literals.zig
index f96f46177179af58eee8e419648e5fdc7568a185..5d237778757f3c2f2a3faa160668f26debfee9f9 100644
--- a/test/behavior/decl_literals.zig
+++ b/test/behavior/decl_literals.zig
@@ -49,6 +49,8 @@ test "call decl literal with optional" {
 }
 
 test "call decl literal with pointer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         x: u32,
         fn init() *const @This() {
diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig
index c90df21fbca81fc441837057b74f26e227c17f9c..edac2dcbc7e66f95a2becaae04502c0ddd956f63 100644
--- a/test/behavior/defer.zig
+++ b/test/behavior/defer.zig
@@ -5,6 +5,8 @@ const expectEqual = std.testing.expectEqual;
 const expectError = std.testing.expectError;
 
 test "break and continue inside loop inside defer expression" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     testBreakContInDefer(10);
     comptime testBreakContInDefer(10);
 }
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index c9bdf8a5b09829f67165c09d71018b3602cafed9..fb5ce0623bf8e1be1a12889da094d7371e118536 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -26,6 +26,7 @@ const EnumFromIntNumber = enum { Zero, One, Two, Three, Four };
 
 test "int to enum" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testEnumFromIntEval(3);
 }
@@ -1059,6 +1060,7 @@ test "tag name with signed enum values" {
 test "tag name with large enum values" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Kdf = enum(u128) {
         aes_kdf = 0xea4f8ac1080d74bf60448a629af3d9c9,
@@ -1078,6 +1080,7 @@ test "tag name with large enum values" {
 test "@tagName with exotic integer enum types" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn testEnumSigned(comptime T: type) !void {
@@ -1280,6 +1283,7 @@ test "tag name functions are unique" {
 
 test "size of enum with only one tag which has explicit integer tag type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const E = enum(u8) { nope = 10 };
     const S0 = struct { e: E };
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index 7a53776b36adecbaede5972f89e7ea19efed0375..325fdfef139e76ab09050832bec0273276f78d60 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -145,6 +145,8 @@ test "implicit cast to optional to error union to return result loc" {
 }
 
 test "fn returning empty error set can be passed as fn returning any error" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     entry();
     comptime entry();
 }
@@ -526,6 +528,7 @@ test "function pointer with return type that is error union with payload which i
 }
 
 test "return result loc as peer result loc in inferred error set function" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -557,6 +560,7 @@ test "return result loc as peer result loc in inferred error set function" {
 }
 
 test "error payload type is correctly resolved" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1111,6 +1115,7 @@ test "'if' ignores error via local while 'else' ignores error directly" {
 }
 
 test "@errorCast into own inferred error set" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const static = struct {
         fn foo(b: bool) !void {
             if (b) {
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index f644c4261eb79460e5045ce81914a1dbaf3e227e..1f8e8b8b416132d612fa054962f75f57b934b035 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -883,6 +883,8 @@ test "debug variable type resolved through indirect zero-bit types" {
 }
 
 test "const local with comptime init through array init" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const E1 = enum {
         A,
         pub fn a() void {}
@@ -902,6 +904,7 @@ test "const local with comptime init through array init" {
 }
 
 test "closure capture type of runtime-known parameter" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -1158,6 +1161,8 @@ test "repeated value is correctly expanded" {
 }
 
 test "value in if block is comptime-known" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const first = blk: {
         const s = if (false) "a" else "b";
         break :blk "foo" ++ s;
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index 693656095332986f1062f0dd546acbe23c2bf8ff..8aadbc640eac5a64bb8f82749e48d7ab7a74ef9b 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -1546,6 +1546,7 @@ fn testNeg(comptime T: type) !void {
 
 test "negate f80" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var f: f80 = 0.0;
     const a: u80 = @bitCast(f);
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index 52648140162843ecbceddf78165e201129bcc28c..7b22be363ca285bdbdcefa203086538292c05654 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -292,6 +292,7 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void {
 
 test "call function with empty string" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     acceptsString("");
 }
@@ -405,6 +406,7 @@ test "function with inferred error set but returning no error" {
 
 test "import passed byref to function in return type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn get() @import("std").ArrayList(i32) {
@@ -440,6 +442,7 @@ test "implicit cast function to function ptr" {
 test "method call with optional and error union first param" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         x: i32 = 1234,
@@ -744,6 +747,8 @@ test "coerce generic function making generic parameter concrete" {
 }
 
 test "return undefined pointer from function, directly and by expired local" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         var global: i32 = 1;
 
diff --git a/test/behavior/for.zig b/test/behavior/for.zig
index 3923029312f5c41115dcd202246eb434897e33f9..8d39201eb9894dcdaecfe7ce5d70d3cb94ddd4f5 100644
--- a/test/behavior/for.zig
+++ b/test/behavior/for.zig
@@ -521,6 +521,8 @@ test "return from inline for" {
 }
 
 test "for loop 0 length range" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const map: []const u8 = &.{};
     for (map, 0..map.len) |i, j| {
         _ = i;
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index 6f6c6d4707e29a2408c171f269ccba2bf46ca62a..0de597670ddb1c4787ff01179d621eb05a0ef5d0 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -439,6 +439,8 @@ test "return type of generic function is function pointer" {
 }
 
 test "coerced function body has inequal value with its uncoerced body" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         const A = B(i32, c);
         fn c() !i32 {
@@ -521,6 +523,7 @@ test "call generic function with from function called by the generic function" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const GET = struct {
         key: []const u8,
diff --git a/test/behavior/globals.zig b/test/behavior/globals.zig
index 982ebc41f839ecbf7a28289be2fe38ab3c474acd..eab88cdfbdc4da73079c041fdc71cde54ba16821 100644
--- a/test/behavior/globals.zig
+++ b/test/behavior/globals.zig
@@ -42,6 +42,7 @@ test "slices pointing at the same address as global array." {
 }
 
 test "global loads can affect liveness" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
diff --git a/test/behavior/incomplete_struct_param_tld.zig b/test/behavior/incomplete_struct_param_tld.zig
index 4edf974daba261157c5ecc355ff7355ce2a5bfe3..0dc585820f7220d4458e55ca7b3caf39c1c12580 100644
--- a/test/behavior/incomplete_struct_param_tld.zig
+++ b/test/behavior/incomplete_struct_param_tld.zig
@@ -23,6 +23,7 @@ fn foo(a: A) i32 {
 
 test "incomplete struct param top level declaration" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const a = A{
         .b = B{
diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig
index a1efe7ab022e1de44dc0e0e0411d915348523999..02408f74b95eb214b03ee81f08e4b76c834808cb 100644
--- a/test/behavior/inline_switch.zig
+++ b/test/behavior/inline_switch.zig
@@ -45,6 +45,7 @@ const U = union(E) { a: void, b: u2, c: u3, d: u4 };
 test "inline switch unions" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var x: U = .a;
     _ = &x;
@@ -138,6 +139,8 @@ test "inline else int all values" {
 }
 
 test "inline switch capture is set when switch operand is comptime known" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const U2 = union(enum) {
         a: u32,
     };
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index b7b383d358ea084ae2d340b0db8a97c8b44ec5d7..313288533ea160782ffd02418204ed2b4f3b9d4b 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -1114,6 +1114,7 @@ test "@mulWithOverflow bitsize 128 bits" {
 test "@mulWithOverflow > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testMulWithOverflow(u140, 0, maxInt(u140), 0, 0);
     try testMulWithOverflow(u140, 1, maxInt(u140), maxInt(u140), 0);
@@ -1340,6 +1341,7 @@ test "@shlWithOverflow > 64 bits" {
 test "@shlWithOverflow > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testShlWithOverflow(u140, 1 << 100, 20, 1 << 120, 0);
     try testShlWithOverflow(u140, 1 << 100, 40, 0, 1);
@@ -1369,6 +1371,7 @@ fn testAnd(comptime T: type, a: T, b: T, expected: T) !void {
 test "and > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testAnd(u140, (1 << 139) | (1 << 70) | 0xaa, (1 << 139) | (1 << 69) | 0xcc, (1 << 139) | 0x88);
     try testAnd(u140, maxInt(u140), 1 << 100, 1 << 100);
@@ -1398,6 +1401,7 @@ fn testOr(comptime T: type, a: T, b: T, expected: T) !void {
 test "or > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testOr(u140, 0, 1 << 139, 1 << 139);
     try testOr(u140, (1 << 70) | 0xa, (1 << 69) | 0x5, (1 << 70) | (1 << 69) | 0xf);
@@ -1427,6 +1431,7 @@ fn testXor(comptime T: type, a: T, b: T, expected: T) !void {
 test "xor > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testXor(u140, 0, maxInt(u140), maxInt(u140));
     try testXor(u140, 1 << 139, 1 << 139, 0);
@@ -1456,6 +1461,7 @@ fn testNot(comptime T: type, a: T, expected: T) !void {
 test "not > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testNot(u140, 0, maxInt(u140));
     try testNot(u140, maxInt(u140), 0);
@@ -1485,6 +1491,7 @@ fn testShl(comptime T: type, a: T, b: std.math.Log2Int(T), expected: T) !void {
 test "shl > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testShl(u140, 1 << 5, 10, 1 << 15);
     try testShl(u140, 3, 138, (1 << 139) | (1 << 138));
@@ -1514,6 +1521,7 @@ fn testShr(comptime T: type, a: T, b: std.math.Log2Int(T), expected: T) !void {
 test "shr > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testShr(u140, 1 << 139, 39, 1 << 100);
     try testShr(u140, (1 << 70) | 8, 3, (1 << 67) | 1);
@@ -1543,6 +1551,7 @@ fn testClz(comptime T: type, a: T, expected: u16) !void {
 test "@clz > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testClz(u140, 0, 140);
     try testClz(u140, 1 << 139, 0);
@@ -1572,6 +1581,7 @@ fn testCtz(comptime T: type, a: T, expected: u16) !void {
 test "@ctz > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testCtz(u140, 0, 140);
     try testCtz(u140, 1 << 139, 139);
@@ -1601,6 +1611,7 @@ fn testPopCount(comptime T: type, a: T, expected: u16) !void {
 test "@popCount > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testPopCount(u140, 0, 0);
     try testPopCount(u140, maxInt(u140), 140);
@@ -1630,6 +1641,7 @@ fn testBitReverse(comptime T: type, a: T, expected: T) !void {
 test "@bitReverse > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testBitReverse(u140, 1 << 139, 1);
     try testBitReverse(u140, 1 << 70, 1 << 69);
@@ -1659,6 +1671,7 @@ fn testByteSwap(comptime T: type, a: T, expected: T) !void {
 test "@byteSwap > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testByteSwap(u144, 1 << 136, 1);
     try testByteSwap(u144, 1, 1 << 136);
@@ -1688,6 +1701,7 @@ fn testMax(comptime T: type, a: T, b: T, expected: T) !void {
 test "@max > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testMax(u140, 0, maxInt(u140), maxInt(u140));
     try testMax(u140, 1 << 139, 1 << 138, 1 << 139);
@@ -1717,6 +1731,7 @@ fn testMin(comptime T: type, a: T, b: T, expected: T) !void {
 test "@min > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testMin(u140, 0, maxInt(u140), 0);
     try testMin(u140, 1 << 139, 1 << 138, 1 << 138);
@@ -1746,6 +1761,7 @@ fn testAbs(comptime T: type, a: T, expected: anytype) !void {
 test "@abs > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testAbs(u140, 0, 0);
     try testAbs(u140, 1 << 139, 1 << 139);
@@ -1770,6 +1786,7 @@ fn testRem(comptime T: type, numerator: T, denominator: T, expected: T) !void {
 test "@rem > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testRem(u140, 0, maxInt(u140), 0);
     try testRem(u140, maxInt(u140), maxInt(u140), 0);
@@ -1797,6 +1814,7 @@ fn testMod(comptime T: type, numerator: T, denominator: T, expected: T) !void {
 test "@mod > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testMod(u140, 0, maxInt(u140), 0);
     try testMod(u140, maxInt(u140), maxInt(u140), 0);
@@ -1824,6 +1842,7 @@ fn testDivFloor(comptime T: type, numerator: T, denominator: T, expected: T) !vo
 test "@divFloor > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testDivFloor(u140, 0, maxInt(u140), 0);
     try testDivFloor(u140, maxInt(u140), maxInt(u140), 1);
@@ -1852,6 +1871,7 @@ fn testDivTrunc(comptime T: type, numerator: T, denominator: T, expected: T) !vo
 test "@divTrunc > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testDivTrunc(u140, 0, maxInt(u140), 0);
     try testDivTrunc(u140, maxInt(u140), maxInt(u140), 1);
@@ -2598,6 +2618,8 @@ test "comptime float vector multiplication of zero by nan is nan" {
 }
 
 test "i96 operations" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     // This is coverage for some stuff used by std.Io timestamps, to catch
     // issues earlier than bootstrapping.
     const Op_i96 = union(enum) {
diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig
index efe2a7f108b79fa7a589fa7e4e78671b6f091b0f..43d1a8043ed656baa3278b908a7e5d1479777b08 100644
--- a/test/behavior/maximum_minimum.zig
+++ b/test/behavior/maximum_minimum.zig
@@ -160,6 +160,7 @@ test "@min/@max more than two arguments" {
 }
 
 test "@min/@max more than two vector arguments" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -189,6 +190,7 @@ test "@min/@max notices bounds" {
 }
 
 test "@min/@max notices vector bounds" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -239,6 +241,7 @@ test "@min/@max notices bounds from types" {
 }
 
 test "@min/@max notices bounds from vector types" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -348,6 +351,7 @@ test "@min/@max with runtime signed and unsigned integers of same size" {
 }
 
 test "@min/@max with runtime vectors of signed and unsigned integers of same size" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
diff --git a/test/behavior/memset.zig b/test/behavior/memset.zig
index 067f89c628a9b331ae57372b9d48cf3e566a6fe3..ed9df298ac0b327506efdbe68871044974ba75dc 100644
--- a/test/behavior/memset.zig
+++ b/test/behavior/memset.zig
@@ -179,6 +179,8 @@ test "@memset with zero-length array" {
 }
 
 test "@memset a global array" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         var buf: [1]u32 = .{123};
     };
@@ -190,6 +192,8 @@ test "@memset a global array" {
 }
 
 test "@memset array of booleans" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         var x: bool = false;
         var y: [1]bool = undefined;
diff --git a/test/behavior/merge_error_sets.zig b/test/behavior/merge_error_sets.zig
index 492cb276999f508d6010eef7bb9fdee7c60a2717..05d3fe0d4af50ba5c3ba35d6fc3fcd4d81af7019 100644
--- a/test/behavior/merge_error_sets.zig
+++ b/test/behavior/merge_error_sets.zig
@@ -13,6 +13,7 @@ fn foo() C!void {
 
 test "merge error sets" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     if (foo()) {
         @panic("unexpected");
diff --git a/test/behavior/multiple_externs_with_conflicting_types.zig b/test/behavior/multiple_externs_with_conflicting_types.zig
index 7fa72506aaa450ba24a3b48ddc13cf35a74bfacf..e0965665b697b61d10017da94ace744150ba7c91 100644
--- a/test/behavior/multiple_externs_with_conflicting_types.zig
+++ b/test/behavior/multiple_externs_with_conflicting_types.zig
@@ -5,7 +5,9 @@ const A = extern struct {
 extern fn issue529(?*A) void;
 
 comptime {
-    _ = @import("conflicting_externs/b.zig");
+    if (builtin.zig_backend != .stage2_spirv) {
+        _ = @import("conflicting_externs/b.zig");
+    }
 }
 
 const builtin = @import("builtin");
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index ce104bf931b0e115812759e82cedefd51dad52ef..f7a77303c1adbfc8f9c0615cd10f0222cdc3163c 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -338,6 +338,7 @@ test "coerce an anon struct literal to optional struct" {
 test "0-bit child type coerced to optional return ptr result location" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -428,6 +429,7 @@ test "optional pointer to zero bit optional payload" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const B = struct {
         fn foo(_: *@This()) void {}
@@ -512,6 +514,8 @@ test "mutable optional of noreturn" {
 }
 
 test "orelse on C pointer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     // TODO https://github.com/ziglang/zig/issues/6597
     const foo: [*c]const u8 = "hey";
     const d = foo orelse @compileError("bad");
@@ -655,6 +659,8 @@ test "result location initialization of optional with OPV payload" {
 }
 
 test "global comptime only optional" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         const @"null": ?*type = null;
         const @"void": ?*const type = &void;
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 1eb69ace532ea46cae3e12ca840663e31bbf4ceb..1e62782b77ba11f3b17b9462d8e2e434a08eecd4 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -248,6 +248,7 @@ test "nested packed struct unaligned" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S1 = packed struct {
         a: u4,
@@ -816,6 +817,7 @@ test "packed struct passed to callconv(.c) function" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const Packed = packed struct(u64) {
@@ -893,6 +895,7 @@ test "store undefined to packed result location" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var x: u4 = 0;
     _ = &x;
diff --git a/test/behavior/packed-union.zig b/test/behavior/packed-union.zig
index b0850392aa51efd60cac8af9403656bc07bae9a3..20732eab98a312ba077ffde4494e8deec179225d 100644
--- a/test/behavior/packed-union.zig
+++ b/test/behavior/packed-union.zig
@@ -201,6 +201,8 @@ test "packed union with explicit backing integer" {
 }
 
 test "packed union equality" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const Foo = packed union {
         a: u4,
         b: i4,
diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig
index 357599bb449308f51f0779003b69146dce0e0a6e..97aafa6ea7bcc3a0cd54dbfb08fb9f72c0a274ac 100644
--- a/test/behavior/pointers.zig
+++ b/test/behavior/pointers.zig
@@ -136,6 +136,8 @@ test "implicit cast single item pointer to C pointer and back" {
 }
 
 test "initialize const optional C pointer to null" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a: ?[*c]i32 = null;
     try expect(a == null);
     comptime assert(a == null);
@@ -643,6 +645,8 @@ test "result type preserved through multiple references" {
 }
 
 test "result type found through optional pointer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const ptr1: ?*const u32 = &@intCast(123);
     const ptr2: ?[]const u8 = &.{ @intCast(123), @truncate(0xABCD) };
     try expect(ptr1.?.* == 123);
@@ -720,6 +724,8 @@ test "cast pointers with zero sized elements" {
 }
 
 test "comptime pointer equality through distinct fields with well-defined layout" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const A = extern struct {
         x: u32,
         z: u16,
@@ -744,6 +750,8 @@ test "comptime pointer equality through distinct fields with well-defined layout
 }
 
 test "comptime pointer equality through distinct elements with well-defined layout" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const buf: [2]u32 = .{ 123, 456 };
 
     const ptr: *const [2]u32 = &buf;
@@ -780,6 +788,8 @@ test "pointers to elements of many-ptr to zero-bit type" {
 }
 
 test "comptime C pointer to optional pointer" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const opt: ?*u8 = @ptrFromInt(0x1000);
     const outer_ptr: [*c]const ?*u8 = &opt;
     const inner_ptr = &outer_ptr.*.?;
diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig
index b8b8fa32243871ad7a6faf48ff8517506eff4b0a..31de4f08b474620680a5d43252530124e12b736d 100644
--- a/test/behavior/ptrcast.zig
+++ b/test/behavior/ptrcast.zig
@@ -193,6 +193,7 @@ const Bytes = struct {
 
 test "ptrcast of const integer has the correct object size" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const is_value = ~@as(isize, @intCast(std.math.minInt(isize)));
     const is_bytes = @as([*]const u8, @ptrCast(&is_value))[0..@sizeOf(isize)];
@@ -279,6 +280,8 @@ test "@ptrCast undefined value at comptime" {
 }
 
 test "comptime @ptrCast with packed struct leaves value unmodified" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = packed struct { three: u3 };
     const st: S = .{ .three = 6 };
     try expect(st.three == 6);
@@ -288,6 +291,8 @@ test "comptime @ptrCast with packed struct leaves value unmodified" {
 }
 
 test "@ptrCast restructures comptime-only array" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     {
         const a3a2: [3][2]comptime_int = .{
             .{ 1, 2 },
@@ -330,6 +335,8 @@ test "@ptrCast restructures comptime-only array" {
 }
 
 test "@ptrCast restructures sliced comptime-only array" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const a3a2: [4][2]comptime_int = .{
         .{ 1, 2 },
         .{ 3, 4 },
@@ -552,6 +559,8 @@ test "@ptrCast single-item pointer to slice of bytes" {
 }
 
 test "@ptrCast array pointer removing sentinel" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const in: *const [4:0]u8 = &.{ 1, 2, 3, 4 };
     const out: []const i8 = @ptrCast(in);
     comptime assert(out.len == 4);
@@ -562,6 +571,8 @@ test "@ptrCast array pointer removing sentinel" {
 }
 
 test "@ptrcast larger type to smaller one" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const T = packed struct { x: u17 };
     const a: u32 = 0;
     const b: *const T = @ptrCast(&a);
diff --git a/test/behavior/saturating_arithmetic.zig b/test/behavior/saturating_arithmetic.zig
index 0e2978bd9b13819905cc1d29c705f33247dc3c7b..c434f014f36e40f2cfea9fc0c2508320d09c74a4 100644
--- a/test/behavior/saturating_arithmetic.zig
+++ b/test/behavior/saturating_arithmetic.zig
@@ -362,6 +362,7 @@ test "saturating shl uses the LHS type" {
 test "sat add > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testSatAdd(u140, 0, 0, 0);
     try testSatAdd(u140, maxInt(u140), 1, maxInt(u140));
@@ -377,6 +378,7 @@ test "sat add > 128 bits" {
 test "sat sub > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testSatSub(u140, 0, 1, 0);
     try testSatSub(u140, maxInt(u140), maxInt(u140), 0);
@@ -392,6 +394,7 @@ test "sat sub > 128 bits" {
 test "sat mul > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testSatMul(u140, 0, maxInt(u140), 0);
     try testSatMul(u140, 1 << 70, 1 << 69, 1 << 139);
@@ -407,6 +410,7 @@ test "sat mul > 128 bits" {
 test "sat shl > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testSatShl(u140, 0, u8, 17, 0);
     try testSatShl(u140, 1 << 100, u8, 20, 1 << 120);
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index cb6c334cb7448bdd403c419baaad2eb9d92443d9..017d8b0ec3a4d6dad9199dc2f35609013a37ec1a 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -340,7 +340,7 @@ const exp = struct {
     }
 };
 comptime {
-    _ = exp;
+    if (builtin.zig_backend != .stage2_spirv) _ = exp;
 }
 
 test "Extern function calls in @TypeOf" {
diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig
index b0be08391b83db7a4260fee68c01c9dbb26b47de..509e0396a7fc7d60fb11c691f1f605824318b13f 100644
--- a/test/behavior/slice.zig
+++ b/test/behavior/slice.zig
@@ -67,6 +67,7 @@ test "comptime slice of undefined pointer of length 0" {
 
 test "implicitly cast array of size 0 to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var msg = [_]u8{};
     try assertLenIsZero(&msg);
@@ -172,6 +173,7 @@ test "pass a slice of types to a function" {
 
 test "generic malloc free" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const a = memAlloc(u8, 10) catch unreachable;
     memFree(u8, a);
@@ -210,6 +212,8 @@ test "comptime slice of pointer preserves comptime var" {
 }
 
 test "comptime pointer cast array and then slice" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
 
     const ptrA: [*]const u8 = @as([*]const u8, @ptrCast(&array));
@@ -276,6 +280,7 @@ test "slice string literal has correct type" {
 
 test "result location zero sized array inside struct field implicit cast to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const E = struct {
         entries: []u32,
@@ -382,6 +387,8 @@ test "obtaining a null terminated slice" {
 }
 
 test "empty array to slice" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             const empty: []align(16) u8 = &[_]u8{};
@@ -786,6 +793,8 @@ test "slice bounds in comptime concatenation" {
 }
 
 test "slice sentinel access at comptime" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     {
         const str0 = &[_:0]u8{ '1', '2', '3' };
         const slice0: [:0]const u8 = str0;
@@ -852,6 +861,8 @@ test "slice len modification at comptime" {
 }
 
 test "slice field ptr const" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const const_slice: []const u8 = "string";
 
     const const_ptr_const_slice = &const_slice;
@@ -865,6 +876,7 @@ test "slice field ptr const" {
 
 test "slice field ptr var" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var var_slice: []const u8 = "string";
 
@@ -1050,6 +1062,8 @@ test "peer slices keep abi alignment with empty struct" {
 }
 
 test "sentinel expression in slice operation has result type" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const sentinel = std.math.maxInt(u16);
 
     const arr: [3]u16 = .{ 1, 2, sentinel };
diff --git a/test/behavior/string_literals.zig b/test/behavior/string_literals.zig
index c1e89bacb2b296b7d5dc193e0f90650bab257745..f983a59bfacdad275a4ead149a3efc553b4bcdc1 100644
--- a/test/behavior/string_literals.zig
+++ b/test/behavior/string_literals.zig
@@ -84,6 +84,8 @@ test "string literal pointer sentinel" {
 }
 
 test "sentinel slice of string literal" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const string = "Hello!\x00World!";
     try std.testing.expect(@TypeOf(string) == *const [13:0]u8);
 
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 4a4906699578f5f36e7bd9e0b31a563f7718c384..ad0c11d7051088e50af5eaf144fa7c62ad2168d3 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -342,6 +342,7 @@ test "self-referencing struct via array member" {
 }
 
 test "empty struct method call" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const es = EmptyStruct{};
     try expect(es.method() == 1234);
 }
@@ -991,6 +992,7 @@ test "struct with 0-length union array field" {
 }
 
 test "packed struct with undefined initializers" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1645,6 +1647,8 @@ test "struct init with no result pointer sets field result types" {
 }
 
 test "runtime side-effects in comptime-known struct init" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     var side_effects: u4 = 0;
     const S = struct { a: u4, b: u4, c: u4, d: u4 };
     const init = S{
@@ -1772,6 +1776,7 @@ test "circular dependency through pointer field of a struct" {
 }
 
 test "field calls do not force struct field init resolution" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const S = struct {
         x: u32 = blk: {
             _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
@@ -1921,6 +1926,7 @@ test "runtime value in nested initializer passed as pointer to function" {
 }
 
 test "struct field default value is a call" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2182,6 +2188,7 @@ test "pass a pointer to a comptime-only struct field to a function" {
 }
 
 test "overaligned extern struct fields" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const A = struct {
         a: *anyopaque,
         b: u64,
@@ -2231,6 +2238,7 @@ test "overaligned extern struct fields" {
 }
 
 test "runtime-known slice of comptime-only struct" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const Mixed = struct { index: u32, T: type };
 
     const static = struct {
@@ -2252,6 +2260,7 @@ test "runtime-known slice of comptime-only struct" {
 }
 
 test "struct contains aligned pointer to itself through type decl" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const Slab = struct {
         const Ptr = *align(64) const @This();
         next: Ptr,
@@ -2269,6 +2278,7 @@ test "struct contains aligned pointer to itself through type decl" {
 }
 
 test "struct contains underaligned field with overaligned pointer to itself" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     const S = struct {
         ptr: *align(8) @This() align(1),
@@ -2281,6 +2291,7 @@ test "struct contains underaligned field with overaligned pointer to itself" {
 }
 
 test "struct contains pointer to function accepting that struct" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const S = struct {
         const FnPtr = ?*const fn (@This()) void;
         fn_ptr: FnPtr,
@@ -2303,6 +2314,7 @@ test "struct queries typeinfo of struct containing pointer back to first struct"
 }
 
 test "pointer to runtime field of struct containing struct containing comptime-only optional" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     const Foo = struct {
         padding: struct { a: u8, b: ?comptime_int },
         number: u8,
diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig
index 43286ea0fcefdd3ca1371243ea81a5f483e96349..9683639c50edca4a3a05c98e13b39ed02bd617f7 100644
--- a/test/behavior/switch.zig
+++ b/test/behavior/switch.zig
@@ -276,6 +276,7 @@ test "switch prong with variable" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
     try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
@@ -299,6 +300,7 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void {
 test "switch on enum using pointer capture" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testSwitchEnumPtrCapture();
     try comptime testSwitchEnumPtrCapture();
@@ -359,6 +361,7 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 {
 test "switch on union with some prongs capturing" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const X = union(enum) {
         a,
@@ -395,6 +398,7 @@ test "switch on const enum with var" {
 
 test "anon enum literal used in switch on union enum" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Foo = union(enum) {
         a: i32,
@@ -576,6 +580,7 @@ test "switch with null and T peer types and inferred result location type" {
 test "switch prongs with cases with identical payload types" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Union = union(enum) {
         A: usize,
@@ -617,6 +622,8 @@ test "switch prongs with cases with identical payload types" {
 }
 
 test "switch prong pointer capture alignment" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const U = union(enum) {
         a: u8 align(8),
         b: u8 align(4),
@@ -840,6 +847,7 @@ test "switch capture peer type resolution" {
 
 test "switch capture peer type resolution for in-memory coercible payloads" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const T1 = c_int;
     const t1_info = @typeInfo(T1).int;
@@ -863,6 +871,7 @@ test "switch capture peer type resolution for in-memory coercible payloads" {
 
 test "switch pointer capture peer type resolution" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const T1 = c_int;
     const t1_info = @typeInfo(T1).int;
@@ -968,6 +977,8 @@ test "switch prong captures range" {
 }
 
 test "prong with inline call to unreachable" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const U = union(enum) {
         void: void,
         bool: bool,
@@ -1174,6 +1185,8 @@ test "switch with uninstantiable union fields" {
 }
 
 test "switch with tag capture" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const U = union(enum) {
         a,
         b: i32,
@@ -1307,6 +1320,8 @@ test "single-item prong in switch on enum has comptime-known capture" {
 }
 
 test "single range switch prong capture" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(x: u8) !void {
             switch (x) {
@@ -1328,6 +1343,8 @@ test "single range switch prong capture" {
 }
 
 test "switch on packed struct" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const P = packed struct {
         a: u1,
         b: u1,
@@ -1358,6 +1375,8 @@ test "switch on packed struct" {
 }
 
 test "switch on packed union" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const P = packed union(u2) {
         a: u2,
         b: i2,
@@ -1405,6 +1424,8 @@ test "switch on packed union" {
 }
 
 test "switch on nested packed containers" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const P = packed struct {
         iu: u17,
         is: i31,
@@ -1458,6 +1479,8 @@ test "switch on nested packed containers" {
 }
 
 test "switch on large types" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(a: u128, b: i500) !void {
             switch (a) {
diff --git a/test/behavior/switch_loop.zig b/test/behavior/switch_loop.zig
index 19293a472bc2a6dc12b319412fe54870e55dec0c..fdc8864a582c0f5fe81cff4652cdc1764edfc3ff 100644
--- a/test/behavior/switch_loop.zig
+++ b/test/behavior/switch_loop.zig
@@ -397,6 +397,8 @@ test "switch loop on type with opv" {
 }
 
 test "switch loop with tag capture" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const U = union(enum) {
         a,
         b: i32,
@@ -467,6 +469,8 @@ test "switch loop with tag capture" {
 }
 
 test "switch loop for error handling" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const Error = error{ MyError, MyOtherError };
     const S = struct {
         fn doTheTest() !void {
@@ -511,6 +515,8 @@ test "switch loop for error handling" {
 }
 
 test "switch loop with packed structs" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const P = packed struct {
         a: u7,
         b: u20,
@@ -528,6 +534,8 @@ test "switch loop with packed structs" {
 }
 
 test "switch loop with packed unions" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const P = packed union {
         a: u7,
         b: i7,
@@ -566,6 +574,8 @@ test "switch loop with packed unions with OPV" {
 }
 
 test "switch loop on large types" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(a: u128, b: i500) !void {
             label: switch (a) {
diff --git a/test/behavior/switch_prong_err_enum.zig b/test/behavior/switch_prong_err_enum.zig
index a2eed86c0f6e30db3f16182e31bdf2529cce3078..a316cacc61cd24cc3eac913fed77d33fe1430f7e 100644
--- a/test/behavior/switch_prong_err_enum.zig
+++ b/test/behavior/switch_prong_err_enum.zig
@@ -24,6 +24,7 @@ test "switch prong returns error enum" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     switch (doThing(17) catch unreachable) {
         FormValue.Address => |payload| {
diff --git a/test/behavior/switch_prong_implicit_cast.zig b/test/behavior/switch_prong_implicit_cast.zig
index 0de343898df9a5b0a47b381bd25d45c0d265cb91..aab365f027ea17273c77e05bf96da48cfbedd612 100644
--- a/test/behavior/switch_prong_implicit_cast.zig
+++ b/test/behavior/switch_prong_implicit_cast.zig
@@ -18,6 +18,7 @@ test "switch prong implicit cast" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const result = switch (foo(2) catch unreachable) {
         FormValue.One => false,
diff --git a/test/behavior/truncate.zig b/test/behavior/truncate.zig
index 01d9490d0c033678f5876bb4b633004c10e53d91..07d19f29c0da73a045ae58d35836502cbebe5cdc 100644
--- a/test/behavior/truncate.zig
+++ b/test/behavior/truncate.zig
@@ -50,6 +50,7 @@ fn testTruncate(comptime S: type, a: S, comptime D: type, expected: D) !void {
 test "@truncate > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     try testTruncate(u140, 0, u128, 0);
     try testTruncate(u140, maxInt(u140), u128, maxInt(u128));
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index d8510b664b690980c1233eb83bd2351c74209e35..0876886b75f04feaba0462975ef8baedd8ecfa38 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -559,6 +559,8 @@ test "OPV tuple fields aren't comptime" {
 }
 
 test "array of tuples that end with a zero-bit field followed by padding" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         var foo: [2]struct { u32, u8, void } = .{ .{ 1, 2, {} }, .{ 3, 4, {} } };
     };
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index 79f6769940713716288333d26fb290db3f3240a6..c2d1fc2f4fbf36674bdf3eab2b506fd4acd1fdb4 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -277,6 +277,7 @@ test "Type.Union from empty Type.Enum" {
 
 test "Type.Fn" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const some_opaque = opaque {};
     const some_ptr = *some_opaque;
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index be67200aca1d873efcb37f96112ad80d90008598..d04e1b947059a2113ab28c666596727b58d94715 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -310,6 +310,8 @@ const TestStruct = struct {
 };
 
 test "type info: packed struct info" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     try testPackedStruct();
     try comptime testPackedStruct();
 }
@@ -594,6 +596,8 @@ test "value from struct @typeInfo default_value_ptr can be loaded at comptime" {
 }
 
 test "type info of tuple of string literal default value" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const struct_info = @typeInfo(@TypeOf(.{"hi"})).@"struct";
     const struct_field_attrs = struct_info.field_attrs[0];
     const struct_field_type = struct_info.field_types[0];
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index e9dbc49aaa9876b3c40ff9816749150a26aa6f1a..163eb8f3f6a5989e9fb1c3cc9baba1c877222c90 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -31,6 +31,7 @@ test "init union with runtime value - floats" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var foo: FooWithFloats = undefined;
 
@@ -407,6 +408,7 @@ test "tagged union with no payloads" {
 
 test "union with only 1 field casted to its enum type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Literal = union(enum) {
         Number: f64,
@@ -443,6 +445,7 @@ var glbl: Foo1 = undefined;
 test "global union with single field is correctly initialized" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     glbl = Foo1{
         .f = @typeInfo(Foo1).@"union".field_types[0]{ .x = 123 },
@@ -485,6 +488,7 @@ test "update the tag value for zero-sized unions" {
 test "union initializer generates padding only if needed" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const U = union(enum) {
         A: u24,
@@ -550,6 +554,7 @@ const Baz = enum { A, B, C, D };
 
 test "tagged union type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const foo1 = TaggedFoo{ .One = 13 };
     const foo2 = TaggedFoo{
@@ -654,6 +659,7 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
 test "switch on union with only 1 field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     var r: PartialInst = undefined;
     r = PartialInst.Compiled;
@@ -682,6 +688,7 @@ const PartialInstWithPayload = union(enum) {
 
 test "union with only 1 field casted to its enum type which has enum value specified" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Literal = union(enum) {
         number: f64,
@@ -706,6 +713,7 @@ test "union with only 1 field casted to its enum type which has enum value speci
 test "@intFromEnum works on unions" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Bar = union(enum) {
         A: bool,
@@ -765,6 +773,7 @@ test "return union init with void payload" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn entry() !void {
@@ -789,6 +798,7 @@ test "@unionInit stored to a const" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const U = union(enum) {
@@ -818,6 +828,7 @@ test "@unionInit stored to a const" {
 test "@unionInit can modify a union type" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const UnionInitEnum = union(enum) {
         Boolean: bool,
@@ -840,6 +851,7 @@ test "@unionInit can modify a union type" {
 test "@unionInit can modify a pointer value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const UnionInitEnum = union(enum) {
         Boolean: bool,
@@ -914,6 +926,7 @@ test "function call result coerces from tagged union to the tag" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const Arch = union(enum) {
@@ -948,6 +961,7 @@ test "function call result coerces from tagged union to the tag" {
 test "switching on non exhaustive union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const E = enum(u8) {
@@ -1004,6 +1018,7 @@ test "containers with single-field enums" {
 test "@unionInit on union with u8 tag but no fields" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         const Type = enum(u8) { no_op = 105 };
@@ -1108,6 +1123,8 @@ test "union with a large struct field" {
 }
 
 test "comptime equality of extern unions with same tag" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         const U = extern union {
             a: i32,
@@ -1126,6 +1143,7 @@ test "union tag is set when initiated as a temporary value at runtime" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const U = union(enum) {
         a,
@@ -1165,6 +1183,7 @@ test "return an extern union from C calling convention" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const namespace = struct {
         const S = extern struct {
@@ -1246,6 +1265,7 @@ test "@unionInit uses tag value instead of field index" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const E = enum(u8) {
         b = 255,
@@ -1303,6 +1323,7 @@ test "packed union in packed struct" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = packed struct {
         nested: packed union {
@@ -1374,6 +1395,7 @@ test "no dependency loop when function pointer in union returns the union" {
 test "union reassignment can use previous value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const U = union {
         a: u32,
@@ -1386,6 +1408,7 @@ test "union reassignment can use previous value" {
 
 test "reinterpreting enum value inside packed union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const U = packed union {
         tag: enum(u8) { a, b },
@@ -1864,6 +1887,7 @@ test "extern union initialized via reintepreted struct field initializer" {
 
 test "packed union initialized via reintepreted struct field initializer" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
 
@@ -1909,6 +1933,7 @@ test "store of comptime reinterpreted memory to extern union" {
 
 test "store of comptime reinterpreted memory to packed union" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
 
@@ -2256,6 +2281,8 @@ test "assign global tagged union" {
 }
 
 test "set mutable union by switching on same union" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const U = union(enum) {
         foo,
         bar: usize,
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index a01fc0a218dac64e24d7c43637d9dfcae43fe8f3..0a07192c19c99aeb8a54be4dc69df44d1edcbb8e 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -8,6 +8,7 @@ const expectEqual = std.testing.expectEqual;
 
 test "implicit cast vector to array - bool" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -30,6 +31,7 @@ test "implicit cast vector to array - bool" {
 }
 
 test "implicit cast array to vector - bool" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = struct {
@@ -311,6 +313,7 @@ test "peer type resolution with coercible element types" {
 }
 
 test "tuple to vector" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -413,6 +416,7 @@ test "vector @splat" {
 }
 
 test "load vector elements via comptime index" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -433,6 +437,7 @@ test "load vector elements via comptime index" {
 }
 
 test "store vector elements via comptime index" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1223,6 +1228,7 @@ test "@subWithOverflow" {
 }
 
 test "@mulWithOverflow" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1243,6 +1249,7 @@ test "@mulWithOverflow" {
 }
 
 test "@shlWithOverflow" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1371,6 +1378,7 @@ test "zero multiplicand" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const zeros = @Vector(2, u32){ 0.0, 0.0 };
     var ones = @Vector(2, u32){ 1.0, 1.0 };
@@ -1413,6 +1421,7 @@ test "modRem with zero divisor" {
 }
 
 test "array operands to shuffle are coerced to vectors" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1438,6 +1447,7 @@ test "load packed vector element" {
 }
 
 test "store packed vector element" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1500,6 +1510,7 @@ test "store vector with memset" {
 }
 
 test "addition of vectors represented as strings" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -1510,6 +1521,7 @@ test "addition of vectors represented as strings" {
 }
 
 test "compare vectors with different element types" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
diff --git a/test/behavior/while.zig b/test/behavior/while.zig
index 2854f8a8d492615f3c3a244b86e6f796a012b42f..e4a421900a3d01297053bbf8a16758dc27d7d304 100644
--- a/test/behavior/while.zig
+++ b/test/behavior/while.zig
@@ -401,6 +401,8 @@ test "breaking from a loop in an if statement" {
 }
 
 test "labeled break from else" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(x: u32) !void {
             const arr: []const u32 = &.{ 1, 3, 10 };