setup spirv backend in behavior tests

87 files changed, 156 insertions, 0 deletions

diff --git a/test/behavior/bugs/10138.zig b/test/behavior/bugs/10138.zig
index 88dc5acde7..1ea2954777 100644
--- a/test/behavior/bugs/10138.zig
+++ b/test/behavior/bugs/10138.zig
@@ -5,6 +5,7 @@ test "registers get overwritten when ignoring return" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const fd = open();
     _ = write(fd, "a", 1);
diff --git a/test/behavior/bugs/10147.zig b/test/behavior/bugs/10147.zig
index 77c513caa6..a1fe9bff68 100644
--- a/test/behavior/bugs/10147.zig
+++ b/test/behavior/bugs/10147.zig
@@ -7,6 +7,7 @@ test "test calling @clz on both vector and scalar inputs" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     var x: u32 = 0x1;
     var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
diff --git a/test/behavior/bugs/10684.zig b/test/behavior/bugs/10684.zig
index ef104a3f0c..e7033eec8f 100644
--- a/test/behavior/bugs/10684.zig
+++ b/test/behavior/bugs/10684.zig
@@ -7,6 +7,7 @@ test "slicing slices" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const foo = "1234";
     const bar = foo[0..4];
diff --git a/test/behavior/bugs/1076.zig b/test/behavior/bugs/1076.zig
index ba2b61e3db..3eb07695cb 100644
--- a/test/behavior/bugs/1076.zig
+++ b/test/behavior/bugs/1076.zig
@@ -6,6 +6,7 @@ const expect = std.testing.expect;
 test "comptime code should not modify constant data" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try testCastPtrOfArrayToSliceAndPtr();
     comptime try testCastPtrOfArrayToSliceAndPtr();
