From 37aa343079d32db96be742c9740f343ff8d2839e Mon Sep 17 00:00:00 2001
From: Robin Voetter <robin@voetter.nl>
Date: Fri, 19 May 2023 11:23:22 +0200
Subject: [PATCH] spirv: more passing tests

---
 test/behavior/align.zig                                   | 4 ----
 test/behavior/array.zig                                   | 2 --
 test/behavior/atomics.zig                                 | 2 --
 test/behavior/basic.zig                                   | 2 +-
 test/behavior/bitcast.zig                                 | 1 -
 test/behavior/bitreverse.zig                              | 1 -
 test/behavior/call.zig                                    | 3 ---
 test/behavior/cast.zig                                    | 2 --
 test/behavior/decltest.zig                                | 2 --
 test/behavior/defer.zig                                   | 3 ---
 test/behavior/duplicated_test_names.zig                   | 2 --
 test/behavior/enum.zig                                    | 1 -
 test/behavior/error.zig                                   | 1 -
 test/behavior/eval.zig                                    | 1 -
 test/behavior/floatop.zig                                 | 1 -
 test/behavior/fn.zig                                      | 2 --
 test/behavior/fn_delegation.zig                           | 1 -
 test/behavior/fn_in_struct_in_comptime.zig                | 2 --
 test/behavior/for.zig                                     | 2 --
 test/behavior/generics.zig                                | 2 --
 test/behavior/if.zig                                      | 2 --
 test/behavior/inttoptr.zig                                | 1 -
 test/behavior/maximum_minimum.zig                         | 2 --
 test/behavior/optional.zig                                | 1 -
 test/behavior/packed-struct.zig                           | 1 -
 test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig | 1 -
 test/behavior/reflection.zig                              | 1 -
 test/behavior/sizeof_and_typeof.zig                       | 2 --
 test/behavior/slice.zig                                   | 2 --
 test/behavior/struct.zig                                  | 1 -
 test/behavior/switch.zig                                  | 1 -
 test/behavior/this.zig                                    | 2 --
 test/behavior/threadlocal.zig                             | 1 -
 test/behavior/type.zig                                    | 1 -
 test/behavior/type_info.zig                               | 1 -
 test/behavior/undefined.zig                               | 1 -
 test/behavior/union.zig                                   | 2 --
 test/behavior/var_args.zig                                | 2 --
 test/behavior/while.zig                                   | 1 -
 39 files changed, 1 insertion(+), 62 deletions(-)

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 4bd6666696..bc1091ace7 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -33,8 +33,6 @@ test "default alignment allows unspecified in type syntax" {
 }
 
 test "implicitly decreasing pointer alignment" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
     try expect(addUnaligned(&a, &b) == 7);
@@ -45,8 +43,6 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
 }
 
 test "@alignCast pointers" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     var x: u32 align(4) = 1;
     expectsOnly1(&x);
     try expect(x == 2);
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index b4754a59a4..ed8b021613 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -347,7 +347,6 @@ test "read/write through global variable array of struct fields initialized via
 test "implicit cast single-item pointer" {
     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 testImplicitCastSingleItemPtr();
     comptime try testImplicitCastSingleItemPtr();
@@ -542,7 +541,6 @@ test "sentinel element count towards the ABI size calculation" {
     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 S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig
index d1b51207a4..99f08a6cae 100644
--- a/test/behavior/atomics.zig
+++ b/test/behavior/atomics.zig
@@ -120,7 +120,6 @@ test "128-bit cmpxchg" {
     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;
 
     try test_u128_cmpxchg();
     comptime try test_u128_cmpxchg();
@@ -313,7 +312,6 @@ test "atomicrmw with 128-bit ints" {
 
     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_spirv64) return error.SkipZigTest;
 
     // TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64
     if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 7f9e2ae78a..3024ad58c0 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -583,7 +583,7 @@ test "comptime cast fn to ptr" {
 }
 
 test "equality compare fn ptrs" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not
 
     var a = &emptyFn;
     try expect(a == a);
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 4b8c363ac2..28eb00c6c1 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -9,7 +9,6 @@ const native_endian = builtin.target.cpu.arch.endian();
 
 test "@bitCast iX -> uX (32, 64)" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const bit_values = [_]usize{ 32, 64 };
 
diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig
index 87cea942d0..8d98f65b55 100644
--- a/test/behavior/bitreverse.zig
+++ b/test/behavior/bitreverse.zig
@@ -5,7 +5,6 @@ const minInt = std.math.minInt;
 
 test "@bitReverse large exotic integer" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
 }
diff --git a/test/behavior/call.zig b/test/behavior/call.zig
index e7d59d7e75..76225d815d 100644
--- a/test/behavior/call.zig
+++ b/test/behavior/call.zig
@@ -109,7 +109,6 @@ test "result location of function call argument through runtime condition and st
 
 test "function call with 40 arguments" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(thirty_nine: i32) !void {
@@ -374,8 +373,6 @@ test "Enum constructed by @Type passed as generic argument" {
 }
 
 test "generic function with generic function parameter" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const S = struct {
         fn f(comptime a: fn (anytype) anyerror!void, b: anytype) anyerror!void {
             try a(b);
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 847abc1798..f3a64b4b7c 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -366,7 +366,6 @@ test "return u8 coercing into ?u32 return type" {
     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;
 
     const S = struct {
         fn doTheTest() !void {
@@ -428,7 +427,6 @@ test "peer resolve array and const slice" {
     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;
 
     try testPeerResolveArrayConstSlice(true);
     comptime try testPeerResolveArrayConstSlice(true);
diff --git a/test/behavior/decltest.zig b/test/behavior/decltest.zig
index 7aa8fb6318..b01a431e28 100644
--- a/test/behavior/decltest.zig
+++ b/test/behavior/decltest.zig
@@ -5,7 +5,5 @@ pub fn the_add_function(a: u32, b: u32) u32 {
 }
 
 test the_add_function {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     if (the_add_function(1, 2) != 3) unreachable;
 }
diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig
index 5aa8c2f02b..c97350cd75 100644
--- a/test/behavior/defer.zig
+++ b/test/behavior/defer.zig
@@ -23,8 +23,6 @@ fn testBreakContInDefer(x: usize) void {
 }
 
 test "defer and labeled break" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     var i = @as(usize, 0);
 
     blk: {
@@ -58,7 +56,6 @@ test "return variable while defer expression in scope to modify it" {
     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 S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/duplicated_test_names.zig b/test/behavior/duplicated_test_names.zig
index 81b9ebdf50..52930ea318 100644
--- a/test/behavior/duplicated_test_names.zig
+++ b/test/behavior/duplicated_test_names.zig
@@ -15,7 +15,5 @@ comptime {
 test "thingy" {}
 
 test thingy {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     if (thingy(1, 2) != 3) unreachable;
 }
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index 097caaad19..255efc50fc 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -1046,7 +1046,6 @@ test "tag name with assigned enum values" {
 test "@tagName on enum literals" {
     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 expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
     comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index 54d53eec4a..89ce094010 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -16,7 +16,6 @@ fn expectError(expected_err: anyerror, observed_err_union: anytype) !void {
 }
 
 test "error values" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const a = @errorToInt(error.err1);
     const b = @errorToInt(error.err2);
     try expect(a != b);
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index d22eba4fa0..cd913dcc9a 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -23,7 +23,6 @@ test "static add one" {
     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(should_be_1235 == 1235);
 }
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index 21fc87ff22..97054b7083 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -506,7 +506,6 @@ test "@fabs" {
     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;
 
     comptime try testFabs();
     try testFabs();
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index c84eb48d2e..608b992eb3 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -5,8 +5,6 @@ const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
 test "params" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     try expect(testParamsAdd(22, 11) == 33);
 }
 fn testParamsAdd(a: i32, b: i32) i32 {
diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig
index d7a2ba2125..95dbfeb4b2 100644
--- a/test/behavior/fn_delegation.zig
+++ b/test/behavior/fn_delegation.zig
@@ -34,7 +34,6 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
 test "fn delegation" {
     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 foo = Foo{};
     try expect(foo.one() == 11);
diff --git a/test/behavior/fn_in_struct_in_comptime.zig b/test/behavior/fn_in_struct_in_comptime.zig
index 427b08e6a4..a7d8e779cc 100644
--- a/test/behavior/fn_in_struct_in_comptime.zig
+++ b/test/behavior/fn_in_struct_in_comptime.zig
@@ -13,8 +13,6 @@ fn get_foo() fn (*u8) usize {
 }
 
 test "define a function in an anonymous struct in comptime" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const foo = get_foo();
     try expect(foo(@intToPtr(*u8, 12345)) == 12345);
 }
diff --git a/test/behavior/for.zig b/test/behavior/for.zig
index 8c9eeb083e..c99ee2edeb 100644
--- a/test/behavior/for.zig
+++ b/test/behavior/for.zig
@@ -22,8 +22,6 @@ test "continue in for loop" {
 }
 
 test "break from outer for loop" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     try testBreakOuter();
     comptime try testBreakOuter();
 }
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index e8d064154b..eddca9e7b1 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -5,8 +5,6 @@ const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
 test "one param, explicit comptime" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     var x: usize = 0;
     x += checkSize(i32);
     x += checkSize(bool);
diff --git a/test/behavior/if.zig b/test/behavior/if.zig
index 7369435cd3..c17f2c9891 100644
--- a/test/behavior/if.zig
+++ b/test/behavior/if.zig
@@ -71,8 +71,6 @@ test "labeled break inside comptime if inside runtime if" {
 }
 
 test "const result loc, runtime if cond, else unreachable" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const Num = enum { One, Two };
 
     var t = true;
diff --git a/test/behavior/inttoptr.zig b/test/behavior/inttoptr.zig
index a05ed83b9b..29a263b2ce 100644
--- a/test/behavior/inttoptr.zig
+++ b/test/behavior/inttoptr.zig
@@ -14,7 +14,6 @@ test "mutate through ptr initialized with constant intToPtr value" {
     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;
 
     forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
 }
diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig
index db6cad221f..648d4d9493 100644
--- a/test/behavior/maximum_minimum.zig
+++ b/test/behavior/maximum_minimum.zig
@@ -129,8 +129,6 @@ test "@min/max for floats" {
 }
 
 test "@min/@max on lazy values" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const A = extern struct { u8_4: [4]u8 };
     const B = extern struct { u8_16: [16]u8 };
     const size = @max(@sizeOf(A), @sizeOf(B));
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index e62065cf25..a813580a20 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -8,7 +8,6 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 test "passing an optional integer as a parameter" {
     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 S = struct {
         fn entry() bool {
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 36e37786f1..7406c22f46 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -7,7 +7,6 @@ const native_endian = builtin.cpu.arch.endian();
 
 test "flags in packed structs" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const Flags1 = packed struct {
         // first 8 bits
diff --git a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig
index 41d7f56662..bb6d5b1359 100644
--- a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig
+++ b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig
@@ -8,7 +8,6 @@ test "reference a variable in an if after an if in the 2nd switch prong" {
     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 foo(true, Num.Two, false, "aoeu");
     try expect(!ok);
diff --git a/test/behavior/reflection.zig b/test/behavior/reflection.zig
index b62838f243..aea84bc45a 100644
--- a/test/behavior/reflection.zig
+++ b/test/behavior/reflection.zig
@@ -28,7 +28,6 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
 test "reflection: @field" {
     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 f = Foo{
         .one = 42,
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index e01e20e544..3f70f02fcb 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -140,8 +140,6 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
 }
 
 test "@TypeOf() has no runtime side effects" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const S = struct {
         fn foo(comptime T: type, ptr: *T) T {
             ptr.* += 1;
diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig
index 3b88636dca..dc27328e6d 100644
--- a/test/behavior/slice.zig
+++ b/test/behavior/slice.zig
@@ -201,8 +201,6 @@ test "slicing pointer by length" {
 const x = @intToPtr([*]i32, 0x1000)[0..0x500];
 const y = x[0x100..];
 test "compile time slice of pointer to hard coded address" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     try expect(@ptrToInt(x) == 0x1000);
     try expect(x.len == 0x500);
 
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 659acbf56b..a4a24ef3b3 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -11,7 +11,6 @@ top_level_field: i32,
 test "top level fields" {
     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 instance = @This(){
         .top_level_field = 1234,
diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig
index f66446632b..dd096f89ed 100644
--- a/test/behavior/switch.zig
+++ b/test/behavior/switch.zig
@@ -215,7 +215,6 @@ fn poll() void {
 
 test "switch on global mutable var isn't constant-folded" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     while (state < 2) {
         poll();
diff --git a/test/behavior/this.zig b/test/behavior/this.zig
index 8fd8af92a3..0bc765c8a7 100644
--- a/test/behavior/this.zig
+++ b/test/behavior/this.zig
@@ -21,8 +21,6 @@ fn add(x: i32, y: i32) i32 {
 }
 
 test "this refer to module call private fn" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     try expect(module.add(1, 2) == 3);
 }
 
diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig
index a1214fff21..57740f75ce 100644
--- a/test/behavior/threadlocal.zig
+++ b/test/behavior/threadlocal.zig
@@ -11,7 +11,6 @@ test "thread local variable" {
         else => return error.SkipZigTest,
     }; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         threadlocal var t: i32 = 1234;
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index 936d9663ad..2fff4b05af 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -491,7 +491,6 @@ test "Type.Fn" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     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;
 
     const some_opaque = opaque {};
     const some_ptr = *some_opaque;
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index d55688c5ee..18b65b755e 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -285,7 +285,6 @@ fn testUnion() !void {
 
 test "type info: struct info" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try testStruct();
     comptime try testStruct();
diff --git a/test/behavior/undefined.zig b/test/behavior/undefined.zig
index e0f3e00fff..6c99b4bbce 100644
--- a/test/behavior/undefined.zig
+++ b/test/behavior/undefined.zig
@@ -81,7 +81,6 @@ test "assign undefined to struct with method" {
 
 test "type name of undefined" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const x = undefined;
     try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)"));
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 26232159b6..213d4c75ea 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1467,8 +1467,6 @@ test "packed union in packed struct" {
 }
 
 test "Namespace-like union" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     const DepType = enum {
         git,
         http,
diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig
index adb5491f7f..94e2a81a9a 100644
--- a/test/behavior/var_args.zig
+++ b/test/behavior/var_args.zig
@@ -14,8 +14,6 @@ fn add(args: anytype) i32 {
 }
 
 test "add arbitrary args" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
     try expect(add(.{@as(i32, 1234)}) == 1234);
     try expect(add(.{}) == 0);
diff --git a/test/behavior/while.zig b/test/behavior/while.zig
index a6634b672f..8d3e3a12da 100644
--- a/test/behavior/while.zig
+++ b/test/behavior/while.zig
@@ -5,7 +5,6 @@ const assert = std.debug.assert;
 
 test "while loop" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var i: i32 = 0;
     while (i < 4) {