diff --git a/test/behavior/bugs/10970.zig b/test/behavior/bugs/10970.zig
index 539dfaff71..008242196c 100644
--- a/test/behavior/bugs/10970.zig
+++ b/test/behavior/bugs/10970.zig
@@ -7,6 +7,7 @@ test "breaking from a loop in an if statement" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var cond = true;
     const opt = while (cond) {
diff --git a/test/behavior/bugs/11046.zig b/test/behavior/bugs/11046.zig
index a13e02e45c..6bf6041a65 100644
--- a/test/behavior/bugs/11046.zig
+++ b/test/behavior/bugs/11046.zig
@@ -13,6 +13,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     bar() catch |err| switch (err) {
         error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo}
diff --git a/test/behavior/bugs/11100.zig b/test/behavior/bugs/11100.zig
index cacc770ef0..1a55b94510 100644
--- a/test/behavior/bugs/11100.zig
+++ b/test/behavior/bugs/11100.zig
@@ -1,4 +1,6 @@
 const std = @import("std");
+const builtin = @import("builtin");
+
 pub fn do() bool {
     inline for (.{"a"}) |_| {
         if (true) return false;
@@ -7,5 +9,7 @@ pub fn do() bool {
 }
 
 test "bug" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try std.testing.expect(!do());
 }
diff --git a/test/behavior/bugs/11139.zig b/test/behavior/bugs/11139.zig
index 572b2aed72..e04960c24b 100644
--- a/test/behavior/bugs/11139.zig
+++ b/test/behavior/bugs/11139.zig
@@ -6,6 +6,7 @@ test "store array of array of structs at comptime" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     try expect(storeArrayOfArrayOfStructs() == 15);
     comptime try expect(storeArrayOfArrayOfStructs() == 15);
diff --git a/test/behavior/bugs/11165.zig b/test/behavior/bugs/11165.zig
index e23861ddc1..129b605100 100644
--- a/test/behavior/bugs/11165.zig
+++ b/test/behavior/bugs/11165.zig
@@ -2,6 +2,7 @@ const builtin = @import("builtin");
 
 test "bytes" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         a: u32,
@@ -23,6 +24,7 @@ test "bytes" {
 
 test "aggregate" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         a: u32,
diff --git a/test/behavior/bugs/11179.zig b/test/behavior/bugs/11179.zig
index 84fa6183f3..ca3a27c5d1 100644
--- a/test/behavior/bugs/11179.zig
+++ b/test/behavior/bugs/11179.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const Type = std.builtin.Type;
 
 test "Tuple" {
diff --git a/test/behavior/bugs/11213.zig b/test/behavior/bugs/11213.zig
index 7f13b6efd8..875c12697b 100644
--- a/test/behavior/bugs/11213.zig
+++ b/test/behavior/bugs/11213.zig
@@ -3,6 +3,8 @@ const builtin = @import("builtin");
 const testing = std.testing;
 
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const g: error{Test}!void = error.Test;
 
     var v: u32 = 0;
diff --git a/test/behavior/bugs/11787.zig b/test/behavior/bugs/11787.zig
index 6d17730a47..47af7a350a 100644
--- a/test/behavior/bugs/11787.zig
+++ b/test/behavior/bugs/11787.zig
@@ -7,6 +7,7 @@ test "slicing zero length array field of struct" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         a: [0]usize,
diff --git a/test/behavior/bugs/11816.zig b/test/behavior/bugs/11816.zig
index cb548ef2e9..6061d668f3 100644
--- a/test/behavior/bugs/11816.zig
+++ b/test/behavior/bugs/11816.zig
@@ -4,6 +4,7 @@ const builtin = @import("builtin");
 test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var x: u32 = 3;
     const val: usize = while (true) switch (x) {
diff --git a/test/behavior/bugs/11995.zig b/test/behavior/bugs/11995.zig
index 255a366fb2..0ee8e56214 100644
--- a/test/behavior/bugs/11995.zig
+++ b/test/behavior/bugs/11995.zig
@@ -22,6 +22,8 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var string: [5]u8 = "hello".*;
     const arg_data = wuffs_base__slice_u8{ .ptr = @ptrCast([*c]u8, &string), .len = string.len };
     var arg_meta = wuffs_base__io_buffer_meta{ .wi = 1, .ri = 2, .pos = 3, .closed = true };
diff --git a/test/behavior/bugs/12000.zig b/test/behavior/bugs/12000.zig
index a823ce6a0a..808ca061b8 100644
--- a/test/behavior/bugs/12000.zig
+++ b/test/behavior/bugs/12000.zig
@@ -10,6 +10,8 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var t: T = .{ .next = null };
     try std.testing.expect(t.next == null);
 }
diff --git a/test/behavior/bugs/12025.zig b/test/behavior/bugs/12025.zig
index 7b1804cf20..aa293aa6b5 100644
--- a/test/behavior/bugs/12025.zig
+++ b/test/behavior/bugs/12025.zig
@@ -1,4 +1,8 @@
+const builtin = @import("builtin");
+
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     comptime var st = .{
         .foo = &1,
         .bar = &2,
diff --git a/test/behavior/bugs/12033.zig b/test/behavior/bugs/12033.zig
index 563ed8e79b..dfe583f156 100644
--- a/test/behavior/bugs/12033.zig
+++ b/test/behavior/bugs/12033.zig
@@ -1,6 +1,9 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const string = "Hello!\x00World!";
     try std.testing.expect(@TypeOf(string) == *const [13:0]u8);
 
diff --git a/test/behavior/bugs/12043.zig b/test/behavior/bugs/12043.zig
index 2b0d4d062d..835b2f6b4e 100644
--- a/test/behavior/bugs/12043.zig
+++ b/test/behavior/bugs/12043.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 var ok = false;
@@ -6,6 +7,8 @@ fn foo(x: anytype) void {
     ok = x;
 }
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const x = &foo;
     x(true);
     try expect(ok);
diff --git a/test/behavior/bugs/12051.zig b/test/behavior/bugs/12051.zig
index 2b2765358b..5509ab97cd 100644
--- a/test/behavior/bugs/12051.zig
+++ b/test/behavior/bugs/12051.zig
@@ -7,6 +7,8 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
+
     const x = X{};
     try std.testing.expectEqual(@as(u16, 0), x.y.a);
     try std.testing.expectEqual(false, x.y.b);
diff --git a/test/behavior/bugs/12092.zig b/test/behavior/bugs/12092.zig
index 216138d748..434da854f8 100644
--- a/test/behavior/bugs/12092.zig
+++ b/test/behavior/bugs/12092.zig
@@ -18,6 +18,8 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var baz: u32 = 24;
     try takeFoo(&.{
         .a = .{
diff --git a/test/behavior/bugs/12119.zig b/test/behavior/bugs/12119.zig
index 8c734ad6d6..bb5167a3da 100644
--- a/test/behavior/bugs/12119.zig
+++ b/test/behavior/bugs/12119.zig
@@ -9,6 +9,8 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const zerox32: u8x32 = [_]u8{0} ** 32;
     const bigsum: u32x8 = @bitCast(u32x8, zerox32);
     try std.testing.expectEqual(0, @reduce(.Add, bigsum));
diff --git a/test/behavior/bugs/12142.zig b/test/behavior/bugs/12142.zig
index 1efbd0dbb4..e5c022bf18 100644
--- a/test/behavior/bugs/12142.zig
+++ b/test/behavior/bugs/12142.zig
@@ -23,6 +23,8 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const test_struct = Test{
         .holders = &.{
             Holder{
diff --git a/test/behavior/bugs/12450.zig b/test/behavior/bugs/12450.zig
index 4d0c7cd9a1..368f055d05 100644
--- a/test/behavior/bugs/12450.zig
+++ b/test/behavior/bugs/12450.zig
@@ -14,6 +14,8 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
+
     var f1: *align(16) Foo = @alignCast(16, @ptrCast(*align(1) Foo, &buffer[0]));
     try expect(@typeInfo(@TypeOf(f1)).Pointer.alignment == 16);
     try expect(@ptrToInt(f1) == @ptrToInt(&f1.a));
diff --git a/test/behavior/bugs/12551.zig b/test/behavior/bugs/12551.zig
index df01e5cbdd..b2a79c0847 100644
--- a/test/behavior/bugs/12551.zig
+++ b/test/behavior/bugs/12551.zig
@@ -4,6 +4,7 @@ const builtin = @import("builtin");
 test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(for ([1]u8{0}) |x| {
         if (x == 0) break true;
diff --git a/test/behavior/bugs/12571.zig b/test/behavior/bugs/12571.zig
index 7b717369a6..f474c32824 100644
--- a/test/behavior/bugs/12571.zig
+++ b/test/behavior/bugs/12571.zig
@@ -14,6 +14,7 @@ const Entry = packed struct {
 test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const frame = Frame{ .num = 0x7FDE };
     var entry = Entry{ .other = 0, .frame = .{ .num = 0xFFFFF } };
diff --git a/test/behavior/bugs/12644.zig b/test/behavior/bugs/12644.zig
index 36874c12cb..3c0cc5656f 100644
--- a/test/behavior/bugs/12644.zig
+++ b/test/behavior/bugs/12644.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 inline fn foo(comptime T: type) !T {
     return error.AnError;
@@ -9,6 +10,8 @@ fn main0() !void {
 }
 
 test "issue12644" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     main0() catch |e| {
         try std.testing.expect(e == error.AnError);
     };
diff --git a/test/behavior/bugs/12680.zig b/test/behavior/bugs/12680.zig
index 362e03f8a8..b86a015e68 100644
--- a/test/behavior/bugs/12680.zig
+++ b/test/behavior/bugs/12680.zig
@@ -11,6 +11,7 @@ test "export a function twice" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.os.tag == .macos and builtin.zig_backend == .stage2_c) {
         // TODO: test.c: error: aliases are not supported on darwin
         return error.SkipZigTest;
diff --git a/test/behavior/bugs/1277.zig b/test/behavior/bugs/1277.zig
index 0dbf339f4d..64f8430cdb 100644
--- a/test/behavior/bugs/1277.zig
+++ b/test/behavior/bugs/1277.zig
@@ -16,6 +16,7 @@ test "don't emit an LLVM global for a const function when it's in an optional in
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(s.f.?() == 1234);
 }
diff --git a/test/behavior/bugs/12776.zig b/test/behavior/bugs/12776.zig
index 95158f5ee3..2061d6e804 100644
--- a/test/behavior/bugs/12776.zig
+++ b/test/behavior/bugs/12776.zig
@@ -32,6 +32,7 @@ test {
     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;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) {
         // Careful enabling this test, fails randomly.
         return error.SkipZigTest;
diff --git a/test/behavior/bugs/12801-2.zig b/test/behavior/bugs/12801-2.zig
index 5ae701a55c..e6243487b0 100644
--- a/test/behavior/bugs/12801-2.zig
+++ b/test/behavior/bugs/12801-2.zig
@@ -18,6 +18,7 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const a: Auto = .{ .offset = 16, .capacity = Auto.capacity };
     try std.testing.expect(a.capacity() == 32);
diff --git a/test/behavior/bugs/12890.zig b/test/behavior/bugs/12890.zig
index 1316c2745e..a832f14cef 100644
--- a/test/behavior/bugs/12890.zig
+++ b/test/behavior/bugs/12890.zig
@@ -11,6 +11,7 @@ fn a(b: []u3, c: u3) void {
 test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var arr: [8]u3 = undefined;
     a(&arr, 5);
diff --git a/test/behavior/bugs/12891.zig b/test/behavior/bugs/12891.zig
index 354d9e856e..9987a494e0 100644
--- a/test/behavior/bugs/12891.zig
+++ b/test/behavior/bugs/12891.zig
@@ -7,21 +7,29 @@ test "issue12891" {
     try std.testing.expect(i < f);
 }
 test "nan" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const f = comptime std.math.nan(f64);
     var i: usize = 0;
     try std.testing.expect(!(f < i));
 }
 test "inf" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const f = comptime std.math.inf(f64);
     var i: usize = 0;
     try std.testing.expect(f > i);
 }
 test "-inf < 0" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const f = comptime -std.math.inf(f64);
     var i: usize = 0;
     try std.testing.expect(f < i);
 }
 test "inf >= 1" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const f = comptime std.math.inf(f64);
     var i: usize = 1;
     try std.testing.expect(f >= i);
@@ -29,6 +37,7 @@ test "inf >= 1" {
 test "isNan(nan * 1)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const nan_times_one = comptime std.math.nan(f64) * 1;
     try std.testing.expect(std.math.isNan(nan_times_one));
@@ -36,6 +45,7 @@ test "isNan(nan * 1)" {
 test "runtime isNan(nan * 1)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const nan_times_one = std.math.nan(f64) * 1;
     try std.testing.expect(std.math.isNan(nan_times_one));
@@ -43,6 +53,7 @@ test "runtime isNan(nan * 1)" {
 test "isNan(nan * 0)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const nan_times_zero = comptime std.math.nan(f64) * 0;
     try std.testing.expect(std.math.isNan(nan_times_zero));
@@ -52,6 +63,7 @@ test "isNan(nan * 0)" {
 test "isNan(inf * 0)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const inf_times_zero = comptime std.math.inf(f64) * 0;
     try std.testing.expect(std.math.isNan(inf_times_zero));
@@ -61,6 +73,7 @@ test "isNan(inf * 0)" {
 test "runtime isNan(nan * 0)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const nan_times_zero = std.math.nan(f64) * 0;
     try std.testing.expect(std.math.isNan(nan_times_zero));
@@ -70,6 +83,7 @@ test "runtime isNan(nan * 0)" {
 test "runtime isNan(inf * 0)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const inf_times_zero = std.math.inf(f64) * 0;
     try std.testing.expect(std.math.isNan(inf_times_zero));
diff --git a/test/behavior/bugs/12928.zig b/test/behavior/bugs/12928.zig
index 56eca8cf60..dd5a7761d7 100644
--- a/test/behavior/bugs/12928.zig
+++ b/test/behavior/bugs/12928.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const expect = std.testing.expect;
+
 const A = extern struct {
     value: *volatile B,
 };
@@ -7,11 +9,15 @@ const B = extern struct {
     a: u32,
     b: i32,
 };
+
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var a: *A = undefined;
     try expect(@TypeOf(&a.value.a) == *volatile u32);
     try expect(@TypeOf(&a.value.b) == *volatile i32);
 }
+
 const C = extern struct {
     value: *volatile D,
 };
@@ -20,6 +26,8 @@ const D = extern union {
     b: i32,
 };
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var c: *C = undefined;
     try expect(@TypeOf(&c.value.a) == *volatile u32);
     try expect(@TypeOf(&c.value.b) == *volatile i32);
diff --git a/test/behavior/bugs/12972.zig b/test/behavior/bugs/12972.zig
index 3c256a19f8..329e993ab8 100644
--- a/test/behavior/bugs/12972.zig
+++ b/test/behavior/bugs/12972.zig
@@ -6,6 +6,7 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     const c: u8 = 42;
     f(&[_:null]?u8{c});
diff --git a/test/behavior/bugs/12984.zig b/test/behavior/bugs/12984.zig
index 75f2747eda..0b144ed159 100644
--- a/test/behavior/bugs/12984.zig
+++ b/test/behavior/bugs/12984.zig
@@ -14,6 +14,7 @@ pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void);
 test "simple test" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var c: CustomDraw = undefined;
     _ = c;
diff --git a/test/behavior/bugs/13064.zig b/test/behavior/bugs/13064.zig
index a6fea11e86..f997bb46b9 100644
--- a/test/behavior/bugs/13064.zig
+++ b/test/behavior/bugs/13064.zig
@@ -6,6 +6,7 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var x: [10][10]u32 = undefined;
 
diff --git a/test/behavior/bugs/13065.zig b/test/behavior/bugs/13065.zig
index 74f1d01c8c..d6c63db84b 100644
--- a/test/behavior/bugs/13065.zig
+++ b/test/behavior/bugs/13065.zig
@@ -11,6 +11,7 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var x = U{ .array = undefined };
 
diff --git a/test/behavior/bugs/13068.zig b/test/behavior/bugs/13068.zig
index bfe6164e27..046a27cc15 100644
--- a/test/behavior/bugs/13068.zig
+++ b/test/behavior/bugs/13068.zig
@@ -9,6 +9,7 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     list.items.len = 0;
 }
diff --git a/test/behavior/bugs/13069.zig b/test/behavior/bugs/13069.zig
index 41c5906ee6..916f3ba800 100644
--- a/test/behavior/bugs/13069.zig
+++ b/test/behavior/bugs/13069.zig
@@ -6,6 +6,7 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var opt_x: ?[3]f32 = [_]f32{0.0} ** 3;
 
diff --git a/test/behavior/bugs/13113.zig b/test/behavior/bugs/13113.zig
index f9e0c8e7bb..72ab0f9f5e 100644
--- a/test/behavior/bugs/13113.zig
+++ b/test/behavior/bugs/13113.zig
@@ -11,6 +11,8 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const foo = Foo{
         .a = 1,
         .b = 2,
diff --git a/test/behavior/bugs/13128.zig b/test/behavior/bugs/13128.zig
index 26f8510328..a378b42818 100644
--- a/test/behavior/bugs/13128.zig
+++ b/test/behavior/bugs/13128.zig
@@ -17,6 +17,7 @@ test "runtime union init, most-aligned field != largest" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var x: u8 = 1;
     try foo(.{ .x = x });
diff --git a/test/behavior/bugs/13159.zig b/test/behavior/bugs/13159.zig
index c394839731..6f8ae1842f 100644
--- a/test/behavior/bugs/13159.zig
+++ b/test/behavior/bugs/13159.zig
@@ -11,6 +11,8 @@ const Bar = packed struct {
 
 test {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var foo = Bar.Baz.fizz;
     try expect(foo == .fizz);
 }
diff --git a/test/behavior/bugs/13285.zig b/test/behavior/bugs/13285.zig
index 15ebfa5804..b87020bf46 100644
--- a/test/behavior/bugs/13285.zig
+++ b/test/behavior/bugs/13285.zig
@@ -6,6 +6,7 @@ const Crasher = struct {
 
 test {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var a: Crasher = undefined;
     var crasher_ptr = &a;
diff --git a/test/behavior/bugs/13366.zig b/test/behavior/bugs/13366.zig
index ff90ee00c3..cec015cc40 100644
--- a/test/behavior/bugs/13366.zig
+++ b/test/behavior/bugs/13366.zig
@@ -18,6 +18,7 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var a: u32 = 16;
     var reason = .{ .c_import = .{ .a = a } };
diff --git a/test/behavior/bugs/13664.zig b/test/behavior/bugs/13664.zig
index 16ebb6ed68..7171a89f29 100644
--- a/test/behavior/bugs/13664.zig
+++ b/test/behavior/bugs/13664.zig
@@ -18,6 +18,7 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     const timestamp: i64 = value();
     const id = ID{ .fields = Fields{
diff --git a/test/behavior/bugs/13785.zig b/test/behavior/bugs/13785.zig
index 463cdbec68..53d03f5413 100644
--- a/test/behavior/bugs/13785.zig
+++ b/test/behavior/bugs/13785.zig
@@ -6,6 +6,7 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     var a: u8 = 0;
     try std.io.null_writer.print("\n{} {}\n", .{ a, S{} });
diff --git a/test/behavior/bugs/1381.zig b/test/behavior/bugs/1381.zig
index ef34dc6410..aa349b4d13 100644
--- a/test/behavior/bugs/1381.zig
+++ b/test/behavior/bugs/1381.zig
@@ -17,6 +17,7 @@ test "union that needs padding bytes inside an array" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var as = [_]A{
         A{ .B = B{ .D = 1 } },
diff --git a/test/behavior/bugs/1442.zig b/test/behavior/bugs/1442.zig
index f9bef6ec50..7ce138dfd7 100644
--- a/test/behavior/bugs/1442.zig
+++ b/test/behavior/bugs/1442.zig
@@ -10,6 +10,8 @@ test "const error union field alignment" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var union_or_err: anyerror!Union = Union{ .Color = 1234 };
     try std.testing.expect((union_or_err catch unreachable).Color == 1234);
 }
diff --git a/test/behavior/bugs/14854.zig b/test/behavior/bugs/14854.zig
index b34dd49406..9c877bc688 100644
--- a/test/behavior/bugs/14854.zig
+++ b/test/behavior/bugs/14854.zig
@@ -1,6 +1,9 @@
 const testing = @import("std").testing;
+const builtin = @import("builtin");
 
 test {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try testing.expect(getGeneric(u8, getU8) == 123);
 }
 
diff --git a/test/behavior/bugs/1500.zig b/test/behavior/bugs/1500.zig
index cc12c5d0be..3a6246b2c9 100644
--- a/test/behavior/bugs/1500.zig
+++ b/test/behavior/bugs/1500.zig
@@ -6,6 +6,8 @@ const A = struct {
 const B = *const fn (A) void;
 
 test "allow these dependencies" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var a: A = undefined;
     var b: B = undefined;
     if (false) {
diff --git a/test/behavior/bugs/1607.zig b/test/behavior/bugs/1607.zig
index a60a406b75..31904ec3fd 100644
--- a/test/behavior/bugs/1607.zig
+++ b/test/behavior/bugs/1607.zig
@@ -14,6 +14,8 @@ test "slices pointing at the same address as global array." {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try checkAddress(&a);
     comptime try checkAddress(&a);
 }
diff --git a/test/behavior/bugs/1735.zig b/test/behavior/bugs/1735.zig
index 12600ccef9..78fd59e41e 100644
--- a/test/behavior/bugs/1735.zig
+++ b/test/behavior/bugs/1735.zig
@@ -44,6 +44,8 @@ const a = struct {
 test "initialization" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var t = a.init();
     try std.testing.expect(t.foo.len == 0);
 }
diff --git a/test/behavior/bugs/1741.zig b/test/behavior/bugs/1741.zig
index 63de6e83dc..6c36ba5e15 100644
--- a/test/behavior/bugs/1741.zig
+++ b/test/behavior/bugs/1741.zig
@@ -5,6 +5,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const x: f32 align(128) = 12.34;
     try std.testing.expect(@ptrToInt(&x) % 128 == 0);
diff --git a/test/behavior/bugs/1851.zig b/test/behavior/bugs/1851.zig
index cf7c7ced28..4af02feaca 100644
--- a/test/behavior/bugs/1851.zig
+++ b/test/behavior/bugs/1851.zig
@@ -7,6 +7,7 @@ test "allocation and looping over 3-byte integer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {
         return error.SkipZigTest; // TODO
diff --git a/test/behavior/bugs/1914.zig b/test/behavior/bugs/1914.zig
index bd3f830e60..14f4b0be27 100644
--- a/test/behavior/bugs/1914.zig
+++ b/test/behavior/bugs/1914.zig
@@ -12,6 +12,8 @@ const b_list: []B = &[_]B{};
 const a = A{ .b_list_pointer = &b_list };
 
 test "segfault bug" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const assert = std.debug.assert;
     const obj = B{ .a_pointer = &a };
     assert(obj.a_pointer == &a); // this makes zig crash
@@ -28,5 +30,7 @@ pub const B2 = struct {
 var b_value = B2{ .pointer_array = &[_]*A2{} };
 
 test "basic stuff" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     std.debug.assert(&b_value == &b_value);
 }
diff --git a/test/behavior/bugs/2006.zig b/test/behavior/bugs/2006.zig
index 3a4e61b11d..40f03d5b0b 100644
--- a/test/behavior/bugs/2006.zig
+++ b/test/behavior/bugs/2006.zig
@@ -7,6 +7,7 @@ const S = struct {
 };
 test "bug 2006" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var a: S = undefined;
     a = S{ .p = undefined };
diff --git a/test/behavior/bugs/2114.zig b/test/behavior/bugs/2114.zig
index 3ad4a97b80..265de399f7 100644
--- a/test/behavior/bugs/2114.zig
+++ b/test/behavior/bugs/2114.zig
@@ -14,6 +14,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     try testCtz();
     comptime try testCtz();
diff --git a/test/behavior/bugs/2578.zig b/test/behavior/bugs/2578.zig
index ff8ba141fa..9cf34e980d 100644
--- a/test/behavior/bugs/2578.zig
+++ b/test/behavior/bugs/2578.zig
@@ -15,6 +15,7 @@ test "fixed" {
     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_spirv64) return error.SkipZigTest;
 
     bar(t);
 }
diff --git a/test/behavior/bugs/2622.zig b/test/behavior/bugs/2622.zig
index 89130a3974..d3d2b078e2 100644
--- a/test/behavior/bugs/2622.zig
+++ b/test/behavior/bugs/2622.zig
@@ -7,6 +7,7 @@ test "reslice of undefined global var slice" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var mem: [100]u8 = [_]u8{0} ** 100;
     buf = &mem;
diff --git a/test/behavior/bugs/2692.zig b/test/behavior/bugs/2692.zig
index d89b3b5449..0eed28b2e7 100644
--- a/test/behavior/bugs/2692.zig
+++ b/test/behavior/bugs/2692.zig
@@ -7,6 +7,7 @@ fn foo(a: []u8) void {
 test "address of 0 length array" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var pt: [0]u8 = undefined;
     foo(&pt);
diff --git a/test/behavior/bugs/3007.zig b/test/behavior/bugs/3007.zig
index 3ae1562e9b..7adec60a3b 100644
--- a/test/behavior/bugs/3007.zig
+++ b/test/behavior/bugs/3007.zig
@@ -22,6 +22,7 @@ test "fixed" {
     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_spirv64) return error.SkipZigTest;
 
     default_foo = get_foo() catch null; // This Line
     try std.testing.expect(!default_foo.?.free);
diff --git a/test/behavior/bugs/3046.zig b/test/behavior/bugs/3046.zig
index 24e18043a0..683ece874e 100644
--- a/test/behavior/bugs/3046.zig
+++ b/test/behavior/bugs/3046.zig
@@ -16,6 +16,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     some_struct = SomeStruct{
         .field = couldFail() catch @as(i32, 0),
diff --git a/test/behavior/bugs/3112.zig b/test/behavior/bugs/3112.zig
index 0b0f767e77..b1dc2e2908 100644
--- a/test/behavior/bugs/3112.zig
+++ b/test/behavior/bugs/3112.zig
@@ -15,6 +15,8 @@ test "zig test crash" {
     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_spirv64) return error.SkipZigTest;
+
     var global: State = undefined;
     global.enter = prev;
     global.enter(null);
diff --git a/test/behavior/bugs/3367.zig b/test/behavior/bugs/3367.zig
index 68b7d90ae8..775e918f63 100644
--- a/test/behavior/bugs/3367.zig
+++ b/test/behavior/bugs/3367.zig
@@ -10,6 +10,8 @@ const Mixin = struct {
 };
 
 test "container member access usingnamespace decls" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var foo = Foo{};
     foo.two();
 }
diff --git a/test/behavior/bugs/3742.zig b/test/behavior/bugs/3742.zig
index 1ee88b8b64..09d209912e 100644
--- a/test/behavior/bugs/3742.zig
+++ b/test/behavior/bugs/3742.zig
@@ -40,5 +40,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_llvm and
         builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     ArgSerializer.serializeCommand(GET.init("banana"));
 }
diff --git a/test/behavior/bugs/3779.zig b/test/behavior/bugs/3779.zig
index c2bd103118..2b1dad5de0 100644
--- a/test/behavior/bugs/3779.zig
+++ b/test/behavior/bugs/3779.zig
@@ -8,6 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
 test "@tagName() returns a string literal" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
     try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
@@ -21,6 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
 test "@errorName() returns a string literal" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
     try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
@@ -34,6 +36,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
 test "@typeName() returns a string literal" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
     try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
@@ -47,6 +50,7 @@ const expected_contents = "hello zig\n";
 test "@embedFile() returns a string literal" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
     try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
@@ -61,6 +65,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
 test "@src() returns a struct containing 0-terminated string slices" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const src = testFnForSrc();
     try std.testing.expect([:0]const u8 == @TypeOf(src.file));
diff --git a/test/behavior/bugs/421.zig b/test/behavior/bugs/421.zig
index 69ecbd2331..f44cee37a9 100644
--- a/test/behavior/bugs/421.zig
+++ b/test/behavior/bugs/421.zig
@@ -5,6 +5,7 @@ test "bitCast to array" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     comptime try testBitCastArray();
     try testBitCastArray();
diff --git a/test/behavior/bugs/4328.zig b/test/behavior/bugs/4328.zig
index 924a8cb909..89eb4d4fd0 100644
--- a/test/behavior/bugs/4328.zig
+++ b/test/behavior/bugs/4328.zig
@@ -17,6 +17,8 @@ const S = extern struct {
 };
 
 test "Extern function calls in @TypeOf" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const Test = struct {
         fn test_fn_1(a: anytype, b: anytype) @TypeOf(c_printf("%d %s\n", a, b)) {
             return 0;
@@ -37,6 +39,8 @@ test "Extern function calls in @TypeOf" {
 }
 
 test "Peer resolution of extern function calls in @TypeOf" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const Test = struct {
         fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) {
             return 0;
@@ -54,6 +58,7 @@ test "Peer resolution of extern function calls in @TypeOf" {
 test "Extern function calls, dereferences and field access in @TypeOf" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const Test = struct {
         fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {
diff --git a/test/behavior/bugs/4954.zig b/test/behavior/bugs/4954.zig
index 8cae03d314..15c3185fa9 100644
--- a/test/behavior/bugs/4954.zig
+++ b/test/behavior/bugs/4954.zig
@@ -8,6 +8,7 @@ test "crash" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var buf: [4096]u8 = undefined;
     f(&buf);
diff --git a/test/behavior/bugs/529.zig b/test/behavior/bugs/529.zig
index 3319d06c95..a2e330055a 100644
--- a/test/behavior/bugs/529.zig
+++ b/test/behavior/bugs/529.zig
@@ -16,6 +16,7 @@ test "issue 529 fixed" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     @import("529_other_file.zig").issue529(null);
     issue529(null);
diff --git a/test/behavior/bugs/5398.zig b/test/behavior/bugs/5398.zig
index 6f75bd9436..4dc4ab8d19 100644
--- a/test/behavior/bugs/5398.zig
+++ b/test/behavior/bugs/5398.zig
@@ -22,6 +22,7 @@ test "assignment of field with padding" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     renderable = Renderable{
         .mesh = Mesh{ .id = 0 },
diff --git a/test/behavior/bugs/6047.zig b/test/behavior/bugs/6047.zig
index d3c2c8349c..54e1fd20d6 100644
--- a/test/behavior/bugs/6047.zig
+++ b/test/behavior/bugs/6047.zig
@@ -14,6 +14,7 @@ test "`try`ing an if/else expression" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try @import("std").testing.expectError(error.Test, getError2());
 }
diff --git a/test/behavior/bugs/6456.zig b/test/behavior/bugs/6456.zig
index 3dbec7bc70..1eef9c7f75 100644
--- a/test/behavior/bugs/6456.zig
+++ b/test/behavior/bugs/6456.zig
@@ -13,6 +13,7 @@ const text =
 test "issue 6456" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     comptime {
         var fields: []const StructField = &[0]StructField{};
diff --git a/test/behavior/bugs/656.zig b/test/behavior/bugs/656.zig
index 216c9d8e1c..161da66964 100644
--- a/test/behavior/bugs/656.zig
+++ b/test/behavior/bugs/656.zig
@@ -14,6 +14,8 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an
     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_spirv64) return error.SkipZigTest;
+
     try foo(false, true);
 }
 
diff --git a/test/behavior/bugs/6781.zig b/test/behavior/bugs/6781.zig
index dd12bf2a93..2f5d7a3807 100644
--- a/test/behavior/bugs/6781.zig
+++ b/test/behavior/bugs/6781.zig
@@ -68,6 +68,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536;
     var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);
diff --git a/test/behavior/bugs/6905.zig b/test/behavior/bugs/6905.zig
index 4f308ede22..5792713c89 100644
--- a/test/behavior/bugs/6905.zig
+++ b/test/behavior/bugs/6905.zig
@@ -6,6 +6,7 @@ test "sentinel-terminated 0-length slices" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
 
diff --git a/test/behavior/bugs/6947.zig b/test/behavior/bugs/6947.zig
index c2b538c3fa..9aff7b992e 100644
--- a/test/behavior/bugs/6947.zig
+++ b/test/behavior/bugs/6947.zig
@@ -9,6 +9,7 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var slice: []void = undefined;
     destroy(&slice[0]);
diff --git a/test/behavior/bugs/7047.zig b/test/behavior/bugs/7047.zig
index a60a7d2bbb..a7a0966935 100644
--- a/test/behavior/bugs/7047.zig
+++ b/test/behavior/bugs/7047.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const U = union(enum) {
     T: type,
@@ -14,6 +15,8 @@ fn S(comptime query: U) type {
 }
 
 test "compiler doesn't consider equal unions with different 'type' payload" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const s1 = S(U{ .T = u32 }).tag();
     try std.testing.expectEqual(u32, s1);
 
diff --git a/test/behavior/bugs/718.zig b/test/behavior/bugs/718.zig
index 1c88908f75..b0f0d1ec52 100644
--- a/test/behavior/bugs/718.zig
+++ b/test/behavior/bugs/718.zig
@@ -13,6 +13,7 @@ test "zero keys with @memset" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     @memset(@ptrCast([*]u8, &keys)[0..@sizeOf(@TypeOf(keys))], 0);
     try expect(!keys.up);
diff --git a/test/behavior/bugs/7187.zig b/test/behavior/bugs/7187.zig
index bb2e82af89..be593d7fad 100644
--- a/test/behavior/bugs/7187.zig
+++ b/test/behavior/bugs/7187.zig
@@ -3,6 +3,8 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "miscompilation with bool return type" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var x: usize = 1;
     var y: bool = getFalse();
     _ = y;
diff --git a/test/behavior/bugs/726.zig b/test/behavior/bugs/726.zig
index cc5c2a5fb7..0cd8abc1cf 100644
--- a/test/behavior/bugs/726.zig
+++ b/test/behavior/bugs/726.zig
@@ -5,6 +5,7 @@ test "@ptrCast from const to nullable" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const c: u8 = 4;
     var x: ?*const u8 = @ptrCast(?*const u8, &c);
@@ -15,6 +16,7 @@ test "@ptrCast from var in empty struct to nullable" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const container = struct {
         var c: u8 = 4;
diff --git a/test/behavior/bugs/7325.zig b/test/behavior/bugs/7325.zig
index 23550a512d..5c0c55a644 100644
--- a/test/behavior/bugs/7325.zig
+++ b/test/behavior/bugs/7325.zig
@@ -82,6 +82,7 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var param: ParamType = .{
         .one_of = .{ .name = "name" },
diff --git a/test/behavior/bugs/8277.zig b/test/behavior/bugs/8277.zig
index 8d64d49223..149962d996 100644
--- a/test/behavior/bugs/8277.zig
+++ b/test/behavior/bugs/8277.zig
@@ -2,6 +2,8 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 test "@sizeOf reified union zero-size payload fields" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     comptime {
         try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {}))));
         try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void }))));
diff --git a/test/behavior/bugs/828.zig b/test/behavior/bugs/828.zig
index 220d98ce09..a0ac00817d 100644
--- a/test/behavior/bugs/828.zig
+++ b/test/behavior/bugs/828.zig
@@ -31,6 +31,7 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void {
 
 test "comptime struct return should not return the same instance" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     //the first parameter must be passed by reference to trigger the bug
     //a second parameter is required to trigger the bug
diff --git a/test/behavior/bugs/8646.zig b/test/behavior/bugs/8646.zig
index da9359a60a..1bd81f799f 100644
--- a/test/behavior/bugs/8646.zig
+++ b/test/behavior/bugs/8646.zig
@@ -11,6 +11,7 @@ test {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try std.testing.expect(array[0].len == 1);
     try std.testing.expectEqualStrings("hello", array[0][0]);
diff --git a/test/behavior/bugs/920.zig b/test/behavior/bugs/920.zig
index b1c9bc07a3..8a9bf51512 100644
--- a/test/behavior/bugs/920.zig
+++ b/test/behavior/bugs/920.zig
@@ -62,6 +62,7 @@ test "bug 920 fixed" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_spirv64) return error.SkipZigTest;
 
     const NormalDist1 = blk: {
         break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
diff --git a/test/behavior/bugs/9584.zig b/test/behavior/bugs/9584.zig
index 307f1689bf..49139db899 100644
--- a/test/behavior/bugs/9584.zig
+++ b/test/behavior/bugs/9584.zig
@@ -47,6 +47,7 @@ test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var flags = A{
         .a = false,