diff --git a/lib/compiler/aro/aro/Attribute/Wip.zig b/lib/compiler/aro/aro/Attribute/Wip.zig
index 3f1653564e50bf462a890ff38c2a5c5eed2a75d8..2488f0089f6b4e08168699b9d055e721844430f8 100644
--- a/lib/compiler/aro/aro/Attribute/Wip.zig
+++ b/lib/compiler/aro/aro/Attribute/Wip.zig
@@ -1303,7 +1303,7 @@ fn applyCallingConvention(wip: *Wip) !void {
         .default => unreachable,
         .cdecl => !(comp.target.cpu.arch.isArm() and comp.target.os.tag != .windows) and
             !comp.target.cpu.arch.isPowerPC64() and
-            !comp.target.cpu.arch.isSpirV(),
+            !comp.target.cpu.arch.isSpirv(),
         .aarch64_sve_pcs, .aarch64_vector_pcs => comp.target.cpu.arch.isAARCH64(),
         .arm_aapcs_vfp, .arm_aapcs => comp.target.cpu.arch.isArm(),
         .riscv_vector_cc, .riscv_vls_cc => comp.target.cpu.arch.isRISCV(),
diff --git a/lib/compiler/aro/aro/Target.zig b/lib/compiler/aro/aro/Target.zig
index a65a626a4fdf266b19285068688c8f8c5b995c4c..609ffe13774782f4d26663beff4f281b8d0a8430 100644
--- a/lib/compiler/aro/aro/Target.zig
+++ b/lib/compiler/aro/aro/Target.zig
@@ -113,7 +113,7 @@ pub const SubArch = enum {
             return @backingInt(std.Target.mips.Feature.mips32r6);
         } else if (arch.isMIPS64()) {
             return @backingInt(std.Target.mips.Feature.mips64r6);
-        } else if (arch.isSpirV()) {
+        } else if (arch.isSpirv()) {
             const spirv = std.Target.spirv.Feature;
             return @backingInt(switch (sub) {
                 .spirv_v10 => spirv.v1_0,
diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig
index 0438a8d469f3678cedca64033aa1146886d98556..c4ab7aadeb14ac68589f9add78fdea6c2a001c0a 100644
--- a/lib/compiler/test_runner.zig
+++ b/lib/compiler/test_runner.zig
@@ -36,7 +36,7 @@ const need_simple = switch (builtin.zig_backend) {
 pub fn main(init: std.process.Init.Minimal) void {
     @disableInstrumentation();
 
-    if (builtin.cpu.arch.isSpirV()) {
+    if (builtin.cpu.arch.isSpirv()) {
         // SPIR-V needs an special test-runner
         return;
     }
diff --git a/lib/std/Target.zig b/lib/std/Target.zig
index 6ec3d235b257d08780f1210e44bae2f7a5ee102d..28afc9d2ca70895b2633bd6b5261da9ecb0ad43f 100644
--- a/lib/std/Target.zig
+++ b/lib/std/Target.zig
@@ -2381,7 +2381,7 @@ pub fn supportsAddressSpace(
     const arch = target.cpu.arch;
 
     const is_nvptx = arch.isNvptx();
-    const is_spirv = arch.isSpirV();
+    const is_spirv = arch.isSpirv();
     const is_gpu = is_nvptx or is_spirv or arch == .amdgcn;
 
     return switch (address_space) {
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 5d709fdaa5435cf558b88a06229d09d64b036fce..2c3c5567107e2fa8f5c81c4598e643f496119bed 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -500,6 +500,7 @@ const use_trap_panic = switch (builtin.zig_backend) {
     .stage2_spirv,
     .stage2_x86,
     => true,
+    .stage2_llvm => builtin.cpu.arch.isSpirv(),
     else => false,
 };
 
diff --git a/lib/std/lang.zig b/lib/std/lang.zig
index 42c2f49e7f59476511811316fa17d09953bb9056..b9379a13492184970b84994d3eadb723846c6b14 100644
--- a/lib/std/lang.zig
+++ b/lib/std/lang.zig
@@ -1363,6 +1363,11 @@ pub const panic: type = p: {
         .stage2_powerpc,
         .stage2_riscv64,
         => std.debug.simple_panic,
+        .stage2_spirv => std.debug.no_panic,
+        .stage2_llvm => {
+            if (builtin.cpu.arch.isSpirv()) break :p std.debug.no_panic;
+            break :p std.debug.FullPanic(std.debug.defaultPanic);
+        },
         else => std.debug.FullPanic(std.debug.defaultPanic),
     };
 };
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index ce4523c71cc6d24ad79f8e48bce3b2117522aa01..244e8fd2971e1842702e6c7359882b5c46ebc0b2 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -4889,7 +4889,7 @@ pub fn doNotOptimizeAway(val: anytype) void {
             // tied to IDs that can be passed to valid instructions. Some
             // SPIR-V targets do not define c_long, so we just allow any sized
             // integer on these targets
-            const val_fits_in_gp_register = builtin.target.cpu.arch.isSpirV() or fits: {
+            const val_fits_in_gp_register = builtin.target.cpu.arch.isSpirv() or fits: {
                 const max_gp_register_bits = @bitSizeOf(c_long);
                 break :fits int.bits <= max_gp_register_bits;
             };
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index fe785191d9bd4f537983bb1c764f69eb1510467f..34e450dc0511bd29fc44ed28a94564e804bdb0ab 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -36,6 +36,7 @@ pub const backend_can_print = switch (builtin.zig_backend) {
     .stage2_riscv64,
     .stage2_spirv,
     => false,
+    .stage2_llvm => !builtin.cpu.arch.isSpirv(),
     else => true,
 };
 
diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index 5cf1765116b517eafe92790d5cb2542ede043b83..f01d3444cad29721bdc41ef49ed7784ad87a4066 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -212,13 +212,27 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
         .powerpc => subArchName(target, .powerpc, .{
             .{ .spe, "spe" },
         }),
-        .spirv32, .spirv64 => subArchName(target, .spirv, .{
-            .{ .v1_6, "1.6" },
-            .{ .v1_5, "1.5" },
-            .{ .v1_4, "1.4" },
-            .{ .v1_3, "1.3" },
-            .{ .v1_2, "1.2" },
-            .{ .v1_1, "1.1" },
+        .spirv32 => switch (target.os.tag) {
+            .vulkan, .opengl => subArchName(target, .spirv, .{
+                .{ .v1_6, "1.6" },
+                .{ .v1_5, "1.5" },
+            }),
+            else => subArchName(target, .spirv, .{
+                .{ .v1_6, "v1.6" },
+                .{ .v1_5, "v1.5" },
+                .{ .v1_4, "v1.4" },
+                .{ .v1_3, "v1.3" },
+                .{ .v1_2, "v1.2" },
+                .{ .v1_1, "v1.1" },
+            }),
+        },
+        .spirv64 => subArchName(target, .spirv, .{
+            .{ .v1_6, "v1.6" },
+            .{ .v1_5, "v1.5" },
+            .{ .v1_4, "v1.4" },
+            .{ .v1_3, "v1.3" },
+            .{ .v1_2, "v1.2" },
+            .{ .v1_1, "v1.1" },
         }),
         else => null,
     };
@@ -10234,6 +10248,55 @@ pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
     return self.opaqueTypeAssumeCapacity(name);
 }
 
+pub fn targetType(
+    self: *Builder,
+    name: String,
+    types: []const Type,
+    ints: []const u32,
+) Allocator.Error!Type {
+    try self.ensureUnusedTypeCapacity(1, Type.Target, types.len + ints.len);
+    const Key = struct { name: String, types: []const Type, ints: []const u32 };
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Key) u32 {
+            var hasher: std.hash.Wyhash = .init(comptime std.hash.int(@backingInt(Type.Tag.target)));
+            hasher.update(std.mem.asBytes(&key.name));
+            hasher.update(std.mem.sliceAsBytes(key.types));
+            hasher.update(std.mem.sliceAsBytes(key.ints));
+            return @truncate(hasher.final());
+        }
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
+            const rhs_data = ctx.builder.type_items.items[rhs_index];
+            if (rhs_data.tag != .target) return false;
+            var extra = ctx.builder.typeExtraDataTrail(Type.Target, rhs_data.data);
+            if (lhs_key.name != extra.data.name) return false;
+            const rhs_types = extra.trail.next(extra.data.types_len, Type, ctx.builder);
+            const rhs_ints = extra.trail.next(extra.data.ints_len, u32, ctx.builder);
+            return std.mem.eql(Type, lhs_key.types, rhs_types) and
+                std.mem.eql(u32, lhs_key.ints, rhs_ints);
+        }
+    };
+    const gop = self.type_map.getOrPutAssumeCapacityAdapted(
+        Key{ .name = name, .types = types, .ints = ints },
+        Adapter{ .builder = self },
+    );
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.type_items.appendAssumeCapacity(.{
+            .tag = .target,
+            .data = self.addTypeExtraAssumeCapacity(Type.Target{
+                .name = name,
+                .types_len = @intCast(types.len),
+                .ints_len = @intCast(ints.len),
+            }),
+        });
+        self.type_extra.appendSliceAssumeCapacity(@ptrCast(types));
+        self.type_extra.appendSliceAssumeCapacity(ints);
+    }
+    return @fromBackingInt(@intCast(gop.index));
+}
+
 pub fn namedTypeSetBody(
     self: *Builder,
     named_type: Type,
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 886b46179a789159d76b2b782f249d9a079ef370..db0dc95d27d1333470602321d7b262a4bc58dd28 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1300,7 +1300,7 @@ pub const cache_helpers = struct {
         const tag: @typeInfo(Config.DebugFormat).@"union".tag_type.? = x;
         hh.add(tag);
         switch (x) {
-            .strip, .code_view => {},
+            .strip, .code_view, .nsdi => {},
             .dwarf => |f| hh.add(f),
         }
     }
@@ -6303,6 +6303,7 @@ fn addCommonCCArgs(
     try argv.ensureUnusedCapacity(2);
     switch (comp.config.debug_format) {
         .strip => {},
+        .nsdi => argv.appendAssumeCapacity("-g"),
         .code_view => {
             // -g is required here because -gcodeview doesn't trigger debug info
             // generation, it only changes the type of information generated.
diff --git a/src/Compilation/Config.zig b/src/Compilation/Config.zig
index 4ebe3137be59c9bf90f8cce48e072ff74b413a63..0294268834e9b7c6f4fdf61deaab7a7b8f32bddb 100644
--- a/src/Compilation/Config.zig
+++ b/src/Compilation/Config.zig
@@ -72,6 +72,8 @@ pub const DebugFormat = union(enum) {
     strip,
     dwarf: std.dwarf.Format,
     code_view,
+    /// Non-semantic Shader Debug Info
+    nsdi,
 };
 
 pub const Options = struct {
@@ -517,7 +519,8 @@ pub fn resolve(options: Options) ResolveError!Config {
                 .windows, .uefi => .code_view,
                 else => .{ .dwarf = .@"32" },
             },
-            .spirv, .hex, .raw, .plan9 => .strip,
+            .spirv => .nsdi,
+            .hex, .raw, .plan9 => .strip,
         };
     };
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 1fbfa3dfab778f2e828e0cc3511f7f90523bacef..d0ec10cea99348b73bdf07fc4ae36886f63de6d5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6977,7 +6977,7 @@ fn analyzeCall(
     const is_inline_call = block.isComptime() or inline_requested;
 
     if (!is_inline_call) {
-        if (func_val == null and !func_is_extern and !block.is_typeof and zcu.getTarget().cpu.arch.isSpirV()) {
+        if (func_val == null and !func_is_extern and !block.is_typeof and zcu.getTarget().cpu.arch.isSpirv()) {
             return sema.fail(block, func_src, "SPIR-V does not support calling function pointers", .{});
         }
         if (sema.func_is_naked) return sema.failWithOwnedErrorMsg(block, msg: {
@@ -8695,19 +8695,17 @@ fn checkParamType(
     if (param_is_noalias and !param_ty.isGenericPoison() and !param_ty.isPtrAtRuntime(zcu) and !param_ty.isSliceAtRuntime(zcu)) {
         return sema.fail(block, param_src, "non-pointer parameter declared noalias", .{});
     }
-    switch (target.os.tag) {
-        .vulkan, .opengl => if (cc != .@"inline" and param_ty.isPtrAtRuntime(zcu)) {
-            switch (param_ty.ptrAddressSpace(zcu)) {
-                .input, .output => |as| return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(param_src, "function parameter cannot be a pointer in '{s}' address space", .{@tagName(as)});
-                    errdefer msg.destroy(sema.gpa);
-                    try sema.errNote(param_src, msg, "mark the function as 'inline' so the parameter is substituted at call sites", .{});
-                    break :msg msg;
-                }),
-                else => {},
-            }
-        },
-        else => {},
+    if (cc != .@"inline" and param_ty.isPtrAtRuntime(zcu)) {
+        const as = param_ty.ptrAddressSpace(zcu);
+        if (target_util.addrSpaceIsLogical(target, as)) switch (as) {
+            .input, .output => return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(param_src, "function parameter cannot be a pointer in '{s}' address space", .{@tagName(as)});
+                errdefer msg.destroy(sema.gpa);
+                try sema.errNote(param_src, msg, "mark the function as 'inline' so the parameter is substituted at call sites", .{});
+                break :msg msg;
+            }),
+            else => {},
+        };
     }
 }
 
@@ -8944,9 +8942,7 @@ fn checkMergeAllowed(sema: *Sema, block: *Block, src: LazySrcLoc, peer_ty: Type)
     }
 
     const as = peer_ty.ptrAddressSpace(zcu);
-    if (!target_util.shouldBlockPointerOps(target, as)) {
-        return;
-    }
+    if (!target_util.addrSpaceIsLogical(target, as)) return;
 
     return sema.failWithOwnedErrorMsg(block, msg: {
         const msg = try sema.errMsg(src, "value with non-mergable pointer type '{f}' depends on runtime control flow", .{peer_ty.fmt(zcu)});
@@ -15535,7 +15531,7 @@ fn zirAsm(
         }
 
         const constraint = sema.code.nullTerminatedString(input.data.constraint);
-        if (zcu.getTarget().cpu.arch.isSpirV() and std.mem.eql(u8, constraint, "c")) {
+        if (zcu.getTarget().cpu.arch.isSpirv() and std.mem.eql(u8, constraint, "c")) {
             const val = sema.resolveValue(arg.*) orelse {
                 return sema.fail(block, input_src, "assembly input with 'c' constraint must be compile-time known", .{});
             };
@@ -20925,7 +20921,7 @@ fn zirReifySpirvType(
         } },
     };
 
-    if (!target.cpu.arch.isSpirV()) {
+    if (!target.cpu.arch.isSpirv()) {
         return sema.fail(
             block,
             src,
@@ -22245,7 +22241,7 @@ fn ptrCastFull(
     try sema.validateRuntimeValue(block, operand_src, operand);
     try sema.checkLogicalPtrCast(block, src, operand_ty, dest_ty);
 
-    const can_cast_to_int = !target_util.shouldBlockPointerOps(zcu.getTarget(), operand_ty.ptrAddressSpace(zcu));
+    const can_cast_to_int = !target_util.addrSpaceIsLogical(zcu.getTarget(), operand_ty.ptrAddressSpace(zcu));
     const need_null_check = can_cast_to_int and block.wantSafety() and operand_ty.ptrAllowsZero(zcu) and !dest_ty.ptrAllowsZero(zcu);
     const need_align_check = can_cast_to_int and block.wantSafety() and dest_align.compare(.gt, src_align);
 
@@ -22791,7 +22787,7 @@ fn checkLogicalPtrOperation(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Typ
     if (zcu.intern_pool.indexToKey(ty.toIntern()) == .ptr_type) {
         const target = zcu.getTarget();
         const as = ty.ptrAddressSpace(zcu);
-        if (target_util.shouldBlockPointerOps(target, as)) {
+        if (target_util.addrSpaceIsLogical(target, as)) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "illegal operation on logical pointer of type '{f}'", .{ty.fmt(zcu)});
                 errdefer msg.destroy(sema.gpa);
@@ -22822,11 +22818,7 @@ fn checkLogicalPtrCast(
     const dest_child: Type = .fromInterned(dest_info.child);
 
     if (block.isComptime() or block.is_typeof) return;
-    switch (zcu.getTarget().os.tag) {
-        .vulkan, .opengl => {},
-        else => return,
-    }
-    if (src_info.flags.address_space == .physical_storage_buffer) return;
+    if (!target_util.addrSpaceIsLogical(zcu.getTarget(), src_info.flags.address_space)) return;
     if (!dest_child.hasRuntimeBits(zcu)) return;
 
     var cur = src_child;
@@ -30294,28 +30286,11 @@ fn checkSpirvSliceAllowed(
     const zcu = sema.pt.zcu;
     const target = zcu.getTarget();
 
-    if (!target.cpu.arch.isSpirV()) return;
+    if (!target.cpu.arch.isSpirv()) return;
     if (block.isComptime()) return;
 
-    // This probably lets some invalid OpPtrAccessChains slip through, but it's better than nothing
-    if (!target.cpu.has(.spirv, .variable_pointers) and !target.cpu.has(.spirv, .variable_pointers_storage_buffer)) {
-        return sema.failWithOwnedErrorMsg(
-            block,
-            try sema.errMsg(src, "cannot construct slices without the 'variable_pointers' or 'variable_pointers_storage_buffer' features", .{}),
-        );
-    }
-
-    switch (address_space) {
-        .shared, .storage_buffer => {},
-        else => {
-            return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(src, "cannot construct slice from address space '{t}'", .{address_space});
-                errdefer msg.destroy(sema.gpa);
-                try sema.errNote(src, msg, "only 'shared' and 'storage_buffer' address spaces support slicing on SPIR-V", .{});
-                break :msg msg;
-            });
-        },
-    }
+    if (!target_util.addrSpaceIsLogical(target, address_space)) return;
+    return sema.fail(block, src, "cannot construct slice from logical address space '{t}'", .{address_space});
 }
 
 fn coerceArrayPtrToSlice(
@@ -35094,7 +35069,7 @@ pub fn resolveNavPtrModifiers(
         };
         const addrspace_body = zir_decl.addrspace_body orelse {
             if (zir_decl.linkage == .@"extern" and
-                target.cpu.arch.isSpirV() and
+                target.cpu.arch.isSpirv() and
                 nav_ty.zigTypeTag(zcu) != .@"fn")
             {
                 return sema.fail(
@@ -35115,7 +35090,7 @@ pub fn resolveNavPtrModifiers(
         break :as try sema.analyzeAsAddressSpace(block, addrspace_src, addrspace_ref, addrspace_ctx);
     };
 
-    if (target.cpu.arch.isSpirV()) {
+    if (target.cpu.arch.isSpirv()) {
         if (zir_decl.kind == .@"var" and zir_decl.linkage != .@"extern" and !zir_decl.is_threadlocal) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const decl_src = block.nodeOffset(.zero);
diff --git a/src/Type.zig b/src/Type.zig
index f2707c942e2f24a1e94f5f9058b23db4f3eccc4b..647f7c87c0b15c86e8b3cd42c51aa79b165edc82 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -3135,7 +3135,7 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
         => false,
 
         .vector => {
-            if (zcu.getTarget().cpu.arch.isSpirV()) return true;
+            if (zcu.getTarget().cpu.arch.isSpirv()) return true;
             return position == .param_ty or position == .ret_ty;
         },
 
diff --git a/src/Zcu.zig b/src/Zcu.zig
index fdae0d840a69e6bc19ebddb32788b1598fef9865..d8a0fb55e2fbc5b99f8c116c87119ad8cf27be9e 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4101,7 +4101,7 @@ pub fn errorSetBits(zcu: *const Zcu) u16 {
     const target = zcu.getTarget();
 
     if (zcu.error_limit == 0) return 0;
-    if (target.cpu.arch.isSpirV()) {
+    if (target.cpu.arch.isSpirv()) {
         // As expected by https://github.com/Snektron/zig-spirv-test-executor
         if (zcu.comp.config.is_test) return 32;
     }
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 279979085b12c4da65da09f2868676ca567af7e0..efca31772815c007e1f32c4e12b4ce44cd8a1b8f 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -455,6 +455,7 @@ pub const Object = struct {
 
                 switch (comp.config.debug_format) {
                     .strip => unreachable,
+                    .nsdi => {},
                     .dwarf => |f| {
                         module_flags.appendAssumeCapacity(try o.builder.metadataTuple(&.{
                             behavior_max,
@@ -994,6 +995,13 @@ pub const Object = struct {
         }
 
         try fg.wip.finish();
+
+        // We don't use `builtin.test_functions` for running the SPIR-V tests so here is
+        // a workaround to not optimize away test functions from the final module.
+        if (target.cpu.arch.isSpirv() and zcu.test_functions.contains(func.owner_nav)) {
+            try o.used.append(gpa, llvm_function.ptrConst(&o.builder).global.toConst());
+        }
+
         try o.flushTypePool(pt);
     }
 
@@ -1002,6 +1010,7 @@ pub const Object = struct {
         const ip = &zcu.intern_pool;
         const comp = zcu.comp;
         const gpa = comp.gpa;
+        const arch = comp.root_mod.resolved_target.result.cpu.arch;
 
         const nav = ip.getNav(nav_id);
         const resolved = nav.resolved.?;
@@ -1011,6 +1020,19 @@ pub const Object = struct {
             else => null,
         };
         const nav_ty: Type = .fromInterned(resolved.type);
+
+        // Workaround for SPIR-V not supporting references to global constants.
+        // Our choices here are only between bad (defaulting constant globals
+        // address space to .private) and ugly (this). I went with ugly since
+        // it's scoped and doesn't break anything for other targets.
+        if (arch.isSpirv() and resolved.@"const" and opt_extern == null and nav_ty.zigTypeTag(zcu) != .@"fn") {
+            if (o.nav_map.get(nav_id)) |llvm_global| {
+                const llvm_ref = try o.lowerNavRef(nav_id);
+                try llvm_global.replace(llvm_ref.unwrap().global, &o.builder);
+            }
+            return;
+        }
+
         const llvm_ty: Builder.Type = if (opt_extern != null) ty: {
             // We *must* lower this declaration no matter what. If it has a type we can't actually
             // represent (because it doesn't have runtime bits), we instead lower as the zero-size
@@ -1461,6 +1483,7 @@ pub const Object = struct {
             .undefined,
             .null,
             .enum_literal,
+            .spirv,
             => return o.builder.debugSignedType(name, 0),
 
             .float => return o.builder.debugFloatType(name, ty.floatBits(target)),
@@ -1822,7 +1845,13 @@ pub const Object = struct {
                         while (it.next()) |field_index| {
                             const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
                             if (!field_ty.hasRuntimeBits(zcu)) continue;
-                            const field_size = field_ty.abiSize(zcu);
+                            const field_size = field_size: {
+                                if (field_ty.isSpirvRuntimeArray(zcu)) {
+                                    assert(field_index == it.fields_len - 1);
+                                    break :field_size 0;
+                                }
+                                break :field_size field_ty.abiSize(zcu);
+                            };
                             const field_align = switch (ty.explicitFieldAlignment(field_index, zcu)) {
                                 .none => field_ty.abiAlignment(zcu),
                                 else => |a| a,
@@ -2097,7 +2126,6 @@ pub const Object = struct {
             },
             .frame => @panic("TODO implement lowerDebugType for Frame types"),
             .@"anyframe" => @panic("TODO implement lowerDebugType for AnyFrame types"),
-            .spirv => unreachable,
         }
     }
 
@@ -2855,7 +2883,8 @@ pub const Object = struct {
 
                     if (o.type_map.get(t.toIntern())) |value| return value;
 
-                    assert(struct_type.size > 0);
+                    // @SpirvType() can create opaque types which are zero-sized but cannot be ignored here.
+                    assert(struct_type.size > 0 or target.cpu.arch.isSpirv());
 
                     var llvm_field_types: std.ArrayList(Builder.Type) = .empty;
                     defer llvm_field_types.deinit(o.gpa);
@@ -2890,7 +2919,11 @@ pub const Object = struct {
 
                         try llvm_field_types.append(o.gpa, try o.lowerType(field_ty, repr));
 
-                        offset += field_ty.abiSize(zcu);
+                        if (field_ty.isSpirvRuntimeArray(zcu)) {
+                            assert(field_index == it.fields_len - 1);
+                        } else {
+                            offset += field_ty.abiSize(zcu);
+                        }
                     }
                     {
                         const prev_offset = offset;
@@ -3032,7 +3065,8 @@ pub const Object = struct {
                     );
                     return ty;
                 },
-                .opaque_type, .spirv_type => unreachable, // no runtime bits
+                .opaque_type => unreachable,
+                .spirv_type => try o.lowerSpirvType(t),
                 .enum_type => try o.intType(t.backingIntType(zcu).intInfo(zcu).bits, repr),
                 .func_type => |func_type| {
                     assert(t.fnHasRuntimeBits(zcu));
@@ -3063,6 +3097,74 @@ pub const Object = struct {
         };
     }
 
+    fn lowerSpirvType(o: *Object, t: Type) Allocator.Error!Builder.Type {
+        const zcu = o.zcu;
+        const ip = &zcu.intern_pool;
+        const os_tag = zcu.comp.root_mod.resolved_target.result.os.tag;
+
+        const spirv_ty = ip.loadSpirvType(t.toIntern());
+        switch (spirv_ty.flags.tag) {
+            .sampler => return o.builder.targetType(try o.builder.string("spirv.Sampler"), &.{}, &.{}),
+            .image, .sampled_image => {
+                const image_ty = if (spirv_ty.flags.tag == .image) spirv_ty else ip.loadSpirvType(spirv_ty.ty);
+                const sampled_ty = sampled_ty: {
+                    if (image_ty.ty == .void_type) break :sampled_ty .void;
+                    break :sampled_ty try o.lowerType(.fromInterned(image_ty.ty), .in_memory);
+                };
+                const image_flags = image_ty.flags;
+                const ints = [_]u32{
+                    switch (image_flags.dim) {
+                        .@"1d" => 0,
+                        .@"2d" => 1,
+                        .@"3d" => 2,
+                        .cube => 3,
+                    },
+                    switch (image_flags.depth) {
+                        .not_depth => 0,
+                        .depth => 1,
+                        .unknown => 2,
+                    },
+                    @intFromBool(image_flags.is_arrayed),
+                    @intFromBool(image_flags.is_multisampled),
+                    switch (image_flags.usage) {
+                        .unknown => 0,
+                        .sampled => 1,
+                        .storage => 2,
+                    },
+                    switch (image_flags.format) {
+                        .unknown => 0,
+                        .rgba32f => 1,
+                        .rgba16f => 2,
+                        .r32f => 3,
+                        .rgba8unorm => 4,
+                        .rgba8snorm => 5,
+                        .rgba32i => 21,
+                        .rgba16i => 22,
+                        .rgba8i => 23,
+                        .r32i => 24,
+                        .rgba32u => 30,
+                        .rgba16u => 31,
+                        .rgba8u => 32,
+                        .r32u => 33,
+                    },
+                    switch (image_flags.access) {
+                        .unknown => 0,
+                        .read_only => 0,
+                        .write_only => 1,
+                        .read_write => 2,
+                    },
+                };
+                const name = if (spirv_ty.flags.tag == .image) "spirv.Image" else "spirv.SampledImage";
+                const ints_len: usize = if (os_tag == .opencl) 7 else 6;
+                return o.builder.targetType(try o.builder.string(name), &.{sampled_ty}, ints[0..ints_len]);
+            },
+            .runtime_array => {
+                const elem_ty = try o.lowerType(.fromInterned(spirv_ty.ty), .in_memory);
+                return o.builder.arrayType(0, elem_ty);
+            },
+        }
+    }
+
     pub const FuncInfo = struct {
         cc: std.lang.CallingConvention,
         noalias_bits: u32 = 0,
@@ -3890,6 +3992,7 @@ pub const Object = struct {
         const zcu = o.zcu;
         const ip = &zcu.intern_pool;
         const gpa = zcu.comp.gpa;
+        const target = &zcu.comp.root_mod.resolved_target.result;
 
         const nav = ip.getNav(nav_id);
         const nav_ty: Type = .fromInterned(nav.resolved.?.type);
@@ -3901,6 +4004,17 @@ pub const Object = struct {
             return o.lowerPtrToVoid(nav_align.toLlvm(), nav.resolved.?.@"addrspace");
         }
 
+        // Workaround for SPIR-V not supporting references to global constants.
+        if (target.cpu.arch.isSpirv() and nav.resolved.?.@"const" and nav.getExtern(ip) == null and
+            nav_ty.zigTypeTag(zcu) != .@"fn" and nav.resolved.?.value != .none)
+        {
+            const nav_align = switch (nav.resolved.?.@"align") {
+                .none => nav_ty.abiAlignment(zcu),
+                else => |a| a,
+            };
+            return o.lowerUavRef(nav.resolved.?.value, nav_align.toLlvm(), nav.resolved.?.@"addrspace");
+        }
+
         const gop = try o.nav_map.getOrPut(gpa, nav_id);
         if (!gop.found_existing) {
             errdefer assert(o.nav_map.remove(nav_id));
@@ -3917,7 +4031,7 @@ pub const Object = struct {
         // We need to make sure the global's address space is up to date, because that affects the
         // type of a pointer to this global. But everything else about the global will be populated
         // by `updateNav` or `updateFunc`.
-        llvm_global.ptr(&o.builder).addr_space = toLlvmAddressSpace(nav.resolved.?.@"addrspace", zcu.getTarget());
+        llvm_global.ptr(&o.builder).addr_space = toLlvmAddressSpace(nav.resolved.?.@"addrspace", target);
         return llvm_global.toConst();
     }
 
@@ -4445,6 +4559,19 @@ pub fn toLlvmAddressSpace(address_space: std.lang.AddressSpace, target: *const s
             .local => Builder.AddrSpace.nvptx.local,
             else => unreachable,
         },
+        .spirv32, .spirv64 => switch (address_space) {
+            .generic, .local => Builder.AddrSpace.spirv.function,
+            .global => Builder.AddrSpace.spirv.cross_workgroup,
+            .constant => Builder.AddrSpace.spirv.uniform_constant,
+            .shared => Builder.AddrSpace.spirv.workgroup,
+            .private => Builder.AddrSpace.spirv.private,
+            .input => Builder.AddrSpace.spirv.input,
+            .output => Builder.AddrSpace.spirv.output,
+            .storage_buffer => Builder.AddrSpace.spirv.storage_buffer,
+            .uniform => Builder.AddrSpace.spirv.uniform,
+            .push_constant => Builder.AddrSpace.spirv.push_constant,
+            else => unreachable,
+        },
         .x86, .x86_64 => switch (address_space) {
             .generic => .default,
             .gs => Builder.AddrSpace.x86.gs,
diff --git a/src/codegen/llvm/FuncGen.zig b/src/codegen/llvm/FuncGen.zig
index 5c600540872039021fe935d0fc1e524d0b3d3b04..1f78dc4804bbf70a3bc97a4a188f82ff0fdf679f 100644
--- a/src/codegen/llvm/FuncGen.zig
+++ b/src/codegen/llvm/FuncGen.zig
@@ -1780,6 +1780,10 @@ fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index, is_dispatch_loop: bool) Tod
         // * https://github.com/llvm/llvm-project/blob/56905dab7da50bccfcceaeb496b206ff476127e1/llvm/test/MC/WebAssembly/blockaddress.ll
         if (zcu.comp.getTarget().cpu.arch.isWasm()) break :jmp_table null;
 
+        // Workaround for:
+        // * https://github.com/llvm/llvm-project/blob/0cd28174a1f64e5a8df194422ebf46e88cff33ad/llvm/lib/Target/SPIRV/SPIRVStructurizer.cpp#L279
+        if (zcu.comp.getTarget().cpu.arch.isSpirv()) break :jmp_table null;
+
         // On a 64-bit target, 1024 pointers in our jump table is about 8K of pointers. This seems just
         // about acceptable - it won't fill L1d cache on most CPUs.
         const max_table_len = 1024;
diff --git a/src/codegen/spirv/Assembler.zig b/src/codegen/spirv/Assembler.zig
index ec9f608e38675d47a258bb16dada49c6262c70d5..7a928157f2a78c885ef3e94045917b6f78a21e64 100644
--- a/src/codegen/spirv/Assembler.zig
+++ b/src/codegen/spirv/Assembler.zig
@@ -784,21 +784,17 @@ fn parseNumber(ass: *Assembler) !void {
     const result = try ass.resolveRef(ass.inst.operands.items[0].ref_id);
     const result_id = result.resultId();
 
-    const words = cg.module.instructions.items;
-    var offset: usize = 0;
-    while (offset < words.len) {
-        const header: spec.InstructionHeader = @bitCast(words[offset]);
-        const word_count = header.word_count;
-        defer offset += word_count;
-        if (word_count == 0) break;
-        switch (header.opcode) {
-            .OpTypeInt => if (word_count >= 4 and @as(Id, @fromBackingInt(@intCast(words[offset + 1]))) == result_id) {
-                const width: u16 = @intCast(words[offset + 2]);
-                const signedness: std.lang.Signedness = if (words[offset + 3] == 0) .unsigned else .signed;
+    var it = cg.module.iterate();
+    while (it.next()) |instruction| {
+        const words = instruction.words;
+        switch (instruction.opcode) {
+            .OpTypeInt => if (words.len >= 4 and @as(Id, @fromBackingInt(@intCast(words[1]))) == result_id) {
+                const width: u16 = @intCast(words[2]);
+                const signedness: std.lang.Signedness = if (words[3] == 0) .unsigned else .signed;
                 return ass.parseContextDependentInt(signedness, width);
             },
-            .OpTypeFloat => if (word_count >= 3 and @as(Id, @fromBackingInt(@intCast(words[offset + 1]))) == result_id) {
-                const bits = words[offset + 2];
+            .OpTypeFloat => if (words.len >= 3 and @as(Id, @fromBackingInt(@intCast(words[1]))) == result_id) {
+                const bits = words[2];
                 return switch (bits) {
                     16 => ass.parseContextDependentFloat(16),
                     32 => ass.parseContextDependentFloat(32),
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index f8caf7cfd993184d1646303834ca8378497f8e49..7d6ab02462d784d24338909a91d611ee397b471a 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -13,7 +13,6 @@ next_result_id: Word = 1,
 navs: std.array_hash_map.Auto(InternPool.Nav.Index, Id) = .empty,
 externs: std.array_hash_map.Auto(InternPool.Nav.Index, Mir.Extern) = .empty,
 entry_points: std.ArrayList(Mir.EntryPoint) = .empty,
-error_buffer: ?Id = null,
 struct_types: std.array_hash_map.Custom(StructType, Id, StructType.HashContext, true) = .empty,
 /// SPIR-V ids of OpVariables whose pointee is a Block struct
 block_var_ids: std.AutoHashMapUnmanaged(Id, void) = .empty,
@@ -202,9 +201,7 @@ pub fn generate(
     defer cg.deinit();
 
     const return_ty_id = try cg.resolveFnReturnType(.fromInterned(fn_info.return_type));
-    const is_test = zcu.test_functions.contains(nav_index);
     const nav_id = try cg.resolveNav(nav_index);
-    const function_id = if (is_test) cg.allocId() else nav_id;
 
     try cg.args.ensureUnusedCapacity(gpa, fn_info.param_types.len);
     for (fn_info.param_types.get(ip)) |param_ty_index| {
@@ -224,7 +221,7 @@ pub fn generate(
     const fn_ty_id = try cg.functionType(return_ty_id, cg.args.items(.ty));
     try cg.module.emit(gpa, .OpFunction, .{
         .id_result_type = return_ty_id,
-        .id_result = function_id,
+        .id_result = nav_id,
         .function_control = .{},
         .function_type = fn_ty_id,
     });
@@ -236,8 +233,7 @@ pub fn generate(
     }
     try cg.module.append(gpa, cg.prologue);
     try cg.module.append(gpa, cg.body);
-    if (is_test) try cg.generateTestEntryPoint(nav.fqn.toSlice(ip), nav_id, function_id);
-    try cg.debugName(function_id, nav.fqn.toSlice(ip));
+    try cg.debugName(nav_id, nav.fqn.toSlice(ip));
 
     return cg.toOwnedMir();
 }
@@ -816,21 +812,20 @@ pub fn memberDebugName(cg: *CodeGen, target: Id, member: u32, name: []const u8)
 pub fn storageClass(cg: *const CodeGen, as: std.lang.AddressSpace) spec.StorageClass {
     const target = cg.zcu.getTarget();
     return switch (as) {
-        .generic => .function,
         .global => switch (target.os.tag) {
             .opencl, .amdhsa => .cross_workgroup,
-            else => .storage_buffer,
+            else => unreachable,
         },
+        .local, .generic => .function,
         .push_constant => .push_constant,
-        .output => .output,
         .uniform => .uniform,
         .storage_buffer => .storage_buffer,
         .physical_storage_buffer => .physical_storage_buffer,
         .constant => .uniform_constant,
         .shared => .workgroup,
-        .local => .function,
         .private => .private,
         .input => .input,
+        .output => .output,
         .gs,
         .fs,
         .ss,
@@ -1689,14 +1684,14 @@ fn constantPtr(cg: *CodeGen, ptr_val: Value) !Id {
 /// This function emits instructions on every call, and they stay in the module whether or not they
 /// are read, so it should only be called where the resulting type is used: a buffer struct emitted
 /// without `Block` fails validation even when nothing refers to it.
-fn derivedPtrType(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
+fn derivedPtrType(cg: *CodeGen, as: std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
     return cg.ptrType(
-        try cg.pointeeType(@"addrspace", derivation.elem_ty, false),
-        cg.storageClass(@"addrspace"),
+        try cg.pointeeType(as, derivation.elem_ty, false),
+        cg.storageClass(as),
     );
 }
 
-fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
+fn derivePtr(cg: *CodeGen, as: std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
     const gpa = cg.gpa;
     const zcu = cg.zcu;
     const target = zcu.getTarget();
@@ -1704,18 +1699,16 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
     switch (derivation.addr) {
         .comptime_alloc, .comptime_field => unreachable,
         .int => |int| {
-            if (target.os.tag != .opencl) {
-                if (@"addrspace" != .physical_storage_buffer) {
-                    return cg.fail(
-                        "cannot cast integer to pointer with address space '{s}'",
-                        .{@tagName(@"addrspace")},
-                    );
-                }
+            if (target_util.addrSpaceIsLogical(target, as)) {
+                return cg.fail(
+                    "cannot cast integer to pointer with address space '{s}'",
+                    .{@tagName(as)},
+                );
             }
             // TODO: This can probably be an OpSpecConstantOp Bitcast, but
             // that is not implemented by Mesa yet. Therefore, just generate it
             // as a runtime operation.
-            const result_ty_id = try cg.derivedPtrType(@"addrspace", derivation);
+            const result_ty_id = try cg.derivedPtrType(as, derivation);
             const result_ptr_id = cg.allocId();
             const value_id = try cg.constInt(.usize, int);
             try cg.body.emit(gpa, .OpConvertUToPtr, .{
@@ -1735,30 +1728,26 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
 
             if (ip.isFunctionType(nav_ty.toIntern())) {
                 if (is_extern) return try cg.resolveExternFn(nav_index);
-                return try cg.constUndef(try cg.derivedPtrType(@"addrspace", derivation));
+                return try cg.constUndef(try cg.derivedPtrType(as, derivation));
             }
             if (!nav_ty.hasRuntimeBits(zcu) and nav_ty.zigTypeTag(zcu) != .spirv) {
-                return cg.constUndef(try cg.derivedPtrType(@"addrspace", derivation));
+                return cg.constUndef(try cg.derivedPtrType(as, derivation));
             }
             if (!is_extern) {
                 return cg.todo("pointer to constant '{f}'", .{nav.fqn.fmt(ip)});
             }
 
-            const as = nav.resolved.?.@"addrspace";
-            assert(as != .generic);
+            assert(nav.resolved.?.@"addrspace" != .generic);
 
             const var_id = try cg.resolveNav(nav_index);
             if (cg.needsLayout(as, nav_ty)) {
                 try cg.block_var_ids.put(gpa, var_id, {});
             }
-            switch (target.os.tag) {
-                .vulkan, .opengl => return var_id,
-                else => {},
-            }
+            if (target_util.addrSpaceIsLogical(target, as)) return var_id;
 
             const nav_ty_id = try cg.resolveType(nav_ty, .indirect);
             const decl_ptr_ty_id = try cg.ptrType(nav_ty_id, cg.storageClass(as));
-            const result_ty_id = try cg.derivedPtrType(@"addrspace", derivation);
+            const result_ty_id = try cg.derivedPtrType(as, derivation);
             if (decl_ptr_ty_id == result_ty_id) return var_id;
 
             const casted_ptr_id = cg.allocId();
@@ -1780,10 +1769,10 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
             }
 
             if (!uav_ty.hasRuntimeBits(zcu) and uav_ty.zigTypeTag(zcu) != .spirv) {
-                return cg.constUndef(try cg.derivedPtrType(@"addrspace", derivation));
+                return cg.constUndef(try cg.derivedPtrType(as, derivation));
             }
 
-            if (cg.storageClass(@"addrspace") != .function) {
+            if (cg.storageClass(as) != .function) {
                 return cg.todo("pointer to an anonymous constant of type '{f}'", .{uav_ty.fmt(zcu)});
             }
 
@@ -1796,11 +1785,11 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
         .eu_payload => @panic("TODO"),
         .opt_payload => @panic("TODO"),
         .field => |derived| return cg.structFieldPtr(
-            @"addrspace",
-            try cg.derivedPtrType(@"addrspace", derivation),
+            as,
+            try cg.derivedPtrType(as, derivation),
             derivation.elem_ty,
             derived.parent.elem_ty,
-            try cg.derivePtr(@"addrspace", derived.parent.*),
+            try cg.derivePtr(as, derived.parent.*),
             derived.field_index,
         ),
         .elem => |derived| return cg.ptrElemPtr(
@@ -1808,13 +1797,13 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
                 .one => .single_array_ptr,
                 .many => .many_ptr,
             },
-            @"addrspace",
+            as,
             derivation.elem_ty,
-            try cg.derivePtr(@"addrspace", derived.parent.*),
+            try cg.derivePtr(as, derived.parent.*),
             try cg.constInt(.usize, derived.elem_index),
         ),
         .offset_and_cast => |derived| {
-            const parent_ptr_id = try cg.derivePtr(@"addrspace", derived.parent.*);
+            const parent_ptr_id = try cg.derivePtr(as, derived.parent.*);
 
             if (derived.byte_offset == 0) {
                 var depth: u32 = 0;
@@ -1849,13 +1838,13 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
                         const zero = try cg.constInt(.u32, 0);
                         const ids = try cg.id_scratch.addManyAsSlice(gpa, depth);
                         @memset(ids, zero);
-                        return cg.accessChainId(try cg.derivedPtrType(@"addrspace", derivation), parent_ptr_id, ids);
+                        return cg.accessChainId(try cg.derivedPtrType(as, derivation), parent_ptr_id, ids);
                     } else {
                         return parent_ptr_id;
                     }
                 }
-                if (target.os.tag == .opencl) {
-                    const result_ty_id = try cg.derivedPtrType(@"addrspace", derivation);
+                if (!target_util.addrSpaceIsLogical(target, as)) {
+                    const result_ty_id = try cg.derivedPtrType(as, derivation);
                     const result_ptr_id = cg.allocId();
                     try cg.body.emit(gpa, .OpBitcast, .{
                         .id_result_type = result_ty_id,
@@ -3788,149 +3777,6 @@ fn buildWideMul(
 }
 
 /// The SPIR-V backend is not yet advanced enough to support the std testing infrastructure.
-/// In order to be able to run tests, we "temporarily" lower test kernels into separate entry-
-/// points. The test executor will then be able to invoke these to run the tests.
-/// Note that tests are lowered according to std.lang.TestFn, which is `fn () anyerror!void`.
-/// (anyerror!void has the same layout as anyerror).
-/// Each test declaration generates a function like.
-///   %anyerror = OpTypeInt 0 16
-///   %p_invocation_globals_struct_ty = ...
-///   %p_anyerror = OpTypePointer CrossWorkgroup %anyerror
-///   %K = OpTypeFunction %void %p_invocation_globals_struct_ty %p_anyerror
-///
-///   %test = OpFunction %void %K
-///   %p_invocation_globals = OpFunctionParameter p_invocation_globals_struct_ty
-///   %p_err = OpFunctionParameter %p_anyerror
-///   %lbl = OpLabel
-///   %result = OpFunctionCall %anyerror %func %p_invocation_globals
-///   OpStore %p_err %result
-///   OpFunctionEnd
-/// TODO is to also write out the error as a function call parameter, and to somehow fetch
-/// the name of an error in the text executor.
-fn generateTestEntryPoint(
-    cg: *CodeGen,
-    name: []const u8,
-    kernel_id: Id,
-    test_id: Id,
-) !void {
-    const gpa = cg.gpa;
-    const zcu = cg.zcu;
-    const target = cg.zcu.getTarget();
-
-    const anyerror_ty_id = try cg.resolveType(.anyerror, .direct);
-    const ptr_anyerror_ty = try cg.pt.ptrType(.{
-        .child = .anyerror_type,
-        .flags = .{ .address_space = .global },
-    });
-    const ptr_anyerror_ty_id = try cg.resolveType(ptr_anyerror_ty, .direct);
-
-    var section: Section = .empty;
-    defer section.deinit(gpa);
-
-    const p_error_id = cg.allocId();
-    switch (target.os.tag) {
-        .opencl, .amdhsa => {
-            const void_ty_id = try cg.resolveType(.void, .direct);
-            const kernel_proto_ty_id = try cg.functionType(void_ty_id, &.{ptr_anyerror_ty_id});
-
-            try section.emit(gpa, .OpFunction, .{
-                .id_result_type = try cg.resolveType(.void, .direct),
-                .id_result = kernel_id,
-                .function_control = .{},
-                .function_type = kernel_proto_ty_id,
-            });
-
-            try section.emit(gpa, .OpFunctionParameter, .{
-                .id_result_type = ptr_anyerror_ty_id,
-                .id_result = p_error_id,
-            });
-
-            try section.emit(gpa, .OpLabel, .{
-                .id_result = cg.allocId(),
-            });
-        },
-        .vulkan, .opengl => {
-            if (cg.error_buffer == null) {
-                const buffer_struct_ty_id = cg.allocId();
-                try cg.module.emit(gpa, .OpTypeStruct, .{
-                    .id_result = buffer_struct_ty_id,
-                    .id_ref = &.{anyerror_ty_id},
-                });
-                try cg.memberDebugName(buffer_struct_ty_id, 0, "error_out");
-                try cg.decorate(buffer_struct_ty_id, .block);
-                try cg.decorateMember(buffer_struct_ty_id, 0, .{ .offset = .{ .byte_offset = 0 } });
-
-                const ptr_buffer_struct_ty_id = cg.allocId();
-                try cg.module.emit(gpa, .OpTypePointer, .{
-                    .id_result = ptr_buffer_struct_ty_id,
-                    .storage_class = cg.storageClass(.global),
-                    .type = buffer_struct_ty_id,
-                });
-
-                const error_buffer_id = cg.allocId();
-                cg.error_buffer = error_buffer_id;
-                try cg.module.emit(gpa, .OpVariable, .{
-                    .id_result_type = ptr_buffer_struct_ty_id,
-                    .id_result = error_buffer_id,
-                    .storage_class = cg.storageClass(.global),
-                });
-                try cg.decorate(error_buffer_id, .{ .descriptor_set = .{ .descriptor_set = 0 } });
-                try cg.decorate(error_buffer_id, .{ .binding = .{ .binding_point = 0 } });
-            }
-
-            const void_ty_id = try cg.resolveType(.void, .direct);
-            const kernel_proto_ty_id = try cg.functionType(void_ty_id, &.{});
-            try section.emit(gpa, .OpFunction, .{
-                .id_result_type = try cg.resolveType(.void, .direct),
-                .id_result = kernel_id,
-                .function_control = .{},
-                .function_type = kernel_proto_ty_id,
-            });
-            try section.emit(gpa, .OpLabel, .{
-                .id_result = cg.allocId(),
-            });
-
-            const buffer_id = cg.error_buffer.?;
-            const zero_id = try cg.constInt(.u32, 0);
-            try section.emit(gpa, .OpInBoundsAccessChain, .{
-                .id_result_type = ptr_anyerror_ty_id,
-                .id_result = p_error_id,
-                .base = buffer_id,
-                .indexes = &.{zero_id},
-            });
-        },
-        else => unreachable,
-    }
-
-    const error_id = cg.allocId();
-    try section.emit(gpa, .OpFunctionCall, .{
-        .id_result_type = anyerror_ty_id,
-        .id_result = error_id,
-        .function = test_id,
-    });
-    // Note: Convert to direct not required.
-    try section.emit(gpa, .OpStore, .{
-        .pointer = p_error_id,
-        .object = error_id,
-        .memory_access = .{
-            .aligned = .{ .literal_integer = @intCast(Type.abiAlignment(.anyerror, zcu).toByteUnits().?) },
-        },
-    });
-    try section.emit(gpa, .OpReturn, {});
-    try section.emit(gpa, .OpFunctionEnd, {});
-    try cg.module.append(gpa, section);
-
-    // Just generate a quick other name because the intel runtime crashes when the entry-
-    // point name is the same as a different OpName.
-    const test_name = try std.fmt.allocPrint(gpa, "test {s}", .{name});
-    errdefer gpa.free(test_name);
-    try cg.entry_points.append(gpa, .{
-        .id = kernel_id,
-        .name = test_name,
-        .cc = .{ .spirv_kernel = .{ .x = 1, .y = 1, .z = 1 } },
-    });
-}
-
 fn intFromBool(cg: *CodeGen, value: Temporary, result_ty: Type) !Temporary {
     const zero_id = try cg.constInt(result_ty, 0);
     const one_id = try cg.constInt(result_ty, 1);
@@ -5464,6 +5310,7 @@ fn accessChain(
 
 fn ptrAccessChain(
     cg: *CodeGen,
+    as: std.lang.AddressSpace,
     result_ty_id: Id,
     base: Id,
     element: Id,
@@ -5491,8 +5338,7 @@ fn ptrAccessChain(
             });
         },
         .vulkan, .opengl => {
-            assert(target.cpu.has(.spirv, .variable_pointers) or
-                target.cpu.has(.spirv, .variable_pointers_storage_buffer));
+            assert(!target_util.addrSpaceIsLogical(target, as));
             try cg.body.emit(gpa, .OpPtrAccessChain, .{
                 .id_result_type = result_ty_id,
                 .id_result = result_id,
@@ -5513,11 +5359,11 @@ fn ptrAdd(cg: *CodeGen, result_ty: Type, ptr_ty: Type, ptr_id: Id, offset_id: Id
     const result_ty_id = try cg.ptrType(child_ty_id, cg.storageClass(as));
     return switch (ptr_ty.ptrSize(zcu)) {
         .one => cg.accessChainId(result_ty_id, ptr_id, &.{offset_id}),
-        .c, .many => cg.ptrAccessChain(result_ty_id, ptr_id, offset_id, &.{}),
+        .c, .many => cg.ptrAccessChain(as, result_ty_id, ptr_id, offset_id, &.{}),
         .slice => blk: {
             // TODO: This is probably incorrect. A slice should be returned here, though this is what llvm does.
             const slice_ptr_id = try cg.extractField(result_ty, ptr_id, 0);
-            break :blk cg.ptrAccessChain(result_ty_id, slice_ptr_id, offset_id, &.{});
+            break :blk cg.ptrAccessChain(as, result_ty_id, slice_ptr_id, offset_id, &.{});
         },
     };
 }
@@ -5770,8 +5616,8 @@ fn bitCast(
     const target = zcu.getTarget();
 
     if (src_ty.toIntern() == dst_ty.toIntern()) return src_id;
-    if (src_ty.isPtrAtRuntime(zcu) and dst_ty.isPtrAtRuntime(zcu)) switch (target.os.tag) {
-        .vulkan, .opengl => if (src_ty.ptrAddressSpace(zcu) != .physical_storage_buffer) {
+    if (src_ty.isPtrAtRuntime(zcu) and dst_ty.isPtrAtRuntime(zcu)) {
+        if (target_util.addrSpaceIsLogical(target, src_ty.ptrAddressSpace(zcu))) {
             const src_child = src_ty.childType(zcu);
             const dst_child = dst_ty.childType(zcu);
             if (!dst_child.hasRuntimeBits(zcu)) return src_id;
@@ -5797,9 +5643,8 @@ fn bitCast(
             }
             const dst_ty_id = try cg.resolveType(dst_ty, .direct);
             return try cg.accessChain(dst_ty_id, src_id, indices.items);
-        },
-        else => {},
-    };
+        }
+    }
 
     const dst_ty_id = try cg.resolveType(dst_ty, .direct);
     const result_id = blk: {
@@ -5836,13 +5681,11 @@ fn bitCast(
         }
 
         if (src_ty.zigTypeTag(zcu) == .int and dst_ty.isPtrAtRuntime(zcu)) {
-            if (target.os.tag != .opencl) {
-                if (dst_ty.ptrAddressSpace(zcu) != .physical_storage_buffer) {
-                    return cg.fail(
-                        "cannot cast integer to pointer with address space '{s}'",
-                        .{@tagName(dst_ty.ptrAddressSpace(zcu))},
-                    );
-                }
+            if (target_util.addrSpaceIsLogical(target, dst_ty.ptrAddressSpace(zcu))) {
+                return cg.fail(
+                    "cannot cast integer to pointer with address space '{s}'",
+                    .{@tagName(dst_ty.ptrAddressSpace(zcu))},
+                );
             }
 
             const result_id = cg.allocId();
@@ -5869,16 +5712,13 @@ fn bitCast(
             break :blk result_id;
         }
 
-        switch (target.os.tag) {
-            .vulkan, .opengl => {
-                // Logical addressing forbids OpBitcast on pointers. Allocate
-                // the temp with dst_ty so the load reads through a slot of the right type.
-                const dst_ty_indirect_id = try cg.resolveType(dst_ty, .indirect);
-                const tmp_id = try cg.alloc(dst_ty_indirect_id, null);
-                try cg.store(dst_ty, tmp_id, src_id, .{});
-                break :blk try cg.load(dst_ty, tmp_id, .{});
-            },
-            else => {},
+        if (target_util.addrSpaceIsLogical(target, .local)) {
+            // Logical addressing forbids OpBitcast on pointers. Allocate
+            // the temp with dst_ty so the load reads through a slot of the right type.
+            const dst_ty_indirect_id = try cg.resolveType(dst_ty, .indirect);
+            const tmp_id = try cg.alloc(dst_ty_indirect_id, null);
+            try cg.store(dst_ty, tmp_id, src_id, .{});
+            break :blk try cg.load(dst_ty, tmp_id, .{});
         }
 
         const dst_ptr_ty_id = try cg.ptrType(dst_ty_id, .function);
@@ -6463,7 +6303,7 @@ fn airSliceElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const ptr_ty_id = try cg.resolveType(ptr_ty, .direct);
 
     const slice_ptr = try cg.extractField(ptr_ty, slice_id, 0);
-    return try cg.ptrAccessChain(ptr_ty_id, slice_ptr, index_id, &.{});
+    return try cg.ptrAccessChain(ptr_ty.ptrAddressSpace(zcu), ptr_ty_id, slice_ptr, index_id, &.{});
 }
 
 fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
@@ -6479,22 +6319,22 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const ptr_ty_id = try cg.resolveType(ptr_ty, .direct);
 
     const slice_ptr = try cg.extractField(ptr_ty, slice_id, 0);
-    const elem_ptr = try cg.ptrAccessChain(ptr_ty_id, slice_ptr, index_id, &.{});
+    const elem_ptr = try cg.ptrAccessChain(ptr_ty.ptrAddressSpace(zcu), ptr_ty_id, slice_ptr, index_id, &.{});
     return try cg.load(slice_ty.childType(zcu), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(zcu) });
 }
 
 fn ptrElemPtr(
     cg: *CodeGen,
     mode: enum { single_array_ptr, many_ptr },
-    @"addrspace": std.lang.AddressSpace,
+    as: std.lang.AddressSpace,
     elem_ty: Type,
     ptr_id: Id,
     index_id: Id,
 ) !Id {
     // Construct new pointer type for the resulting pointer
     const elem_is_block = cg.block_var_ids.contains(ptr_id);
-    const elem_ty_id = try cg.pointeeType(@"addrspace", elem_ty, elem_is_block);
-    const elem_ptr_ty_id = try cg.ptrType(elem_ty_id, cg.storageClass(@"addrspace"));
+    const elem_ty_id = try cg.pointeeType(as, elem_ty, elem_is_block);
+    const elem_ptr_ty_id = try cg.ptrType(elem_ty_id, cg.storageClass(as));
     switch (mode) {
         .single_array_ptr => {
             // Pointer-to-array. In this case, the resulting pointer is not of the same type
@@ -6503,7 +6343,7 @@ fn ptrElemPtr(
         },
         .many_ptr => {
             // Resulting pointer type is the same as the ptr_ty, so use ptrAccessChain
-            return cg.ptrAccessChain(elem_ptr_ty_id, ptr_id, index_id, &.{});
+            return cg.ptrAccessChain(as, elem_ptr_ty_id, ptr_id, index_id, &.{});
         },
     }
 }
@@ -6821,14 +6661,11 @@ fn airAggFieldVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
                     return try cg.load(field_ty, pl_ptr_id, .{});
                 }
 
-                switch (zcu.getTarget().os.tag) {
-                    .vulkan, .opengl => {
-                        // Logical addressing forbids OpBitcast on pointers. Load the
-                        // payload as its type and bitcast the value instead.
-                        const payload_id = try cg.load(layout.payload_ty, pl_ptr_id, .{});
-                        return try cg.bitCast(field_ty, layout.payload_ty, payload_id);
-                    },
-                    else => {},
+                if (target_util.addrSpaceIsLogical(zcu.getTarget(), .local)) {
+                    // Logical addressing forbids OpBitcast on pointers. Load the
+                    // payload as its type and bitcast the value instead.
+                    const payload_id = try cg.load(layout.payload_ty, pl_ptr_id, .{});
+                    return try cg.bitCast(field_ty, layout.payload_ty, payload_id);
                 }
 
                 const field_ty_id = try cg.resolveType(field_ty, .indirect);
@@ -6871,13 +6708,11 @@ fn airFieldParentPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
         break :base_ptr_int try result.materialize(cg);
     };
 
-    if (target.os.tag != .opencl) {
-        if (field_ptr_ty.ptrAddressSpace(zcu) != .physical_storage_buffer) {
-            return cg.fail(
-                "cannot cast integer to pointer with address space '{s}'",
-                .{@tagName(field_ptr_ty.ptrAddressSpace(zcu))},
-            );
-        }
+    if (target_util.addrSpaceIsLogical(target, field_ptr_ty.ptrAddressSpace(zcu))) {
+        return cg.fail(
+            "cannot cast integer to pointer with address space '{s}'",
+            .{@tagName(field_ptr_ty.ptrAddressSpace(zcu))},
+        );
     }
 
     const base_ptr = cg.allocId();
@@ -6892,7 +6727,7 @@ fn airFieldParentPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
 
 fn structFieldPtr(
     cg: *CodeGen,
-    @"addrspace": std.lang.AddressSpace,
+    as: std.lang.AddressSpace,
     result_ptr_ty_id: Id,
     field_ty: Type,
     object_ty: Type,
@@ -6926,21 +6761,18 @@ fn structFieldPtr(
                     return try cg.constUndef(result_ptr_ty_id);
                 }
 
-                const storage_class = cg.storageClass(@"addrspace");
+                const storage_class = cg.storageClass(as);
                 if (field_ty.toIntern() == layout.payload_ty.toIntern()) {
                     if (object_ty.containerLayout(zcu) == .@"packed") return object_ptr;
                     return try cg.accessChain(result_ptr_ty_id, object_ptr, &.{layout.payload_index});
                 }
 
-                switch (zcu.getTarget().os.tag) {
-                    .vulkan, .opengl => {
-                        // Logical addressing forbids OpBitcast on pointers. If the field
-                        // type is structurally identical to the payload type (dedup will
-                        // unify them) the access chain typed as the field type is valid.
-                        if (object_ty.containerLayout(zcu) == .@"packed") return object_ptr;
-                        return try cg.accessChain(result_ptr_ty_id, object_ptr, &.{layout.payload_index});
-                    },
-                    else => {},
+                if (target_util.addrSpaceIsLogical(zcu.getTarget(), as)) {
+                    // Logical addressing forbids OpBitcast on pointers. If the field
+                    // type is structurally identical to the payload type (dedup will
+                    // unify them) the access chain typed as the field type is valid.
+                    if (object_ty.containerLayout(zcu) == .@"packed") return object_ptr;
+                    return try cg.accessChain(result_ptr_ty_id, object_ptr, &.{layout.payload_index});
                 }
 
                 const layout_payload_ty_id = try cg.resolveType(layout.payload_ty, .indirect);
@@ -7039,18 +6871,13 @@ fn airAlloc(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const ptr_ty = cg.typeOfIndex(inst);
     const child_ty = ptr_ty.childType(zcu);
 
-    switch (target.os.tag) {
-        .vulkan, .opengl => {
-            if (child_ty.zigTypeTag(zcu) == .pointer and !child_ty.isSlice(zcu)) {
-                const as = child_ty.ptrAddressSpace(zcu);
-                if (cg.storageClass(as) == .function) {
-                    const result_id = cg.allocId();
-                    try cg.tracked_allocas.put(cg.gpa, result_id, null);
-                    return result_id;
-                }
-            }
-        },
-        else => {},
+    if (child_ty.zigTypeTag(zcu) == .pointer and !child_ty.isSlice(zcu)) {
+        const as = child_ty.ptrAddressSpace(zcu);
+        if (target_util.addrSpaceIsLogical(target, as) and cg.storageClass(as) == .function) {
+            const result_id = cg.allocId();
+            try cg.tracked_allocas.put(cg.gpa, result_id, null);
+            return result_id;
+        }
     }
 
     const child_ty_id = try cg.resolveType(child_ty, .indirect);
@@ -8790,6 +8617,7 @@ const log = std.log.scoped(.codegen);
 const builtin = @import("builtin");
 const link = @import("../../link.zig");
 const codegen = @import("../../codegen.zig");
+const target_util = @import("../../target.zig");
 const Zcu = @import("../../Zcu.zig");
 const Type = @import("../../Type.zig");
 const Value = @import("../../Value.zig");
diff --git a/src/codegen/spirv/Section.zig b/src/codegen/spirv/Section.zig
index a594d294906e666145743db33a53c7ffc4a0d0eb..83e7faaf1e446f1e7d419482f5d4d043547fd103 100644
--- a/src/codegen/spirv/Section.zig
+++ b/src/codegen/spirv/Section.zig
@@ -14,6 +14,38 @@ ids: std.bit_set.Dynamic,
 
 pub const empty: Section = .{ .instructions = .empty, .ids = .{} };
 
+pub const InstructionIterator = struct {
+    words: []const Word,
+    offset: usize = 0,
+
+    pub const Instruction = struct {
+        opcode: Opcode,
+        words: []const Word,
+        start: usize,
+        end: usize,
+        result_id: Id,
+    };
+
+    pub fn next(it: *InstructionIterator) ?Instruction {
+        if (it.offset >= it.words.len) return null;
+        const start = it.offset;
+        const header: InstructionHeader = @bitCast(it.words[start]);
+        const words = it.words[start..][0..header.word_count];
+        it.offset += words.len;
+        return .{
+            .opcode = header.opcode,
+            .words = words,
+            .start = start,
+            .end = it.offset,
+            .result_id = if (header.opcode.resultIndex()) |i| @fromBackingInt(words[i]) else .none,
+        };
+    }
+};
+
+pub fn iterate(section: *const Section) InstructionIterator {
+    return .{ .words = section.instructions.items };
+}
+
 pub const Error = error{
     OutOfMemory,
     UnknownOpcode,
@@ -31,7 +63,7 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
     const type_widths = try gpa.alloc(u16, id_bound);
     defer gpa.free(type_widths);
     @memset(type_widths, 0);
-    var instruction_sets: std.array_hash_map.Auto(Word, spec.InstructionSet) = .empty;
+    var instruction_sets: std.array_hash_map.Auto(Word, ?spec.InstructionSet) = .empty;
     defer instruction_sets.deinit(gpa);
     var results: std.bit_set.Dynamic = try .initEmpty(gpa, id_bound);
     defer results.deinit(gpa);
@@ -48,18 +80,18 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
             return error.UnknownOpcode;
         const end = offset + len;
         var index = offset + 1;
-        const list: []const spec.Operand = switch (op) {
-            .OpFunction => list: {
+        const list: []const spec.Operand = list: switch (op) {
+            .OpFunction => {
                 if (in_function) return error.NestedFunction;
                 in_function = true;
                 break :list op.operands();
             },
-            .OpFunctionEnd => list: {
+            .OpFunctionEnd => {
                 if (!in_function) return error.InvalidInstruction;
                 in_function = false;
                 break :list op.operands();
             },
-            .OpSpecConstantOp => list: {
+            .OpSpecConstantOp => {
                 const prefix = op.operands()[0..2];
                 index = try section.parseOperands(type_widths, offset, end, prefix, index);
                 if (index >= end) return error.InvalidInstruction;
@@ -68,9 +100,14 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
                 index += 1;
                 break :list inner.operands()[2..];
             },
-            .OpExtInst => list: {
+            .OpExtInst => {
                 if (len < 5) return error.InvalidInstruction;
-                const set = instruction_sets.get(inst[3]) orelse return error.InvalidInstruction;
+                const maybe_set = instruction_sets.get(inst[3]) orelse return error.InvalidInstruction;
+                const set = maybe_set orelse {
+                    const prefix = op.operands()[0..4];
+                    index = try section.parseOperands(type_widths, offset, end, prefix, index);
+                    break :list &.{.{ .kind = .id_ref, .quantifier = .variadic }};
+                };
                 const prefix = op.operands()[0..4];
                 index = try section.parseOperands(type_widths, offset, end, prefix, index);
                 break :list set.operands(inst[4]) orelse return error.InvalidInstruction;
@@ -93,6 +130,8 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
                 const set_name = std.mem.sliceTo(std.mem.sliceAsBytes(inst[2..]), 0);
                 if (std.meta.stringToEnum(spec.InstructionSet, set_name)) |set| {
                     if (set != .core) try instruction_sets.put(gpa, inst[1], set);
+                } else if (std.mem.startsWith(u8, set_name, "NonSemantic.")) {
+                    try instruction_sets.put(gpa, inst[1], null);
                 }
             },
             else => if (op.resultIndex() == 2) {
diff --git a/src/codegen/spirv/spec.zig b/src/codegen/spirv/spec.zig
index b45e3a2e73ec2809c9de1027b0d98c2bb56eeb30..2a6a90d444aad80af0f3214e8c41a9f7c25eb3ac 100644
--- a/src/codegen/spirv/spec.zig
+++ b/src/codegen/spirv/spec.zig
@@ -190,6 +190,13 @@ pub const OperandKind = enum {
     pair_id_ref_literal_integer,
     pair_id_ref_id_ref,
     tensor_operands,
+    non_semantic_shader_debug_info_100_debug_info_flags,
+    non_semantic_shader_debug_info_100_build_identifier_flags,
+    non_semantic_shader_debug_info_100_debug_base_type_attribute_encoding,
+    non_semantic_shader_debug_info_100_debug_composite_type,
+    non_semantic_shader_debug_info_100_debug_type_qualifier,
+    non_semantic_shader_debug_info_100_debug_operation,
+    non_semantic_shader_debug_info_100_debug_imported_entity,
 
     pub fn category(operand_kind: OperandKind) OperandCategory {
         return switch (operand_kind) {
@@ -265,6 +272,13 @@ pub const OperandKind = enum {
             .pair_id_ref_literal_integer => .composite,
             .pair_id_ref_id_ref => .composite,
             .tensor_operands => .bit_enum,
+            .non_semantic_shader_debug_info_100_debug_info_flags => .bit_enum,
+            .non_semantic_shader_debug_info_100_build_identifier_flags => .bit_enum,
+            .non_semantic_shader_debug_info_100_debug_base_type_attribute_encoding => .value_enum,
+            .non_semantic_shader_debug_info_100_debug_composite_type => .value_enum,
+            .non_semantic_shader_debug_info_100_debug_type_qualifier => .value_enum,
+            .non_semantic_shader_debug_info_100_debug_operation => .value_enum,
+            .non_semantic_shader_debug_info_100_debug_imported_entity => .value_enum,
         };
     }
     pub fn enumerants(operand_kind: OperandKind) []const Enumerant {
@@ -1112,6 +1126,67 @@ pub const OperandKind = enum {
             .pair_id_ref_literal_integer => unreachable,
             .pair_id_ref_id_ref => unreachable,
             .tensor_operands => &.{},
+            .non_semantic_shader_debug_info_100_debug_info_flags => &.{
+                .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &.{} },
+                .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &.{} },
+                .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &.{} },
+                .{ .name = "FlagIsLocal", .value = 0x04, .parameters = &.{} },
+                .{ .name = "FlagIsDefinition", .value = 0x08, .parameters = &.{} },
+                .{ .name = "FlagFwdDecl", .value = 0x10, .parameters = &.{} },
+                .{ .name = "FlagArtificial", .value = 0x20, .parameters = &.{} },
+                .{ .name = "FlagExplicit", .value = 0x40, .parameters = &.{} },
+                .{ .name = "FlagPrototyped", .value = 0x80, .parameters = &.{} },
+                .{ .name = "FlagObjectPointer", .value = 0x100, .parameters = &.{} },
+                .{ .name = "FlagStaticMember", .value = 0x200, .parameters = &.{} },
+                .{ .name = "FlagIndirectVariable", .value = 0x400, .parameters = &.{} },
+                .{ .name = "FlagLValueReference", .value = 0x800, .parameters = &.{} },
+                .{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &.{} },
+                .{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &.{} },
+                .{ .name = "FlagIsEnumClass", .value = 0x4000, .parameters = &.{} },
+                .{ .name = "FlagTypePassByValue", .value = 0x8000, .parameters = &.{} },
+                .{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &.{} },
+                .{ .name = "FlagUnknownPhysicalLayout", .value = 0x20000, .parameters = &.{} },
+            },
+            .non_semantic_shader_debug_info_100_build_identifier_flags => &.{
+                .{ .name = "IdentifierPossibleDuplicates", .value = 0x01, .parameters = &.{} },
+            },
+            .non_semantic_shader_debug_info_100_debug_base_type_attribute_encoding => &.{
+                .{ .name = "Unspecified", .value = 0, .parameters = &.{} },
+                .{ .name = "Address", .value = 1, .parameters = &.{} },
+                .{ .name = "Boolean", .value = 2, .parameters = &.{} },
+                .{ .name = "Float", .value = 3, .parameters = &.{} },
+                .{ .name = "Signed", .value = 4, .parameters = &.{} },
+                .{ .name = "SignedChar", .value = 5, .parameters = &.{} },
+                .{ .name = "Unsigned", .value = 6, .parameters = &.{} },
+                .{ .name = "UnsignedChar", .value = 7, .parameters = &.{} },
+            },
+            .non_semantic_shader_debug_info_100_debug_composite_type => &.{
+                .{ .name = "Class", .value = 0, .parameters = &.{} },
+                .{ .name = "Structure", .value = 1, .parameters = &.{} },
+                .{ .name = "Union", .value = 2, .parameters = &.{} },
+            },
+            .non_semantic_shader_debug_info_100_debug_type_qualifier => &.{
+                .{ .name = "ConstType", .value = 0, .parameters = &.{} },
+                .{ .name = "VolatileType", .value = 1, .parameters = &.{} },
+                .{ .name = "RestrictType", .value = 2, .parameters = &.{} },
+                .{ .name = "AtomicType", .value = 3, .parameters = &.{} },
+            },
+            .non_semantic_shader_debug_info_100_debug_operation => &.{
+                .{ .name = "Deref", .value = 0, .parameters = &.{} },
+                .{ .name = "Plus", .value = 1, .parameters = &.{} },
+                .{ .name = "Minus", .value = 2, .parameters = &.{} },
+                .{ .name = "PlusUconst", .value = 3, .parameters = &.{.{ .kind = .id_ref }} },
+                .{ .name = "BitPiece", .value = 4, .parameters = &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } } },
+                .{ .name = "Swap", .value = 5, .parameters = &.{} },
+                .{ .name = "Xderef", .value = 6, .parameters = &.{} },
+                .{ .name = "StackValue", .value = 7, .parameters = &.{} },
+                .{ .name = "Constu", .value = 8, .parameters = &.{.{ .kind = .id_ref }} },
+                .{ .name = "Fragment", .value = 9, .parameters = &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } } },
+            },
+            .non_semantic_shader_debug_info_100_debug_imported_entity => &.{
+                .{ .name = "ImportedModule", .value = 0, .parameters = &.{} },
+                .{ .name = "ImportedDeclaration", .value = 1, .parameters = &.{} },
+            },
         };
     }
 
@@ -3256,6 +3331,102 @@ pub const GlslOpcode = enum(u16) {
         };
     }
 };
+
+pub const ShaderDebugInfoOpCode = enum(u16) {
+    DebugInfoNone = 0,
+    DebugCompilationUnit = 1,
+    DebugTypeBasic = 2,
+    DebugTypePointer = 3,
+    DebugTypeQualifier = 4,
+    DebugTypeArray = 5,
+    DebugTypeVector = 6,
+    DebugTypedef = 7,
+    DebugTypeFunction = 8,
+    DebugTypeEnum = 9,
+    DebugTypeComposite = 10,
+    DebugTypeMember = 11,
+    DebugTypeInheritance = 12,
+    DebugTypePtrToMember = 13,
+    DebugTypeTemplate = 14,
+    DebugTypeTemplateParameter = 15,
+    DebugTypeTemplateTemplateParameter = 16,
+    DebugTypeTemplateParameterPack = 17,
+    DebugGlobalVariable = 18,
+    DebugFunctionDeclaration = 19,
+    DebugFunction = 20,
+    DebugLexicalBlock = 21,
+    DebugLexicalBlockDiscriminator = 22,
+    DebugScope = 23,
+    DebugNoScope = 24,
+    DebugInlinedAt = 25,
+    DebugLocalVariable = 26,
+    DebugInlinedVariable = 27,
+    DebugDeclare = 28,
+    DebugValue = 29,
+    DebugOperation = 30,
+    DebugExpression = 31,
+    DebugMacroDef = 32,
+    DebugMacroUndef = 33,
+    DebugImportedEntity = 34,
+    DebugSource = 35,
+    DebugFunctionDefinition = 101,
+    DebugSourceContinued = 102,
+    DebugLine = 103,
+    DebugNoLine = 104,
+    DebugBuildIdentifier = 105,
+    DebugStoragePath = 106,
+    DebugEntryPoint = 107,
+    DebugTypeMatrix = 108,
+
+    pub fn operands(opcode: ShaderDebugInfoOpCode) []const Operand {
+        return switch (opcode) {
+            .DebugInfoNone => &.{},
+            .DebugCompilationUnit => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeBasic => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypePointer => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeQualifier => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeArray => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugTypeVector => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypedef => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeFunction => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugTypeEnum => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .pair_id_ref_id_ref, .quantifier = .variadic } },
+            .DebugTypeComposite => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugTypeMember => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugTypeInheritance => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypePtrToMember => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeTemplate => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugTypeTemplateParameter => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeTemplateTemplateParameter => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeTemplateParameterPack => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugGlobalVariable => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugFunctionDeclaration => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugFunction => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugLexicalBlock => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugLexicalBlockDiscriminator => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugScope => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugNoScope => &.{},
+            .DebugInlinedAt => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugLocalVariable => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugInlinedVariable => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugDeclare => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugValue => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugOperation => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
+            .DebugExpression => &.{.{ .kind = .id_ref, .quantifier = .variadic }},
+            .DebugMacroDef => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugMacroUndef => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugImportedEntity => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugSource => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
+            .DebugFunctionDefinition => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugSourceContinued => &.{.{ .kind = .id_ref }},
+            .DebugLine => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugNoLine => &.{},
+            .DebugBuildIdentifier => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugStoragePath => &.{.{ .kind = .id_ref }},
+            .DebugEntryPoint => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+            .DebugTypeMatrix => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
+        };
+    }
+};
 pub const ImageOperands = packed struct(Word) {
     bias: bool = false,
     lod: bool = false,
@@ -4460,16 +4631,93 @@ pub const ComponentType = enum(u32) {
 pub const TensorOperands = packed struct(Word) {
     _reserved_bits_0_to_31: u32 = 0,
 };
+pub const @"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" = packed struct(Word) {
+    flag_is_protected: bool = false,
+    flag_is_private: bool = false,
+    flag_is_local: bool = false,
+    flag_is_definition: bool = false,
+    flag_fwd_decl: bool = false,
+    flag_artificial: bool = false,
+    flag_explicit: bool = false,
+    flag_prototyped: bool = false,
+    flag_object_pointer: bool = false,
+    flag_static_member: bool = false,
+    flag_indirect_variable: bool = false,
+    flag_l_value_reference: bool = false,
+    flag_r_value_reference: bool = false,
+    flag_is_optimized: bool = false,
+    flag_is_enum_class: bool = false,
+    flag_type_pass_by_value: bool = false,
+    flag_type_pass_by_reference: bool = false,
+    flag_unknown_physical_layout: bool = false,
+    _reserved_bits_18_to_31: u14 = 0,
+};
+pub const @"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" = packed struct(Word) {
+    identifier_possible_duplicates: bool = false,
+    _reserved_bits_1_to_31: u31 = 0,
+};
+pub const @"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) {
+    unspecified = 0,
+    address = 1,
+    boolean = 2,
+    float = 3,
+    signed = 4,
+    signed_char = 5,
+    unsigned = 6,
+    unsigned_char = 7,
+};
+pub const @"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" = enum(u32) {
+    class = 0,
+    structure = 1,
+    @"union" = 2,
+};
+pub const @"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" = enum(u32) {
+    const_type = 0,
+    volatile_type = 1,
+    restrict_type = 2,
+    atomic_type = 3,
+};
+pub const @"NonSemantic.Shader.DebugInfo.100.DebugOperation" = enum(u32) {
+    deref = 0,
+    plus = 1,
+    minus = 2,
+    plus_uconst = 3,
+    bit_piece = 4,
+    swap = 5,
+    xderef = 6,
+    stack_value = 7,
+    constu = 8,
+    fragment = 9,
+
+    pub const Extended = union(@"NonSemantic.Shader.DebugInfo.100.DebugOperation") {
+        deref,
+        plus,
+        minus,
+        plus_uconst: struct { id_ref: Id },
+        bit_piece: struct { id_ref_0: Id, id_ref_1: Id },
+        swap,
+        xderef,
+        stack_value,
+        constu: struct { id_ref: Id },
+        fragment: struct { id_ref_0: Id, id_ref_1: Id },
+    };
+};
+pub const @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" = enum(u32) {
+    imported_module = 0,
+    imported_declaration = 1,
+};
 pub const InstructionSet = enum {
     core,
     @"OpenCL.std",
     @"GLSL.std.450",
+    @"NonSemantic.Shader.DebugInfo.100",
 
     pub fn operands(inst_set: InstructionSet, opcode: Word) ?[]const Operand {
         return switch (inst_set) {
             .core => if (std.enums.fromInt(Opcode, opcode)) |op| op.operands() else null,
             .@"OpenCL.std" => if (std.enums.fromInt(OpenClOpcode, opcode)) |op| op.operands() else null,
             .@"GLSL.std.450" => if (std.enums.fromInt(GlslOpcode, opcode)) |op| op.operands() else null,
+            .@"NonSemantic.Shader.DebugInfo.100" => if (std.enums.fromInt(ShaderDebugInfoOpCode, opcode)) |op| op.operands() else null,
         };
     }
 };
diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig
index 08ba32f95e93d7a5c267137a9323187b7f12924b..ff02d7932fb9036abd576e80b22b9cbd0bd81e76 100644
--- a/src/link/Elf/ZigObject.zig
+++ b/src/link/Elf/ZigObject.zig
@@ -224,7 +224,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
             try dwarf.initMetadata();
             self.dwarf = dwarf;
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
 }
 
diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig
index 699174de84522cfe337fc4b662ac72e65250fc1f..9405cba58dac79010e8c10b37c5c83fac4866378 100644
--- a/src/link/Elf2.zig
+++ b/src/link/Elf2.zig
@@ -5146,7 +5146,7 @@ fn create(
         .dwarf = .init(&elf.base, switch (comp.config.debug_format) {
             .strip => .@"32", // for .eh_frame
             .dwarf => |v| v,
-            .code_view => unreachable,
+            .code_view, .nsdi => unreachable,
         }),
         .dwarf_shared = comptime .initFill(.{
             .first_target_reloc = .none,
@@ -5261,7 +5261,7 @@ fn initHeaders(
     const have_debug_frame = machine == .X86_64 and switch (comp.config.debug_format) {
         .strip => false,
         .dwarf => !comp.config.any_unwind_tables,
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     };
     const addr_align: Alignment = switch (class) {
         .NONE, _ => unreachable,
@@ -5322,7 +5322,7 @@ fn initHeaders(
                 shnum += 1; // .debug_str
                 shnum += 1; // .debug_str_offsets
             },
-            .code_view => unreachable,
+            .code_view, .nsdi => unreachable,
         }
         if (@"type" != .REL) {
             shnum += 1; // .got
@@ -6548,7 +6548,7 @@ fn initHeaders(
                 .node_align = elf.mf.flags.block_size,
             });
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
 
     // If we have an entry point symbol, create the undefined reference now.
@@ -10400,7 +10400,7 @@ fn updateContainerTypeInner(
             try elf.dwarf.const_pool.updateContainerType(pt, .{ .elf2 = elf }, ty, success);
             try elf.dwarf.const_pool.flushPending(pt, .{ .elf2 = elf });
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
     if (!success) return;
     var lazy_it = elf.lazy.iterator();
@@ -10426,7 +10426,7 @@ pub fn addConst(
             try elf.dwarf_consts.ensureUnusedCapacity(gpa, 1);
             try elf.dwarf.addConst(cpi, val, &addConstNode);
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
 }
 fn addConstNode(
@@ -10502,7 +10502,7 @@ fn updateConstInner(
             }
             try elf.genPending(pt);
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
 }
 
@@ -11259,7 +11259,7 @@ fn genPending(elf: *Elf, pt: Zcu.PerThread) link.Error!void {
             elf.resetNodeRelocs(debug_info_ni);
             try elf.dwarf.genDecl(pt, &di_nw, pending.instance);
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
     try elf.genPendingDebug(gpa);
     assert(elf.pending_uavs.items.len == 0); // no UAVs added by lazy code/data or by debug info
diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig
index dd4acfd15ab7be86de4cb2a7bd9f86709ce4a93d..b4ac58529b1b2ef37c659dbc0320144eaa2814fa 100644
--- a/src/link/MachO/ZigObject.zig
+++ b/src/link/MachO/ZigObject.zig
@@ -62,7 +62,7 @@ pub fn init(self: *ZigObject, macho_file: *MachO) !void {
             self.debug_info_header_dirty = true;
             self.debug_line_header_dirty = true;
         },
-        .code_view => unreachable,
+        .code_view, .nsdi => unreachable,
     }
 }
 
diff --git a/src/link/Spirv.zig b/src/link/Spirv.zig
index b40a3ae6e9cf99dabb5f1e7456a5b8b119393e72..3da6d789cb9299cfe6cdb4d68ebf5f8d70a03fdd 100644
--- a/src/link/Spirv.zig
+++ b/src/link/Spirv.zig
@@ -218,11 +218,12 @@ pub fn flush(
         .linker = linker,
         .arena = arena,
         .id_bound = 1,
+        .nonsemantic_info = false,
         .navs = .empty,
         .symbols = .empty,
         .interned = .empty,
         .variables = .empty,
-        .function_references = .empty,
+        .fn_refs = .empty,
         .entry_points = .empty,
         .deps = .empty,
         .scratch = .empty,
diff --git a/src/link/Spirv/Flush.zig b/src/link/Spirv/Flush.zig
index c07873869fafb1415441331758c9552f9d26132f..305a39cc01304a3156f966326c39df43923f8efb 100644
--- a/src/link/Spirv/Flush.zig
+++ b/src/link/Spirv/Flush.zig
@@ -2,6 +2,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const Path = std.Build.Cache.Path;
 const assert = std.debug.assert;
+const stringToEnum = std.meta.stringToEnum;
 const InternPool = @import("../../InternPool.zig");
 const link = @import("../../link.zig");
 const Type = @import("../../Type.zig");
@@ -17,11 +18,12 @@ const Flush = @This();
 linker: *Linker,
 arena: Allocator,
 id_bound: Word,
+nonsemantic_info: bool,
 navs: std.array_hash_map.Auto(InternPool.Nav.Index, Id),
 symbols: std.array_hash_map.String(Symbol),
 interned: std.array_hash_map.String(Id),
 variables: std.array_hash_map.Auto(Id, spec.StorageClass),
-function_references: std.array_hash_map.Auto(Id, []const Id),
+fn_refs: std.array_hash_map.Auto(Id, []const Id),
 entry_points: std.ArrayList(Mir.EntryPoint),
 deps: std.ArrayList(Id),
 scratch: Section,
@@ -42,7 +44,7 @@ const Symbol = struct {
 };
 
 const Annotation = struct {
-    target: Word,
+    target_id: Word,
     class: spec.Class,
     start: usize,
     end: usize,
@@ -193,7 +195,6 @@ pub fn emitModule(flush: *Flush, out: *Section) link.Error!void {
     }) |feature| {
         if (target.cpu.has(.spirv, feature)) version.minor += 1;
     }
-
     const zig_packed_version = (zig_version.major << 12) | (zig_version.minor << 7) | zig_version.patch;
     const header: spec.Header = .{
         .magic = spec.magic_number,
@@ -202,6 +203,7 @@ pub fn emitModule(flush: *Flush, out: *Section) link.Error!void {
         .id_bound = flush.id_bound,
         .schema = 0,
     };
+
     try out.writeWords(gpa, @ptrCast(@alignCast(&header)));
     try flush.emitCapabilities(out);
     try out.writeWords(gpa, flush.extended_instruction_sets.instructions.items);
@@ -224,7 +226,7 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
     const gpa = comp.gpa;
     const arena = flush.arena;
     const diags = &comp.link_diags;
-
+    const target = &comp.root_mod.resolved_target.result;
     const ids = try gpa.alloc(Id, mir.id_bound);
     defer gpa.free(ids);
     ids[0] = .none;
@@ -255,25 +257,22 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
         try imports.put(gpa, @backingInt(ext.id), @intCast(gop.index));
     }
 
-    const words = mir.module.instructions.items;
-    var offset: usize = 0;
-    while (offset < words.len) {
-        const start = offset;
-        const header: spec.InstructionHeader = @bitCast(words[start]);
-        const inst = words[start..][0..header.word_count];
-        offset += inst.len;
+    var it = mir.module.iterate();
+    while (it.next()) |inst| {
+        const opcode = inst.opcode;
+        const words = inst.words;
 
-        if (header.opcode == .OpDecorate) {
-            const target = inst[1];
-            const decoration: spec.Decoration = @fromBackingInt(inst[2]);
+        if (opcode == .OpDecorate) {
+            const target_id = words[1];
+            const decoration: spec.Decoration = @fromBackingInt(words[2]);
             if (decoration == .linkage_attributes) {
-                const parameters = inst[3..];
+                const parameters = words[3..];
                 const name_words = parameters[0 .. parameters.len - 1];
                 const name = std.mem.sliceTo(std.mem.sliceAsBytes(name_words), 0);
                 const linkage: spec.LinkageType = @fromBackingInt(parameters[parameters.len - 1]);
                 const gop = try flush.symbols.getOrPut(arena, name);
                 if (!gop.found_existing) gop.value_ptr.* = .{
-                    .id = ids[target],
+                    .id = ids[target_id],
                     .defined = false,
                     .declaration = &.{},
                 };
@@ -285,130 +284,171 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
                         }
                         gop.value_ptr.defined = true;
                     },
-                    .import => try imports.put(gpa, target, @intCast(gop.index)),
+                    .import => try imports.put(gpa, target_id, @intCast(gop.index)),
                     .link_once_odr => {
                         return diags.failParse(path.?, "unsupported linkage '{t}'", .{linkage});
                     },
                 }
 
-                ids[target] = gop.value_ptr.id;
+                ids[target_id] = gop.value_ptr.id;
                 continue;
             }
         }
 
-        const class = header.opcode.class();
-        const target: Word = switch (header.opcode) {
-            .OpName, .OpMemberName => inst[1],
+        const class = opcode.class();
+        const target_id: Word = switch (opcode) {
+            .OpName, .OpMemberName => words[1],
             .OpDecorationGroup, .OpGroupDecorate, .OpGroupMemberDecorate => {
                 return diags.failParse(path.?, "decoration groups are not supported", .{});
             },
-            else => if (class == .annotation) inst[1] else continue,
+            else => if (class == .annotation) words[1] else continue,
         };
         try annotations.append(gpa, .{
-            .target = target,
+            .target_id = target_id,
             .class = class,
-            .start = start,
-            .end = offset,
+            .start = inst.start,
+            .end = inst.end,
         });
     }
 
+    var result_ids: std.ArrayList(Word) = .empty;
+    defer result_ids.deinit(gpa);
+
     const starts = try gpa.alloc(u32, mir.id_bound + 1);
     defer gpa.free(starts);
     @memset(starts, 0);
 
-    for (annotations.items) |annotation| starts[annotation.target + 1] += 1;
+    for (annotations.items) |annotation| starts[annotation.target_id + 1] += 1;
     for (1..starts.len) |i| starts[i] += starts[i - 1];
 
-    const cursors = try gpa.dupe(u32, starts);
-    defer gpa.free(cursors);
-    const by_target = try gpa.alloc(u32, annotations.items.len);
-    defer gpa.free(by_target);
-    for (annotations.items, 0..) |annotation, i| {
-        by_target[cursors[annotation.target]] = @intCast(i);
-        cursors[annotation.target] += 1;
+    const grouped_indices = try gpa.alloc(u32, annotations.items.len);
+    defer gpa.free(grouped_indices);
+    {
+        const next_slot = try gpa.dupe(u32, starts);
+        defer gpa.free(next_slot);
+        for (annotations.items, 0..) |annotation, i| {
+            grouped_indices[next_slot[annotation.target_id]] = @intCast(i);
+            next_slot[annotation.target_id] += 1;
+        }
     }
 
-    var results: std.ArrayList(Word) = .empty;
-    defer results.deinit(gpa);
-
-    offset = 0;
-    while (offset < words.len) {
-        const start = offset;
-        const header: spec.InstructionHeader = @bitCast(words[start]);
-        const inst = words[start..][0..header.word_count];
-        offset += inst.len;
+    it = mir.module.iterate();
+    while (it.next()) |inst| {
+        const start = inst.start;
+        var end = inst.end;
+        const opcode = inst.opcode;
+        const words = inst.words;
         input.mark += 1;
         flush.deps.clearRetainingCapacity();
 
-        const result_index = header.opcode.resultIndex() orelse {
-            switch (header.opcode) {
-                .OpEntryPoint => {
-                    try input.copy(flush, &flush.object_entry_points, start, offset, null);
-                },
-                .OpExecutionMode, .OpExecutionModeId => {
-                    try input.copy(flush, &flush.object_execution_modes, start, offset, null);
-                },
-                .OpTypeForwardPointer => {
-                    forward_pointers.set(inst[1]);
-                    try input.copy(flush, &flush.globals, start, offset, null);
-                },
-                else => {},
-            }
-            continue;
+        const result_index = opcode.resultIndex() orelse switch (opcode) {
+            .OpCapability => {
+                const capability = std.enums.fromInt(spec.Capability, words[1]) orelse {
+                    return diags.failParse(path.?, "unknown capability '{d}'", .{words[1]});
+                };
+
+                // TODO: this isn't a full validation. we probably have to automate this
+                // based on some generated info from SPIRV-Headers/SPIRV-Registry
+                const allowed = switch (capability) {
+                    .linkage => true,
+                    .shader => target.os.tag == .vulkan or target.os.tag == .opengl,
+                    .kernel, .addresses => target.os.tag == .opencl,
+                    .physical_storage_buffer_addresses => target.os.tag == .vulkan and target.cpu.arch == .spirv64,
+                    else => if (stringToEnum(std.Target.spirv.Feature, @tagName(capability))) |f| target.cpu.has(.spirv, f) else false,
+                };
+                if (!allowed) return diags.failParse(
+                    path.?,
+                    "SPIR-V capability '{t}' is not enabled by the target feature set",
+                    .{capability},
+                );
+                continue;
+            },
+            .OpExtension => {
+                const name = std.mem.sliceTo(std.mem.sliceAsBytes(words[1..]), 0);
+                if (std.mem.eql(u8, name, "SPV_KHR_non_semantic_info")) {
+                    flush.nonsemantic_info = true;
+                    continue;
+                }
+
+                const allowed = allowed: {
+                    if (stringToEnum(std.Target.spirv.Feature, name)) |f| {
+                        break :allowed target.cpu.has(.spirv, f);
+                    }
+                    break :allowed true;
+                };
+                if (!allowed) return diags.failParse(
+                    path.?,
+                    "SPIR-V extension '{s}' is not enabled by the target feature set",
+                    .{name},
+                );
+                continue;
+            },
+            .OpEntryPoint => {
+                try input.copy(flush, &flush.object_entry_points, start, end, null);
+                continue;
+            },
+            .OpExecutionMode, .OpExecutionModeId => {
+                try input.copy(flush, &flush.object_execution_modes, start, end, null);
+                continue;
+            },
+            .OpTypeForwardPointer => {
+                forward_pointers.set(words[1]);
+                try input.copy(flush, &flush.globals, start, end, null);
+                continue;
+            },
+            else => continue,
         };
-        const result = inst[result_index];
-        results.clearRetainingCapacity();
-        try results.append(gpa, result);
+
+        const result_id = words[result_index];
+        result_ids.clearRetainingCapacity();
+        try result_ids.append(gpa, result_id);
 
         var has_body = false;
-        if (header.opcode == .OpFunction) {
-            while (true) {
-                const body: spec.InstructionHeader = @bitCast(words[offset]);
+        if (opcode == .OpFunction) {
+            while (it.next()) |body| {
+                end = body.end;
                 if (body.opcode == .OpLabel) has_body = true;
-                if (body.opcode.resultIndex()) |index| {
-                    try results.append(gpa, words[offset + index]);
-                }
-                offset += body.word_count;
+                if (body.result_id != .none) try result_ids.append(gpa, @backingInt(body.result_id));
                 if (body.opcode == .OpFunctionEnd) break;
             }
         }
 
-        for (results.items) |own| input.marks[own] = input.mark;
+        for (result_ids.items) |own| input.marks[own] = input.mark;
 
-        if (imports.get(result)) |symbol_index| {
+        if (imports.get(result_id)) |symbol_index| {
             flush.scratch.reset();
-            try input.copy(flush, &flush.scratch, start, offset, null);
+            try input.copy(flush, &flush.scratch, start, end, null);
             const declaration = try arena.dupe(Word, flush.scratch.instructions.items);
             flush.symbols.values()[symbol_index].declaration = declaration;
             continue;
         }
 
-        switch (header.opcode) {
+        switch (opcode) {
             .OpFunction => if (!has_body) return diags.failParse(path.?, "function declaration without linkage", .{}),
-            .OpVariable => try flush.variables.put(arena, ids[result], @fromBackingInt(inst[3])),
-            else => if (!forward_pointers.isSet(result)) {
+            .OpVariable => try flush.variables.put(arena, ids[result_id], @fromBackingInt(words[3])),
+            else => if (!forward_pointers.isSet(result_id)) {
                 flush.scratch.reset();
-                try input.copy(flush, &flush.scratch, start, offset, start + result_index);
-                for (by_target[starts[result]..starts[result + 1]]) |index| {
+                try input.copy(flush, &flush.scratch, start, end, start + result_index);
+                for (grouped_indices[starts[result_id]..starts[result_id + 1]]) |index| {
                     const annotation = annotations.items[index];
                     if (annotation.class != .annotation) continue;
-                    const target = annotation.start + 1;
-                    try input.copy(flush, &flush.scratch, annotation.start, annotation.end, target);
+                    const target_id = annotation.start + 1;
+                    try input.copy(flush, &flush.scratch, annotation.start, annotation.end, target_id);
                 }
 
                 const key = std.mem.sliceAsBytes(flush.scratch.instructions.items);
                 const gop = try flush.interned.getOrPut(arena, key);
                 if (gop.found_existing) {
-                    ids[result] = gop.value_ptr.*;
+                    ids[result_id] = gop.value_ptr.*;
                     continue;
                 }
                 gop.key_ptr.* = try arena.dupe(u8, key);
-                gop.value_ptr.* = ids[result];
+                gop.value_ptr.* = ids[result_id];
             },
         }
 
-        for (results.items) |target| {
-            for (by_target[starts[target]..starts[target + 1]]) |index| {
+        for (result_ids.items) |target_id| {
+            for (grouped_indices[starts[target_id]..starts[target_id + 1]]) |index| {
                 const annotation = annotations.items[index];
                 const section = switch (annotation.class) {
                     .debug => &flush.names,
@@ -419,16 +459,16 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
             }
         }
 
-        const section = switch (header.opcode) {
+        const section = switch (opcode) {
             .OpFunction => &flush.functions,
             .OpExtInstImport => &flush.extended_instruction_sets,
             .OpString => &flush.debug_strings,
             else => &flush.globals,
         };
-        try input.copy(flush, section, start, offset, null);
-        if (header.opcode == .OpFunction) {
+        try input.copy(flush, section, start, end, null);
+        if (opcode == .OpFunction) {
             const references = try arena.dupe(Id, flush.deps.items);
-            try flush.function_references.put(arena, ids[result], references);
+            try flush.fn_refs.put(arena, ids[result_id], references);
         }
     }
 
@@ -468,25 +508,26 @@ fn emitCapabilities(flush: *Flush, out: *Section) link.Error!void {
         try out.emit(gpa, .OpCapability, .{ .capability = .linkage });
     }
 
-    inline for (@typeInfo(spec.Capability).@"enum".field_names) |name| {
-        if (@hasField(std.Target.spirv.Feature, name)) {
-            const feature = @field(std.Target.spirv.Feature, name);
-            if (target.cpu.has(.spirv, feature)) {
-                try out.emit(gpa, .OpCapability, .{ .capability = @field(spec.Capability, name) });
-            }
-        }
+    for (std.enums.values(spec.Capability)) |capability| {
+        const feature = stringToEnum(std.Target.spirv.Feature, @tagName(capability)) orelse continue;
+        if (!target.cpu.has(.spirv, feature)) continue;
+        try out.emit(gpa, .OpCapability, .{ .capability = capability });
     }
 
     if (target.cpu.arch == .spirv64 and target.os.tag == .vulkan) {
         try out.emit(gpa, .OpExtension, .{ .name = "SPV_KHR_physical_storage_buffer" });
     }
 
-    inline for (@typeInfo(spec.Extension).@"enum".field_names) |name| {
-        if (comptime std.mem.startsWith(u8, name, "v1_")) continue;
-        if (@hasField(std.Target.spirv.Feature, name)) {
-            const feature = @field(std.Target.spirv.Feature, name);
-            if (target.cpu.has(.spirv, feature)) try out.emit(gpa, .OpExtension, .{ .name = name });
-        }
+    for (std.enums.values(spec.Extension)) |extension| {
+        const name = @tagName(extension);
+        if (std.mem.startsWith(u8, name, "v1_")) continue;
+        const feature = stringToEnum(std.Target.spirv.Feature, name) orelse continue;
+        if (!target.cpu.has(.spirv, feature)) continue;
+        try out.emit(gpa, .OpExtension, .{ .name = name });
+    }
+
+    if (flush.nonsemantic_info) {
+        try out.emit(gpa, .OpExtension, .{ .name = "SPV_KHR_non_semantic_info" });
     }
 }
 
@@ -547,7 +588,7 @@ fn emitEntryPoints(flush: *Flush, out: *Section) link.Error!void {
                 if (storage_class == .function) continue;
                 if (!v1_4 and storage_class != .input and storage_class != .output) continue;
                 try interface.append(arena, id);
-            } else if (flush.function_references.get(id)) |references| {
+            } else if (flush.fn_refs.get(id)) |references| {
                 try pending.appendSlice(arena, references);
             }
         }
diff --git a/src/main.zig b/src/main.zig
index 5e55ccff87620a6c66b61e5a2fc4d1a7256a4f63..af8a66e2ff6a7c808451a8fae23bda787209469f 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -3582,6 +3582,35 @@ fn buildOutputType(
         @import("codegen/llvm/bindings.zig").ParseCommandLineOptions(argv.len, &argv);
     }
 
+    if (build_options.have_llvm and create_module.resolved_options.use_llvm and target.cpu.arch.isSpirv()) {
+        // LLVM has no way to set this non-globally other
+        // than SPIRVTranslate() but it cannot emits assembly.
+        var extensions: std.ArrayList(u8) = .empty;
+        defer extensions.deinit(gpa);
+        try extensions.appendSlice(gpa, "--spirv-ext=");
+
+        var has_extension = false;
+        if (!root_mod.strip) {
+            try extensions.appendSlice(gpa, "+SPV_KHR_non_semantic_info");
+            has_extension = true;
+        }
+
+        for (std.enums.values(std.Target.spirv.Feature)) |feature| {
+            const name = @tagName(feature);
+            if (!mem.startsWith(u8, name, "SPV_")) continue;
+            if (!target.cpu.has(.spirv, feature)) continue;
+            if (mem.eql(u8, name, "SPV_KHR_variable_pointers") and target.cpu.has(.spirv, .v1_3)) continue;
+
+            if (has_extension) try extensions.append(gpa, ',');
+            try extensions.append(gpa, '+');
+            try extensions.appendSlice(gpa, name);
+            has_extension = true;
+        }
+
+        const argv = [_][*:0]const u8{ "zig (LLVM option parsing)", try extensions.toOwnedSliceSentinel(gpa, 0) };
+        @import("codegen/llvm/bindings.zig").ParseCommandLineOptions(argv.len, &argv);
+    }
+
     const clang_passthrough_mode = switch (arg_mode) {
         .cc, .cpp, .translate_c => true,
         else => false,
diff --git a/src/target.zig b/src/target.zig
index 3f6edf8c63673c36abcbbf2b0faf41397df5cfd2..bb46a9135ec2598021853f1c126cf0f94d6e0182 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -310,7 +310,7 @@ pub fn hasNewLinker(ofmt: std.Target.ObjectFormat) bool {
 /// than or equal to the number of behavior tests as the respective LLVM backend.
 pub fn selfHostedBackendIsAsRobustAsLlvm(target: *const std.Target) bool {
     if (comptime builtin.cpu.arch.endian() == .big) return false; // https://github.com/ziglang/zig/issues/25961
-    if (target.cpu.arch.isSpirV()) return true;
+    if (target.cpu.arch.isSpirv()) return true;
     if (target.cpu.arch == .x86_64 and target.ptrBitWidth() == 64) {
         if (target.os.tag == .illumos) {
             // https://github.com/ziglang/zig/issues/25699
@@ -635,38 +635,28 @@ pub fn addrSpaceCastIsValid(
     }
 }
 
-/// Returns whether pointer operations (arithmetic, indexing, etc.) should be blocked
-/// for the given address space on the target architecture.
-///
-/// Under SPIR-V with Vulkan
-/// (a) all physical pointers (.physical_storage_buffer, .global) always support pointer operations,
-/// (b) by default logical pointers (.constant, .input, .output, etc.) never support operations
-/// (c) some logical pointers (.storage_buffer, .shared) do support operations when
-///     the VariablePointers capability is enabled (which enables OpPtrAccessChain).
-pub fn shouldBlockPointerOps(target: *const std.Target, as: AddressSpace) bool {
-    if (target.os.tag != .vulkan and target.os.tag != .opengl) return false;
-
-    return switch (as) {
-        // TODO: Vulkan doesn't support pointers in the generic address space, we
-        // should remove this case but this requires a change in defaultAddressSpace().
-        .generic => true,
-        // For now, all global pointers are represented using StorageBuffer or CrossWorkgroup,
-        // so these are real pointers.
-        // Physical pointers always support operations
-        .global, .physical_storage_buffer => false,
-        // Logical pointers that support operations with VariablePointers capability
-        .shared => !target.cpu.features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)),
-        .storage_buffer => !target.cpu.features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)),
-        // Logical pointers that never support operations
-        .constant,
-        .local,
-        .private,
-        .input,
-        .output,
-        .uniform,
-        .push_constant,
-        => true,
-        else => unreachable,
+/// Returns true if the given address space memory model is logical (i.e. arithmetic pointer
+/// operations are illegal).
+pub fn addrSpaceIsLogical(target: *const std.Target, as: AddressSpace) bool {
+    const features = &target.cpu.features;
+    return switch (target.os.tag) {
+        .vulkan, .opengl => switch (as) {
+            .generic,
+            .constant,
+            .local,
+            .private,
+            .input,
+            .output,
+            .uniform,
+            .push_constant,
+            => true,
+            .shared => !features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)),
+            .storage_buffer => !features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)) and
+                !features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers_storage_buffer)),
+            .physical_storage_buffer => false,
+            else => unreachable,
+        },
+        else => false,
     };
 }
 
diff --git a/test/behavior.zig b/test/behavior.zig
index b64c883d9a6489eeba791ad50254555e4a27214c..5db1e0afdce5da29ebd67b7919600b73582d4b12 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -115,21 +115,21 @@ test {
         _ = @import("behavior/wasm.zig");
     }
 
-    if (builtin.zig_backend == .stage2_spirv) {
+    if (builtin.cpu.arch.isSpirv()) {
         _ = @import("behavior/spirv.zig");
     }
 
-    if (builtin.zig_backend != .stage2_spirv and builtin.os.tag != .wasi) {
+    if (!builtin.cpu.arch.isSpirv() and builtin.os.tag != .wasi) {
         _ = @import("behavior/asm.zig");
     }
 
     if (builtin.zig_backend != .stage2_arm and
-        builtin.zig_backend != .stage2_spirv)
+        !builtin.cpu.arch.isSpirv())
     {
         _ = @import("behavior/export_keyword.zig");
     }
 
-    if (builtin.zig_backend != .stage2_spirv and !builtin.cpu.arch.isWasm()) {
+    if (!builtin.cpu.arch.isSpirv() and !builtin.cpu.arch.isWasm()) {
         // Due to lack of import/export of global support
         // (https://github.com/ziglang/zig/issues/4866), these tests correctly
         // cause linker errors, since a data symbol cannot be exported when
@@ -143,7 +143,7 @@ test {
 // This bug only repros in the root file
 test "dereference @embedFile() of a file full of zero bytes" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const contents = @embedFile("behavior/zero.bin").*;
     try @import("std").testing.expect(contents.len == 456);
diff --git a/test/behavior/abs.zig b/test/behavior/abs.zig
index 9c140d35499fe43c6dfb1b5309e4dbd8bd7263c0..1fea3411f0a2a360e40f81bceaf9f12bfeb15dee 100644
--- a/test/behavior/abs.zig
+++ b/test/behavior/abs.zig
@@ -4,6 +4,7 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 
 test "@abs integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -49,6 +50,7 @@ fn testAbsIntegers() !void {
 }
 
 test "@abs signed C ABI integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -60,7 +62,7 @@ test "@abs signed C ABI integers" {
             try testOne(c_short, c_ushort);
             try testOne(c_int, c_uint);
             try testOne(c_long, c_ulong);
-            if (!builtin.cpu.arch.isSpirV()) try testOne(c_longlong, c_ulonglong);
+            if (!builtin.cpu.arch.isSpirv()) try testOne(c_longlong, c_ulonglong);
         }
         fn testOne(comptime Signed: type, comptime Unsigned: type) !void {
             var negative_one: Signed = undefined;
@@ -76,6 +78,7 @@ test "@abs signed C ABI integers" {
 }
 
 test "@abs unsigned integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -115,6 +118,7 @@ fn testAbsUnsignedIntegers() !void {
 }
 
 test "@abs unsigned C ABI integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -125,7 +129,7 @@ test "@abs unsigned C ABI integers" {
             try testOne(c_ushort);
             try testOne(c_uint);
             try testOne(c_ulong);
-            if (!builtin.cpu.arch.isSpirV()) try testOne(c_ulonglong);
+            if (!builtin.cpu.arch.isSpirv()) try testOne(c_ulonglong);
         }
         fn testOne(comptime Unsigned: type) !void {
             var one: Unsigned = undefined;
@@ -141,6 +145,7 @@ test "@abs unsigned C ABI integers" {
 }
 
 test "@abs big int <= 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest; // TODO
@@ -203,6 +208,7 @@ fn testAbsUnsignedBigInt() !void {
 test "@abs floats" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     try comptime testAbsFloats(f16);
     if (builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f16);
@@ -211,9 +217,9 @@ test "@abs floats" {
     try comptime testAbsFloats(f64);
     try testAbsFloats(f64);
     try comptime testAbsFloats(f80);
-    if (builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
+    if (!builtin.cpu.arch.isSpirv() and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
     try comptime testAbsFloats(f128);
-    if (builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
+    if (!builtin.cpu.arch.isSpirv() and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
 }
 
 fn testAbsFloats(comptime T: type) !void {
@@ -258,7 +264,7 @@ test "@abs int vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try comptime testAbsIntVectors(1);
     try testAbsIntVectors(1);
@@ -324,7 +330,7 @@ test "@abs unsigned int vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try comptime testAbsUnsignedIntVectors(1);
     try testAbsUnsignedIntVectors(1);
@@ -381,7 +387,7 @@ test "@abs float vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     @setEvalBranchQuota(2000);
diff --git a/test/behavior/addrspace_and_linksection.zig b/test/behavior/addrspace_and_linksection.zig
index a340ee4b6e79c55dc75cef12e4255abccccc9fb9..be88ebf4bf765042f95d6c32e0ca30898149f25f 100644
--- a/test/behavior/addrspace_and_linksection.zig
+++ b/test/behavior/addrspace_and_linksection.zig
@@ -12,7 +12,7 @@ const var_linksection = linksections.?[1];
 const fn_linksection = linksections.?[2];
 
 test "addrspace on container-level const" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const a: u32 addrspace(.generic) = 123;
@@ -49,7 +49,7 @@ test "addrspace and linksection on container-level const" {
 }
 
 test "addrspace on container-level var" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var a: u32 addrspace(.generic) = 123;
@@ -83,7 +83,7 @@ test "addrspace and linksection on container-level var" {
 }
 
 test "addrspace on fn" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn f() addrspace(.generic) u32 {
diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 3ef1249e78a49c1abf71d2a42e9c4d130acf4ef3..6850817f1484114ffd406952f01b1103641712d2 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -7,7 +7,7 @@ const assert = std.debug.assert;
 var foo: u8 align(4) = 100;
 
 test "global variable alignment" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     comptime assert(@typeInfo(@TypeOf(&foo)).pointer.attrs.@"align" == 4);
     comptime assert(@TypeOf(&foo) == *align(4) u8);
@@ -18,7 +18,7 @@ test "global variable alignment" {
 }
 
 test "large abi alignment of global" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var global: @This() = undefined;
@@ -30,7 +30,7 @@ test "large abi alignment of global" {
 
 test "large alignment of local constant" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
     if (builtin.zig_backend == .stage2_c and builtin.target.abi == .msvc) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) {
@@ -44,7 +44,7 @@ test "large alignment of local constant" {
 
 test "slicing array of length 1 can not assume runtime index is always zero" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
 
     var runtime_index: usize = 1;
     _ = &runtime_index;
@@ -55,7 +55,7 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const A = *u32;
     const B = *align(@alignOf(u32)) u32;
@@ -89,6 +89,8 @@ test "implicitly-aligned pointer is coercible to equivalent explicitly-aligned p
 }
 
 test "implicitly decreasing pointer alignment" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
     try expect(addUnaligned(&a, &b) == 7);
@@ -240,7 +242,7 @@ test "alignment and size of structs with 128-bit fields" {
 
 test "implicitly decreasing slice alignment" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
     try expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7);
@@ -251,7 +253,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
 
 test "specifying alignment allows pointer cast" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testBytesAlign(0x33);
 }
@@ -264,7 +266,7 @@ fn testBytesAlign(b: u8) !void {
 test "@alignCast slices" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var array align(4) = [_]u32{ 1, 1 };
     const slice = array[0..];
@@ -279,6 +281,7 @@ fn sliceExpects4(slice: []align(4) u32) void {
 }
 
 test "return error union with 128-bit integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -292,7 +295,7 @@ test "page aligned array on stack" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     // Large alignment value to make it hard to accidentally pass.
     var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
     var number1: u8 align(16) = 42;
@@ -310,7 +313,7 @@ test "page aligned array on stack" {
 test "function alignment" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // function alignment greater than 1 is a compile error on wasm
     if (native_arch.isWasm()) return error.SkipZigTest;
@@ -339,7 +342,7 @@ test "function alignment" {
 test "implicitly decreasing fn alignment" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // function alignment greater than 1 is a compile error on wasm
     if (native_arch.isWasm()) return error.SkipZigTest;
@@ -362,7 +365,7 @@ fn alignedBig() align(16) i32 {
 test "@alignCast functions" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // function alignment greater than 1 is a compile error on wasm
     if (native_arch.isWasm()) return error.SkipZigTest;
@@ -381,7 +384,7 @@ fn simple4() align(4) i32 {
 
 test "runtime-known array index has best alignment possible" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // take full advantage of over-alignment
     var array align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
@@ -430,7 +433,7 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
 }
 
 test "alignment of function with c calling convention" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = @alignOf(@TypeOf(nothing));
 
@@ -449,6 +452,7 @@ const DefaultAligned = struct {
 };
 
 test "read 128-bit field from default aligned struct in stack memory" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -467,7 +471,7 @@ var default_aligned_global = DefaultAligned{
 };
 
 test "read 128-bit field from default aligned struct in global memory" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -478,7 +482,7 @@ test "read 128-bit field from default aligned struct in global memory" {
 test "struct field explicit alignment" {
     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; // flaky
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -498,7 +502,7 @@ test "struct field explicit alignment" {
 test "align(N) on functions" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_c) {
         // https://github.com/ziglang/zig/issues/16845
@@ -536,7 +540,7 @@ test "comptime alloc alignment" {
 
 test "@alignCast null" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var ptr: ?*anyopaque = null;
     _ = &ptr;
@@ -552,7 +556,7 @@ test "alignment of slice element" {
 test "sub-aligned pointer field access" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // Originally reported at https://github.com/ziglang/zig/issues/14904
 
@@ -570,7 +574,7 @@ test "sub-aligned pointer field access" {
 }
 
 test "alignment of zero-bit types is respected" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct { arr: [0]usize = .{} };
@@ -602,7 +606,7 @@ test "zero-bit fields in extern struct pad fields appropriately" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = extern struct {
         x: u8,
@@ -626,7 +630,7 @@ test "zero-bit fields in extern struct pad fields appropriately" {
 }
 
 test "function pointer @intFromPtr/@ptrFromInt roundtrip" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // This only succeeds on Thumb if we handle the Thumb bit correctly; if not, the `@ptrFromInt`
     // will incorrectly trip an alignment safety check.
@@ -646,7 +650,7 @@ test "function pointer align mask" {
 }
 
 test "align expression is implicitly comptime" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn alignment() usize {
diff --git a/test/behavior/alignof.zig b/test/behavior/alignof.zig
index f8914ead80b5dc4ee8eed3039e0ad96d7f880961..9d9d54582c81ca514961aa819cf65e274e191fd2 100644
--- a/test/behavior/alignof.zig
+++ b/test/behavior/alignof.zig
@@ -19,6 +19,7 @@ test "@alignOf(T) before referencing T" {
 }
 
 test "comparison of @alignOf(T) against zero" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const T = struct { x: u32 };
     try expect(!(@alignOf(T) == 0));
     try expect(@alignOf(T) != 0);
@@ -29,7 +30,7 @@ test "comparison of @alignOf(T) against zero" {
 }
 
 test "correct alignment for elements and slices of aligned array" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [1024]u8 align(64) = undefined;
     var start: usize = 1;
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 97c595d474b3e06978e372dc47dca9c78d4eb31c..0399ef5ee1c44a63935e85acce22549d26559c90 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -7,7 +7,7 @@ const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
 test "array to slice" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
@@ -21,7 +21,7 @@ test "array to slice" {
 }
 
 test "arrays" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -51,7 +51,7 @@ fn getArrayLen(a: []const u32) usize {
 test "runtime array concat with comptime slice" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     var a: [1]u8 = .{1};
     const b = (comptime @as([]const u8, &.{0})) ++ &a;
     const c = &a ++ (comptime @as([]const u8, &.{0}));
@@ -61,7 +61,7 @@ test "runtime array concat with comptime slice" {
 
 test "array concat with undefined" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -83,7 +83,7 @@ test "array concat with undefined" {
 }
 
 test "array concat with tuple" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -99,7 +99,7 @@ test "array concat with tuple" {
 }
 
 test "array concat with undefined tuple" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     {
         const array: [2]u64 = .{ 1, 2 };
@@ -117,7 +117,7 @@ test "array concat with undefined tuple" {
 }
 
 test "array init with concat" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = 'a';
     var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };
@@ -152,6 +152,7 @@ const ArrayDotLenConstExpr = struct {
 const some_array = [_]u8{ 0, 1, 2, 3 };
 
 test "array literal with specified size" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -162,6 +163,7 @@ test "array literal with specified size" {
 }
 
 test "array len field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var arr = [4]u8{ 0, 0, 0, 0 };
@@ -174,7 +176,7 @@ test "array len field" {
 }
 
 test "array with sentinels" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -211,7 +213,7 @@ test "void arrays" {
 }
 
 test "nested arrays of strings" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -226,6 +228,7 @@ test "nested arrays of strings" {
 }
 
 test "nested arrays of integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const array_of_numbers = [_][2]u8{
@@ -240,6 +243,7 @@ test "nested arrays of integers" {
 }
 
 test "implicit comptime in array type size" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var arr: [plusOne(10)]bool = undefined;
@@ -253,7 +257,7 @@ fn plusOne(x: u32) u32 {
 
 test "single-item pointer to array indexing and slicing" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSingleItemPtrArrayIndexSlice();
     try comptime testSingleItemPtrArrayIndexSlice();
@@ -279,7 +283,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     {
         var b = "".*;
@@ -294,6 +298,7 @@ test "implicit cast zero sized array ptr to slice" {
 }
 
 test "anonymous list literal syntax" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -315,7 +320,7 @@ var s_array: [8]Sub = undefined;
 const Sub = struct { b: u8 };
 const Str = struct { a: []Sub };
 test "set global var array via slice embedded in struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var s = Str{ .a = s_array[0..] };
@@ -330,7 +335,7 @@ test "set global var array via slice embedded in struct" {
 }
 
 test "implicit cast single-item pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testImplicitCastSingleItemPtr();
@@ -359,7 +364,7 @@ test "comptime evaluating function that takes array by value" {
 }
 
 test "runtime initialize array elem and then implicit cast to slice" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var two: i32 = 2;
@@ -369,7 +374,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
 }
 
 test "array literal as argument to function" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -396,7 +401,7 @@ test "array literal as argument to function" {
 }
 
 test "double nested array to const slice cast in array literal" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -457,6 +462,7 @@ test "double nested array to const slice cast in array literal" {
 }
 
 test "anonymous literal in array" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -482,6 +488,7 @@ test "anonymous literal in array" {
 }
 
 test "access the null element of a null terminated array" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -499,6 +506,7 @@ test "access the null element of a null terminated array" {
 }
 
 test "type deduction for array subscript expression" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -517,7 +525,7 @@ test "type deduction for array subscript expression" {
 }
 
 test "sentinel element count towards the ABI size calculation" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -542,7 +550,7 @@ test "sentinel element count towards the ABI size calculation" {
 
 test "type coercion of anon struct literal to array" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -582,7 +590,7 @@ test "array with comptime-only element type" {
 }
 
 test "tuple to array handles sentinel" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -612,7 +620,7 @@ test "array-like to array handles sentinel" {
 }
 
 test "array init of container level array variable" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -635,7 +643,7 @@ test "array init of container level array variable" {
 }
 
 test "runtime initialized sentinel-terminated array literal" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var c: u16 = 300;
     _ = &c;
@@ -646,6 +654,7 @@ test "runtime initialized sentinel-terminated array literal" {
 }
 
 test "array of array agregate init" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -656,7 +665,7 @@ test "array of array agregate init" {
 }
 
 test "pointer to array has ptr field" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(p: *const [5]u32) !void {
@@ -692,6 +701,7 @@ test "discarded array init preserves result location" {
 }
 
 test "array init with no result location has result type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const x = .{ .foo = [2]u16{
         @intCast(10),
         @intCast(20),
@@ -705,7 +715,7 @@ test "array init with no result location has result type" {
 test "slicing array of zero-sized values" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var arr: [32]u0 = undefined;
     for (arr[0..]) |*zero|
@@ -715,6 +725,7 @@ test "slicing array of zero-sized values" {
 }
 
 test "array init with no result pointer sets field result types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         // A function parameter has a result type, but no result pointer.
         fn f(arr: [1]u32) u32 {
@@ -729,7 +740,7 @@ test "array init with no result pointer sets field result types" {
 }
 
 test "runtime side-effects in comptime-known array init" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var side_effects: u4 = 0;
     const init = [4]u4{
@@ -755,7 +766,7 @@ test "runtime side-effects in comptime-known array init" {
 }
 
 test "slice initialized through reference to anonymous array init provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var my_u32: u32 = 123;
     var my_u64: u64 = 456;
@@ -770,7 +781,7 @@ test "slice initialized through reference to anonymous array init provides resul
 }
 
 test "sentinel-terminated slice initialized through reference to anonymous array init provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var my_u32: u32 = 123;
     var my_u64: u64 = 456;
@@ -785,7 +796,7 @@ test "sentinel-terminated slice initialized through reference to anonymous array
 }
 
 test "many-item pointer initialized through reference to anonymous array init provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var my_u32: u32 = 123;
@@ -804,7 +815,7 @@ test "many-item pointer initialized through reference to anonymous array init pr
 }
 
 test "many-item sentinel-terminated pointer initialized through reference to anonymous array init provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var my_u32: u32 = 123;
@@ -824,7 +835,7 @@ test "many-item sentinel-terminated pointer initialized through reference to ano
 }
 
 test "pointer to array initialized through reference to anonymous array init provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var my_u32: u32 = 123;
     var my_u64: u64 = 456;
@@ -839,7 +850,7 @@ test "pointer to array initialized through reference to anonymous array init pro
 }
 
 test "pointer to sentinel-terminated array initialized through reference to anonymous array init provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var my_u32: u32 = 123;
     var my_u64: u64 = 456;
@@ -854,6 +865,7 @@ test "pointer to sentinel-terminated array initialized through reference to anon
 }
 
 test "tuple initialized through reference to anonymous array init provides result types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const Tuple = struct { u64, *const u32 };
     const foo: *const Tuple = &.{
         @intCast(12345),
@@ -864,6 +876,7 @@ test "tuple initialized through reference to anonymous array init provides resul
 }
 
 test "copied array element doesn't alias source" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -878,7 +891,7 @@ test "copied array element doesn't alias source" {
 
 test "array initialized with string literal" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         a: u32,
@@ -898,7 +911,7 @@ test "array initialized with string literal" {
 }
 
 test "array initialized with array with sentinel" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -919,6 +932,7 @@ test "array initialized with array with sentinel" {
 }
 
 test "store array of array of structs at comptime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -944,7 +958,7 @@ test "store array of array of structs at comptime" {
 
 test "accessing multidimensional global array at comptime" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const array = [_][]const []const u8{
@@ -958,6 +972,7 @@ test "accessing multidimensional global array at comptime" {
 }
 
 test "union that needs padding bytes inside an array" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -981,7 +996,7 @@ test "union that needs padding bytes inside an array" {
 }
 
 test "runtime index of array of zero-bit values" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var runtime: struct { array: [1]void, index: usize } = undefined;
     runtime = .{ .array = .{{}}, .index = 0 };
@@ -1035,7 +1050,7 @@ test "initialize pointer to anyopaque with reference to empty array initializer"
 }
 
 test "sentinel of runtime-known array initialization is populated" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var rt: u32 = undefined;
     rt = 42;
@@ -1048,6 +1063,7 @@ test "sentinel of runtime-known array initialization is populated" {
 }
 
 test "resist alias of explicit copy of array passed as arg" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         const Thing = [1]u32;
 
@@ -1069,7 +1085,7 @@ test "resist alias of explicit copy of array passed as arg" {
 }
 
 test "access element through reference" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(x: u8) !void {
diff --git a/test/behavior/asm.zig b/test/behavior/asm.zig
index ac2178044584884d536295a336765e21517c4e6f..9b7a13d948d7914d8ce30d26ac99f65b218ea7d3 100644
--- a/test/behavior/asm.zig
+++ b/test/behavior/asm.zig
@@ -18,7 +18,7 @@ comptime {
             \\.type this_is_my_alias, @function;
             \\.set this_is_my_alias, derp;
         );
-    } else if (builtin.zig_backend == .stage2_spirv) {
+    } else if (builtin.cpu.arch.isSpirv()) {
         asm (
             \\%a = OpString "hello there"
         );
@@ -43,7 +43,7 @@ test "output constraint modifiers" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
@@ -65,7 +65,7 @@ test "alternative constraints" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig
index baae51590e637e312967b6e6bed00a61fcdb2f15..57d114b521df211262f1caf391c49aa1462ea903 100644
--- a/test/behavior/atomics.zig
+++ b/test/behavior/atomics.zig
@@ -14,7 +14,7 @@ test "cmpxchg" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCmpxchg();
     try comptime testCmpxchg();
@@ -41,7 +41,7 @@ test "atomicrmw and atomicload" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var data: u8 = 200;
@@ -70,7 +70,7 @@ test "cmpxchg with ptr" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var data1: i32 = 1234;
@@ -96,7 +96,7 @@ test "cmpxchg with ignored result" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: i32 = 1234;
 
@@ -141,7 +141,7 @@ test "cmpxchg on a global variable" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     _ = @cmpxchgStrong(u32, &a_global_variable, 1234, 42, .acquire, .monotonic);
     try expect(a_global_variable == 42);
@@ -151,7 +151,7 @@ test "atomic load and rmw with enum" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const Value = enum(u8) { a, b, c };
@@ -169,7 +169,7 @@ test "atomic store" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try comptime testAtomicStore();
     try testAtomicStore();
@@ -188,7 +188,7 @@ test "atomicrmw with floats" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     try testAtomicRmwFloat();
@@ -214,7 +214,7 @@ test "atomicrmw with ints" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testAtomicRmwInts();
@@ -357,7 +357,7 @@ test "atomics with different types" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testAtomicsWithType(bool, true, false);
@@ -411,7 +411,7 @@ fn testAtomicsWithPackedStruct(comptime T: type, a: T, b: T) !void {
 test "return @atomicStore, using it as a void value" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const A = struct {
diff --git a/test/behavior/backing_int.zig b/test/behavior/backing_int.zig
index 78602fc3e97308a687dbc001a5252d4ec2c9c205..f842a4a6fcdba59072154f1faf97bb22d3c6ebd4 100644
--- a/test/behavior/backing_int.zig
+++ b/test/behavior/backing_int.zig
@@ -46,6 +46,8 @@ const E5 = enum(u0) {
 };
 
 test "@backingInt with enums" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const static = struct {
         fn doTheTest(v1: E1, v2: E2, v3: E3, v4: E4, v5: E5) !void {
             const b1 = @backingInt(v1);
@@ -74,6 +76,8 @@ test "@backingInt with enums" {
 }
 
 test "@fromBackingInt with enums" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const static = struct {
         fn doTheTest(
             b1: @typeInfo(E1).@"enum".tag_type,
@@ -137,7 +141,7 @@ const T5 = union(E5) {
 };
 
 test "@backingInt with tagged unions" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const static = struct {
         fn doTheTest(v1: T1, v2: T2, v4: T4, v5: T5) !void {
@@ -208,6 +212,8 @@ const S5 = packed struct(u0) {
 };
 
 test "@backingInt with packed structs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const static = struct {
         fn doTheTest(v1: S1, v2: S2, v3: S3, v4: S4, v5: S5) !void {
             const b1 = @backingInt(v1);
@@ -236,6 +242,8 @@ test "@backingInt with packed structs" {
 }
 
 test "@fromBackingInt with packed structs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const static = struct {
         fn doTheTest(
             b1: @typeInfo(S1).@"struct".backing_integer.?,
@@ -313,7 +321,7 @@ const U5 = packed union(u0) {
 };
 
 test "@backingInt with packed unions" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const static = struct {
         fn doTheTest(v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) !void {
@@ -343,7 +351,7 @@ test "@backingInt with packed unions" {
 }
 
 test "@fromBackingInt with packed unions" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const static = struct {
         fn doTheTest(
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index cb81cbd68b23bb706a1c288671185e485080aa6e..ab4e83841337f60ea605e200a5645008db217fdb 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -24,6 +24,7 @@ fn testTruncate(x: u32) u8 {
 }
 
 test "truncate to non-power-of-two integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testTrunc(u32, u1, 0b10101, 0b1);
@@ -38,6 +39,7 @@ test "truncate to non-power-of-two integers" {
 }
 
 test "truncate to non-power-of-two integers from 128-bit" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -60,7 +62,7 @@ const g1: i32 = 1233 + 1;
 var g2: i32 = 0;
 
 test "global variables" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(g2 == 0);
@@ -80,6 +82,8 @@ test "type equality" {
 }
 
 test "pointer dereferencing" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x = @as(i32, 3);
     const y = &x;
 
@@ -137,6 +141,8 @@ test "function branch hints" {
 }
 
 test "if branch hints" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var t: bool = undefined;
     t = true;
     if (t) {
@@ -147,6 +153,8 @@ test "if branch hints" {
 }
 
 test "switch branch hints" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var t: bool = undefined;
     t = true;
     switch (t) {
@@ -160,6 +168,8 @@ test "switch branch hints" {
 }
 
 test "orelse branch hints" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x: ?u32 = undefined;
     x = 123;
     const val = x orelse val: {
@@ -170,6 +180,8 @@ test "orelse branch hints" {
 }
 
 test "catch branch hints" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x: error{Bad}!u32 = undefined;
     x = 123;
     const val = x catch val: {
@@ -180,6 +192,8 @@ test "catch branch hints" {
 }
 
 test "and/or branch hints" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var t: bool = undefined;
     t = true;
     try expect(t or b: {
@@ -207,14 +221,14 @@ fn first4KeysOfHomeRow() []const u8 {
 }
 
 test "return string from function" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
 }
 
 test "hex escape" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
@@ -222,7 +236,7 @@ test "hex escape" {
 
 test "multiline string" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s1 =
         \\one
@@ -235,7 +249,7 @@ test "multiline string" {
 
 test "multiline string comments at start" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s1 =
         //\\one
@@ -248,7 +262,7 @@ test "multiline string comments at start" {
 
 test "multiline string comments at end" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s1 =
         \\one
@@ -261,7 +275,7 @@ test "multiline string comments at end" {
 
 test "multiline string comments in middle" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s1 =
         \\one
@@ -274,7 +288,7 @@ test "multiline string comments in middle" {
 
 test "multiline string comments at multiple places" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s1 =
         \\one
@@ -288,7 +302,7 @@ test "multiline string comments at multiple places" {
 }
 
 test "string concatenation simple" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
 }
@@ -302,6 +316,7 @@ test "compile time global reinterpret" {
 }
 
 test "cast undefined" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const array: [100]u8 = undefined;
@@ -372,7 +387,8 @@ fn fB() []const u8 {
 
 test "call function pointer in struct" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     try expect(mem.eql(u8, f3(true), "a"));
     try expect(mem.eql(u8, f3(false), "b"));
 }
@@ -394,6 +410,7 @@ const FnPtrWrapper = struct {
 };
 
 test "const ptr from var variable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     var x: u64 = undefined;
@@ -412,7 +429,7 @@ fn copy(src: *const u64, dst: *u64) void {
 test "call result of if else expression" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, f2(true), "a"));
     try expect(mem.eql(u8, f2(false), "b"));
@@ -423,7 +440,7 @@ fn f2(x: bool) []const u8 {
 
 const OpaqueA = opaque {};
 test "variable is allowed to be a pointer to an opaque type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: i32 = 1234;
     _ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));
@@ -446,7 +463,7 @@ fn testTakeAddressOfParameter(f: f32) !void {
 }
 
 test "pointer to void return type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testPointerToVoidReturnType();
 }
@@ -462,7 +479,7 @@ fn testPointerToVoidReturnType2() *const void {
 test "array 2D const double ptr" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const rect_2d_vertexes = [_][1]f32{
         [_]f32{1.0},
@@ -474,7 +491,7 @@ test "array 2D const double ptr" {
 test "array 2D const double ptr with offset" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const rect_2d_vertexes = [_][2]f32{
         [_]f32{ 3.0, 4.239 },
@@ -486,7 +503,7 @@ test "array 2D const double ptr with offset" {
 test "array 3D const double ptr with offset" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const rect_3d_vertexes = [_][2][2]f32{
         [_][2]f32{
@@ -519,6 +536,7 @@ fn nine() u8 {
 }
 
 test "struct inside function" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testStructInFn();
@@ -541,7 +559,7 @@ fn testStructInFn() !void {
 
 test "fn call returning scalar optional in equality expression" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(getNull() == null);
 }
@@ -553,7 +571,7 @@ fn getNull() ?*i32 {
 test "global variable assignment with optional unwrapping with var initialized to undefined" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var data: i32 = 1234;
@@ -570,6 +588,7 @@ test "global variable assignment with optional unwrapping with var initialized t
 var global_foo: *i32 = undefined;
 
 test "peer result location with typed parent, runtime condition, comptime prongs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -610,6 +629,8 @@ fn ZA() type {
 }
 
 test "use of declaration with same name as primitive" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const @"u8" = u16;
         const alias = @"u8";
@@ -636,12 +657,14 @@ fn emptyFn() void {}
 
 const addr1 = @as(*const u8, @ptrCast(&emptyFn));
 test "comptime cast fn to ptr" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const addr2 = @as(*const u8, @ptrCast(&emptyFn));
     comptime assert(addr1 == addr2);
 }
 
 test "equality compare fn ptrs" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // Uses function pointers
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Uses function pointers
 
     var a = &emptyFn;
     _ = &a;
@@ -649,7 +672,7 @@ test "equality compare fn ptrs" {
 }
 
 test "self reference through fn ptr field" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const A = struct {
@@ -668,7 +691,7 @@ test "self reference through fn ptr field" {
 
 test "global variable initialized to global variable array element" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(global_ptr == &gdt[0]);
 }
@@ -682,7 +705,7 @@ var gdt = [_]GDTEntry{
 var global_ptr = &gdt[0];
 
 test "global constant is loaded with a runtime-known index" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -701,7 +724,7 @@ test "global constant is loaded with a runtime-known index" {
 }
 
 test "multiline string literal is null terminated" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s1 =
         \\one
@@ -715,7 +738,7 @@ test "multiline string literal is null terminated" {
 test "string escapes" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expectEqualStrings("\"", "\x22");
     try expectEqualStrings("\'", "\x27");
@@ -733,7 +756,7 @@ test "explicit cast optional pointers" {
 }
 
 test "pointer comparison" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = @as([]const u8, "a");
     const b = &a;
@@ -744,6 +767,7 @@ fn ptrEql(a: *const []const u8, b: *const []const u8) bool {
 }
 
 test "string concatenation" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -766,6 +790,7 @@ test "string concatenation" {
 }
 
 test "result location is optional inside error union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -782,7 +807,7 @@ fn maybe(x: bool) anyerror!?u32 {
 
 test "auto created variables have correct alignment" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(str: [*]const u8) u32 {
@@ -799,7 +824,7 @@ test "auto created variables have correct alignment" {
 test "extern variable with non-pointer opaque 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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     @export(&var_to_export, .{ .name = "opaque_extern_var" });
     try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42);
@@ -840,6 +865,7 @@ test "if expression type coercion" {
 }
 
 test "discarding the result of various expressions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -912,6 +938,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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -936,6 +963,7 @@ test "vector initialized with array init syntax has proper type" {
 }
 
 test "weird array and tuple initializations" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1054,6 +1082,7 @@ comptime {
 }
 
 test "switch inside @as gets correct type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: u32 = 0;
@@ -1078,7 +1107,7 @@ test "inline call of function with a switch inside the return statement" {
 }
 
 test "pointer to zero sized global is mutable" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Thing = struct {};
@@ -1100,6 +1129,7 @@ test "returning an opaque type from a function" {
 }
 
 test "orelse coercion as function argument" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const Loc = struct { start: i32 = -1 };
@@ -1118,7 +1148,7 @@ test "orelse coercion as function argument" {
 }
 
 test "runtime-known globals initialized with undefined" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
@@ -1137,7 +1167,7 @@ test "arrays and vectors with big integers" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and (builtin.abi == .gnuabin32 or builtin.abi == .muslabin32 or builtin.abi == .abin32)) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23805
 
@@ -1211,6 +1241,8 @@ fn testUnsignedCmp(comptime T: type) !void {
 }
 
 test "integer compare <= 64 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     inline for (.{ u8, u16, u32, u64, usize, u10, u20, u30, u60 }) |T| {
         try testUnsignedCmp(T);
         try comptime testUnsignedCmp(T);
@@ -1222,6 +1254,7 @@ test "integer compare <= 64 bits" {
 }
 
 test "integer compare <= 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     inline for (.{ u65, u96, u127, u128 }) |T| {
@@ -1235,6 +1268,7 @@ test "integer compare <= 128 bits" {
 }
 
 test "integer compare > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     inline for (.{ u129, u255, u512, u800 }) |T| {
@@ -1248,6 +1282,7 @@ test "integer compare > 128 bits" {
 }
 
 test "reference to inferred local variable works as expected" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const Crasher = struct {
@@ -1332,7 +1367,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct { v: bool };
 
@@ -1355,6 +1390,7 @@ test "copy array of self-referential struct" {
 }
 
 test "break out of block based on comptime known values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1392,7 +1428,7 @@ test "allocation and looping over 3-byte integer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(@sizeOf(u24) == 4);
@@ -1419,6 +1455,8 @@ test "allocation and looping over 3-byte integer" {
 }
 
 test "loading array from struct is not optimized away" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         arr: [1]u32 = .{0},
         fn doTheTest(self: *@This()) !void {
diff --git a/test/behavior/bit_shifting.zig b/test/behavior/bit_shifting.zig
index a9d81b6b53e6d1761e99234200fdcc155e2efa1f..e991dfb4469ad1b5c1d1dbe0997b0d97867b995d 100644
--- a/test/behavior/bit_shifting.zig
+++ b/test/behavior/bit_shifting.zig
@@ -65,7 +65,7 @@ test "sharded table" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // realistic 16-way sharding
     try testShardedTable(u32, 4, 8);
@@ -115,7 +115,7 @@ test "Saturating Shift Left where lhs is of a computed type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -148,7 +148,7 @@ test "Saturating Shift Left where lhs is of a computed type" {
 test "Saturating Shift Left" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 7f2b1e0984c717d2a77f5cfadd6f4ff015135dfc..678aac7581747550e539b87d6f2a0b8d4e224dfa 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -9,6 +9,7 @@ const minInt = std.math.minInt;
 const native_endian = builtin.target.cpu.arch.endian();
 
 test "@bitCast iX -> uX (32, 64)" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const bit_values = [_]usize{ 32, 64 };
@@ -20,6 +21,7 @@ test "@bitCast iX -> uX (32, 64)" {
 }
 
 test "@bitCast iX -> uX (8, 16, 128)" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -32,6 +34,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
 }
 
 test "@bitCast iX -> uX exotic integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -98,7 +101,7 @@ test "bitcast literal [4]u8 param to u32" {
 }
 
 test "bitcast generates a temporary value" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var y: u16 = 0x55AA;
     _ = &y;
@@ -107,6 +110,7 @@ test "bitcast generates a temporary value" {
 }
 
 test "@bitCast packed structs at runtime and comptime" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     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
@@ -134,6 +138,7 @@ test "@bitCast packed structs at runtime and comptime" {
 }
 
 test "bitcast packed struct to integer and back" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     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
@@ -157,6 +162,7 @@ test "bitcast packed struct to integer and back" {
 }
 
 test "implicit cast to error union by returning" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -211,7 +217,7 @@ test "@bitCast packed struct of floats" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Foo = packed struct {
@@ -247,7 +253,7 @@ test "comptime @bitCast packed struct to int 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = packed struct {
@@ -280,7 +286,7 @@ test "comptime @bitCast packed struct to int and back" {
 test "bitcast vector to integer and back" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var vec: @Vector(16, bool) = @splat(true);
@@ -312,6 +318,7 @@ test "bitcast vector to integer and back" {
 }
 
 test "bitcast vector elementwise" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -355,7 +362,7 @@ fn bitCastWrapper128(x: f128) u128 {
 }
 test "bitcast nan float does not modify signaling bit" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
@@ -409,7 +416,7 @@ test "bitcast nan float does not modify signaling bit" {
 test "@bitCast of packed struct of bools all true" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const P = packed struct {
@@ -429,7 +436,7 @@ test "@bitCast of packed struct of bools all true" {
 test "@bitCast of packed struct of bools all false" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     const P = packed struct {
         b0: bool,
@@ -478,7 +485,7 @@ test "@bitCast of packed struct with void field and multiple integers" {
 }
 
 test "@bitCast vector to array with different element size" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const static = struct {
         fn doTheTest(v: @Vector(4, u5)) !void {
@@ -503,7 +510,7 @@ test "@bitCast vector to array with different element size" {
 }
 
 test "@bitCast packed struct to array of bits" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = packed struct(u16) {
         foo: u5,
@@ -551,7 +558,7 @@ test "@bitCast packed struct to array of bits" {
 }
 
 test "@bitCast nested arrays of vectors" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Src = [2][2]@Vector(4, u5);
     const Dest = [5]@Vector(2, u8);
@@ -588,7 +595,7 @@ test "@bitCast nested arrays of vectors" {
 }
 
 test "@bitCast nested arrays of bool to scalar" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const static = struct {
         fn doTheTest(src: [4][4]bool) !void {
@@ -607,7 +614,7 @@ test "@bitCast nested arrays of bool to scalar" {
 }
 
 test "@bitCast deeply nested arrays to scalar" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const static = struct {
         fn doTheTest(src: [2][1][3][5]u4) !void {
diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig
index a71556bee46e74b458844957bce4ed4a8354496c..9d183822126531137e41c50580ead900dec9c0f6 100644
--- a/test/behavior/bitreverse.zig
+++ b/test/behavior/bitreverse.zig
@@ -11,7 +11,7 @@ test "@bitReverse" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime testBitReverse();
@@ -124,7 +124,7 @@ test "bitReverse vectors u8" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector8();
@@ -143,7 +143,7 @@ test "bitReverse vectors u16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector16();
@@ -162,7 +162,7 @@ test "bitReverse vectors u24" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector24();
diff --git a/test/behavior/bool.zig b/test/behavior/bool.zig
index 72c1dff3362afc5960160776841f04a8b22ef2f9..b8b3b6b833d886c59a07b42ef806711f1fb5dc61 100644
--- a/test/behavior/bool.zig
+++ b/test/behavior/bool.zig
@@ -9,6 +9,7 @@ test "bool literals" {
 }
 
 test "cast bool to int" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const t = true;
@@ -48,6 +49,8 @@ test "compile time bool not" {
 }
 
 test "short circuit" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testShortCircuit(false, true);
     try comptime testShortCircuit(false, true);
 }
@@ -92,6 +95,8 @@ fn testShortCircuit(f: bool, t: bool) !void {
 }
 
 test "or with noreturn operand" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn foo(a: u32, b: u32) bool {
             return a == 5 or b == 2 or @panic("oh no");
diff --git a/test/behavior/builtin_functions_returning_void_or_noreturn.zig b/test/behavior/builtin_functions_returning_void_or_noreturn.zig
index 820a920464c77e42b6130b5d96838d7eda7a3d9a..d6bf3a0940ac29c6e2034ccd3f6bfb6bbcf02b03 100644
--- a/test/behavior/builtin_functions_returning_void_or_noreturn.zig
+++ b/test/behavior/builtin_functions_returning_void_or_noreturn.zig
@@ -8,7 +8,7 @@ var x: u8 = 1;
 test {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var val: u8 = undefined;
     try testing.expectEqual({}, @atomicStore(u8, &val, 0, .unordered));
diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig
index 7367587be611caa2c1aa21a5f241e0aa47fb70eb..51b04e7ae0cb33fb7ceb1f3854f22b92d03e3d4e 100644
--- a/test/behavior/byteswap.zig
+++ b/test/behavior/byteswap.zig
@@ -6,7 +6,7 @@ test "@byteSwap integers" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const ByteSwapIntTest = struct {
         fn run() !void {
@@ -41,7 +41,7 @@ test "@byteSwap exotic integers" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const ByteSwapIntTest = struct {
         fn run() !void {
@@ -84,7 +84,7 @@ test "@byteSwap vectors u8" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector8();
@@ -103,7 +103,7 @@ test "@byteSwap vectors u16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector16();
@@ -122,7 +122,7 @@ test "@byteSwap vectors u24" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector24();
diff --git a/test/behavior/byval_arg_var.zig b/test/behavior/byval_arg_var.zig
index 4657b2cfda92692ed2909a261acce9851ff78074..3079d318b1b3319544570e40d1ae0183c81e28ca 100644
--- a/test/behavior/byval_arg_var.zig
+++ b/test/behavior/byval_arg_var.zig
@@ -5,7 +5,7 @@ var result: []const u8 = "wrong";
 
 test "pass string literal byvalue to a generic var param" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     start();
     blowUpStack(10);
diff --git a/test/behavior/call.zig b/test/behavior/call.zig
index b096123a3d3c8af6dfe1b6e994a4f1809724fb2c..02c9cdd8201630bc5f7b85a4592e0a1ea5c9a87e 100644
--- a/test/behavior/call.zig
+++ b/test/behavior/call.zig
@@ -23,7 +23,7 @@ test "basic invocations" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support tail call modifiers
 
@@ -61,7 +61,7 @@ test "basic invocations" {
 test "tuple parameters" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const add = struct {
         fn add(a: i32, b: i32) i32 {
@@ -92,6 +92,7 @@ test "tuple parameters" {
 }
 
 test "result location of function call argument through runtime condition and struct init" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -112,6 +113,7 @@ test "result location of function call argument through runtime condition and st
 }
 
 test "function call with 40 arguments" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -273,7 +275,7 @@ test "forced tail call" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
@@ -308,7 +310,7 @@ test "inline call preserves tail call" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
@@ -341,7 +343,7 @@ test "inline call preserves tail call" {
 
 test "inline call doesn't re-evaluate non generic struct" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(f: struct { a: u8, b: u8 }) !void {
@@ -355,6 +357,8 @@ test "inline call doesn't re-evaluate non generic struct" {
 }
 
 test "Enum constructed by @Enum passed as generic argument" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const E = std.meta.FieldEnum(struct {
             prev_pos: bool,
@@ -407,7 +411,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn inc(a: *u32) void {
@@ -423,6 +427,8 @@ test "inline while with @call" {
 }
 
 test "method call as parameter type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
             return y;
@@ -436,6 +442,7 @@ test "method call as parameter type" {
 }
 
 test "non-anytype generic parameters provide result type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -464,6 +471,7 @@ test "non-anytype generic parameters provide result type" {
 }
 
 test "argument to generic function has correct result type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -491,7 +499,7 @@ test "argument to generic function has correct result type" {
 }
 
 test "call inline fn through pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         inline fn foo(x: u8) !void {
@@ -517,7 +525,7 @@ test "call function in comptime field" {
 test "call function pointer in comptime 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Auto = struct {
         auto: [max_len]u8 = undefined,
@@ -538,7 +546,7 @@ test "call function pointer in comptime field" {
 }
 
 test "generic function pointer can be called" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var ok = false;
@@ -615,7 +623,7 @@ test "call with union with zero sized field is not memorized incorrectly" {
 test "function call with cast to anyopaque pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Foo = struct {
         y: u8,
@@ -633,7 +641,7 @@ test "arguments pointed to on stack into tailcall" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support always tail calls
 
     switch (builtin.cpu.arch) {
@@ -707,7 +715,7 @@ test "tail call function pointer" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
@@ -737,7 +745,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.cpu.arch.isSpirv()) 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 eb252a3d5cea2a895643ddda3643e2b7d598a592..f3d28610c7e4839d753e21b89cbdc7ebd04c9115 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -21,6 +21,7 @@ test "integer literal to pointer cast" {
 }
 
 test "peer type resolution: ?T and T" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -67,6 +68,7 @@ test "implicit cast comptime_int to comptime_float" {
 }
 
 test "comptime_int @floatFromInt" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     {
         const result = @as(f16, @floatFromInt(1234));
         try expect(@TypeOf(result) == f16);
@@ -97,6 +99,7 @@ test "comptime_int @floatFromInt" {
 }
 
 test "@floatFromInt" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -126,7 +129,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
@@ -151,7 +154,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
@@ -174,7 +177,7 @@ test "@floatFromInt > 128 bits" {
 test "@floatFromInt(f80)" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
@@ -212,7 +215,7 @@ test "@floatFromInt(f80)" {
 }
 
 test "type coercion from int to float" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const check = struct {
         // Check that an integer value can be coerced to a float type and
@@ -273,6 +276,7 @@ test "type coercion from int to float" {
 }
 
 test "@intFromFloat" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -299,10 +303,11 @@ fn testIntFromFloats() !void {
 
     try expectRoundCast(f32, -128.2, i8, -128);
     try expectCeilCast(f32, -128.2, i8, -128);
-    try expectTruncCast(f32, -128.2, i8, -128);
 }
 
 test "rounding builtins with anytype and context propagation" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const x: i32 = 10;
         fn check(expected: anytype, actual: anytype) !void {
@@ -338,7 +343,8 @@ fn expectTruncCast(comptime F: type, f: F, comptime I: type, i: I) !void {
 
 test "implicitly cast indirect pointer to maybe-indirect pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         const Self = @This();
         x: u8,
@@ -372,6 +378,8 @@ test "@intCast comptime_int" {
 }
 
 test "@floatCast comptime_int and comptime_float" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     {
         const result = @as(f16, @floatCast(1234));
         try expect(@TypeOf(result) == f16);
@@ -416,7 +424,7 @@ fn MakeType(comptime T: type) type {
 
 test "implicit cast from *[N]T to [*c]T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
     var y: [*c]u16 = &x;
@@ -451,6 +459,7 @@ test "@intCast to u0 and use the result" {
 }
 
 test "peer result null and comptime_int" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -477,7 +486,7 @@ test "peer result null and comptime_int" {
 test "*const ?[*]const T to [*c]const [*c]const T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var array = [_]u8{ 'o', 'k' };
     const opt_array_ptr: ?[*]const u8 = &array;
@@ -489,7 +498,7 @@ test "*const ?[*]const T to [*c]const [*c]const T" {
 
 test "array coercion to undefined at runtime" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     @setRuntimeSafety(true);
 
@@ -516,6 +525,7 @@ fn implicitIntLitToOptional() void {
 }
 
 test "return u8 coercing into ?u32 return type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -537,6 +547,7 @@ test "cast from ?[*]T to ??[*]T" {
 }
 
 test "peer type unsigned int to signed" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var w: u31 = 5;
@@ -550,7 +561,7 @@ test "peer type unsigned int to signed" {
 
 test "expected [*c]const u8, found [*:0]const u8" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [*:0]const u8 = "hello";
     _ = &a;
@@ -562,7 +573,7 @@ test "expected [*c]const u8, found [*:0]const u8" {
 test "explicit cast from integer to error 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testCastIntToErr(error.ItBroke);
@@ -577,7 +588,7 @@ fn testCastIntToErr(err: anyerror) !void {
 test "peer resolve array and const slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testPeerResolveArrayConstSlice(true);
     try comptime testPeerResolveArrayConstSlice(true);
@@ -590,7 +601,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -616,7 +627,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testCastZeroArrayToErrSliceMut();
@@ -634,7 +645,7 @@ fn gimmeErrOrSlice() anyerror![]u8 {
 test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() anyerror!void {
@@ -665,7 +676,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
 
 test "implicit cast from *const [N]T to []const T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCastConstArrayRefToConstSlice();
     try comptime testCastConstArrayRefToConstSlice();
@@ -690,7 +701,7 @@ fn testCastConstArrayRefToConstSlice() !void {
 
 test "peer type resolution: error and [N]T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
     comptime assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
@@ -714,7 +725,7 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
 
 test "single-item pointer of array to slice to unknown length pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCastPtrOfArrayToSliceAndPtr();
     try comptime testCastPtrOfArrayToSliceAndPtr();
@@ -743,7 +754,7 @@ fn testCastPtrOfArrayToSliceAndPtr() !void {
 
 test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const window_name = [1][*]const u8{"window name"};
     const x: [*]const ?[*]const u8 = &window_name;
@@ -755,7 +766,7 @@ test "@intCast on vector" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
 
     const S = struct {
@@ -1027,7 +1038,7 @@ test "peer cast: error set any anyerror" {
 test "peer type resolution: error set supersets" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a: error{ One, Two } = undefined;
     const b: error{One} = undefined;
@@ -1056,7 +1067,7 @@ test "peer type resolution: error set supersets" {
 test "peer type resolution: disjoint error sets" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a: error{ One, Two } = undefined;
     const b: error{Three} = undefined;
@@ -1085,7 +1096,7 @@ test "peer type resolution: disjoint error sets" {
 test "peer type resolution: error union and error set" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a: error{Three} = undefined;
     const b: error{ One, Two }!u32 = undefined;
@@ -1118,7 +1129,7 @@ test "peer type resolution: error union and error set" {
 test "peer type resolution: error union after non-error" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a: u32 = undefined;
     const b: error{ One, Two }!u32 = undefined;
@@ -1151,7 +1162,7 @@ test "peer type resolution: error union after non-error" {
 test "peer cast *[0]T to E![]const T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buffer: [5]u8 = "abcde".*;
     const buf: anyerror![]const u8 = buffer[0..];
@@ -1166,7 +1177,7 @@ test "peer cast *[0]T to E![]const T" {
 test "peer cast *[0]T to []const T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buffer: [5]u8 = "abcde".*;
     const buf: []const u8 = buffer[0..];
@@ -1177,6 +1188,7 @@ test "peer cast *[0]T to []const T" {
 }
 
 test "peer cast *[N]T to [*]T" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var array = [4:99]i32{ 1, 2, 3, 4 };
@@ -1189,7 +1201,7 @@ test "peer cast *[N]T to [*]T" {
 test "peer resolution of string literals" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const E = enum { a, b, c, d };
@@ -1210,7 +1222,7 @@ test "peer resolution of string literals" {
 
 test "peer cast [:x]T to []T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1226,7 +1238,7 @@ test "peer cast [:x]T to []T" {
 
 test "peer cast [N:x]T to [N]T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1242,7 +1254,7 @@ test "peer cast [N:x]T to [N]T" {
 
 test "peer cast *[N:x]T to *[N]T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1258,7 +1270,7 @@ test "peer cast *[N:x]T to *[N]T" {
 test "peer cast [*:x]T to [*]T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1278,7 +1290,7 @@ test "peer cast [*:x]T to [*]T" {
 test "peer cast [:x]T to [*:x]T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1298,7 +1310,7 @@ test "peer cast [:x]T to [*:x]T" {
 
 test "peer type resolution implicit cast to return type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1318,7 +1330,7 @@ test "peer type resolution implicit cast to return type" {
 
 test "peer type resolution implicit cast to variable type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1343,7 +1355,7 @@ test "variable initialization uses result locations properly with regards to the
 
 test "cast between C pointer with different but compatible types" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(arg: [*]c_ushort) u16 {
@@ -1360,7 +1372,7 @@ test "cast between C pointer with different but compatible types" {
 
 test "peer type resolve string lit with sentinel-terminated mutable slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var array: [4:0]u8 = undefined;
     array[4] = 0; // TODO remove this when #4372 is solved
@@ -1370,6 +1382,8 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" {
 }
 
 test "peer type resolve array pointers, one of them const" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var array1: [4]u8 = undefined;
     const array2: [5]u8 = undefined;
     comptime assert(@TypeOf(&array1, &array2) == []const u8);
@@ -1377,6 +1391,8 @@ test "peer type resolve array pointers, one of them const" {
 }
 
 test "peer type resolve array pointer and unknown pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const const_array: [4]u8 = undefined;
     var array: [4]u8 = undefined;
     var const_ptr: [*]const u8 = undefined;
@@ -1397,6 +1413,8 @@ test "peer type resolve array pointer and unknown pointer" {
 }
 
 test "comptime float casts" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const a = @as(comptime_float, @floatFromInt(1));
     try expect(a == 1);
     try expect(@TypeOf(a) == comptime_float);
@@ -1431,7 +1449,7 @@ test "pointer reinterpret const float to int" {
 test "implicit cast from [*]T to ?*anyopaque" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a = [_]u8{ 3, 2, 1 };
     var runtime_zero: usize = 0;
@@ -1448,7 +1466,7 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
 }
 
 test "compile time int to ptr of function" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try foobar(FUNCTION_CONSTANT);
 }
@@ -1463,7 +1481,7 @@ fn foobar(func: PFN_void) !void {
 }
 
 test "cast function with an opaque parameter" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Container = struct {
         const Ctx = opaque {};
@@ -1490,7 +1508,7 @@ test "cast function with an opaque parameter" {
 test "implicit ptr to *anyopaque" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: u32 = 1;
     const ptr: *align(@alignOf(u32)) anyopaque = &a;
@@ -1503,7 +1521,7 @@ test "implicit ptr to *anyopaque" {
 
 test "return null from fn () anyerror!?&T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = returnNullFromOptionalTypeErrorRef();
     const b = returnNullLitFromOptionalTypeErrorRef();
@@ -1520,7 +1538,7 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
 test "peer type resolution: [0]u8 and []const u8" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
     try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
@@ -1540,7 +1558,7 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
 test "implicitly cast from [N]T to ?[]const T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
     comptime assert(mem.eql(u8, castToOptionalSlice().?, "hi"));
@@ -1553,7 +1571,7 @@ fn castToOptionalSlice() ?[]const u8 {
 test "cast u128 to f128 and back" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime testCast128();
@@ -1576,7 +1594,7 @@ test "implicit cast from *[N]T to ?[*]T" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: ?[*]u16 = null;
     var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
@@ -1591,7 +1609,7 @@ test "implicit cast from *[N]T to ?[*]T" {
 test "implicit cast from *T to ?*anyopaque" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: u8 = 1;
     incrementVoidPtrValue(&a);
@@ -1603,7 +1621,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x = @as(anyerror![]const u8, &[0]u8{});
@@ -1613,13 +1631,13 @@ test "implicit cast *[0]T to E![]const u8" {
 
 var global_array: [4]u8 = undefined;
 test "cast from array reference to fn: comptime fn ptr" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const f = @as(*align(1) const fn () callconv(.c) void, @ptrCast(&global_array));
     try expect(@intFromPtr(f) == @intFromPtr(&global_array));
 }
 test "cast from array reference to fn: runtime fn ptr" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var f = @as(*align(1) const fn () callconv(.c) void, @ptrCast(&global_array));
     _ = &f;
@@ -1629,7 +1647,7 @@ test "cast from array reference to fn: runtime fn ptr" {
 test "*const [N]null u8 to ?[]const u8" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1646,7 +1664,7 @@ test "*const [N]null u8 to ?[]const u8" {
 test "comptime @ptrCast to optional slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const result: ?[]const u8 = comptime blk: {
         const slice: []const u8 = "123";
@@ -1679,7 +1697,7 @@ var global_struct: struct { f0: usize } = undefined;
 test "assignment to optional pointer result loc" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
     _ = &foo;
@@ -1687,7 +1705,7 @@ test "assignment to optional pointer result loc" {
 }
 
 test "cast between *[N]void and []void" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [4]void = undefined;
     const b: []void = &a;
@@ -1696,7 +1714,7 @@ test "cast between *[N]void and []void" {
 
 test "peer resolve arrays of different size to const slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, boolToStr(true), "true"));
     try expect(mem.eql(u8, boolToStr(false), "false"));
@@ -1710,7 +1728,7 @@ fn boolToStr(b: bool) []const u8 {
 test "cast f16 to wider 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1729,7 +1747,7 @@ test "cast f16 to wider types" {
 test "cast f128 to narrower 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1748,7 +1766,7 @@ test "cast f128 to narrower types" {
 test "peer type resolution: unreachable, null, slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(num: usize, word: []const u8) !void {
@@ -1787,7 +1805,7 @@ test "cast i8 fn call peers to i32 result" {
 test "cast compatible optional 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: ?[:0]const u8 = null;
     _ = &a;
@@ -1797,7 +1815,7 @@ test "cast compatible optional types" {
 
 test "coerce undefined single-item pointer of array to error union of slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = @as([*]u8, undefined)[0..0];
     var b: error{a}![]const u8 = a;
@@ -1807,7 +1825,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x: []i32 = &.{};
@@ -1818,7 +1836,7 @@ test "pointer to empty struct literal to mutable slice" {
 test "coerce between pointers of compatible differently-named floats" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const F = switch (@typeInfo(c_longdouble).float.bits) {
@@ -1878,6 +1896,8 @@ test "cast typed undefined to int" {
 // }
 
 test "bitcast packed struct with u0" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = packed struct(u2) { a: u0, b: u2 };
     const s = @as(S, @bitCast(@as(u2, 2)));
     try expect(s.a == 0);
@@ -1888,7 +1908,7 @@ test "bitcast packed struct with u0" {
 
 test "optional pointer coerced to optional allowzero pointer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var p: ?*u32 = undefined;
     var q: ?*allowzero u32 = undefined;
@@ -1905,7 +1925,7 @@ test "optional slice coerced to allowzero many pointer" {
 }
 
 test "optional slice passed as parameter coerced to allowzero many pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const ns = struct {
         const Color = struct {
@@ -1926,7 +1946,7 @@ test "optional slice passed as parameter coerced to allowzero many pointer" {
 }
 
 test "single item pointer to pointer to array to slice" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: i32 = 1234;
     try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234);
@@ -1936,7 +1956,7 @@ test "single item pointer to pointer to array to slice" {
 
 test "peer type resolution forms error union" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo: i32 = 123;
     _ = &foo;
@@ -1971,7 +1991,7 @@ test "@volatileCast without a result location" {
 }
 
 test "coercion from single-item pointer to @as to slice" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: u32 = 1;
 
@@ -1984,7 +2004,7 @@ test "coercion from single-item pointer to @as to slice" {
 test "peer type resolution: const sentinel slice and mutable non-sentinel slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime T: type, comptime s: T) !void {
@@ -2011,6 +2031,7 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel slice"
 }
 
 test "peer type resolution: float and comptime-known fixed-width integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2032,7 +2053,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2077,7 +2098,7 @@ test "peer type resolution: same array type with sentinel" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [2:0]u32 = .{ 0, 1 };
     var b: [2:0]u32 = .{ 2, 3 };
@@ -2099,7 +2120,7 @@ test "peer type resolution: same array type with sentinel" {
 test "peer type resolution: array with sentinel and array without sentinel" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [2:0]u32 = .{ 0, 1 };
     var b: [2]u32 = .{ 2, 3 };
@@ -2122,7 +2143,7 @@ test "peer type resolution: array and vector with same child type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     var arr: [2]u32 = .{ 0, 1 };
@@ -2143,7 +2164,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.cpu.arch.isSpirv()) 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
@@ -2170,7 +2191,7 @@ test "peer type resolution: error union and optional of same type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = error{Foo};
     var a: E!*u8 = error.Foo;
@@ -2193,7 +2214,7 @@ test "peer type resolution: error union and optional of same type" {
 test "peer type resolution: C pointer and @TypeOf(null)" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [*c]c_int = 0x1000;
     _ = &a;
@@ -2215,7 +2236,7 @@ test "peer type resolution: C pointer and @TypeOf(null)" {
 test "peer type resolution: three-way resolution combines error set and optional" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = error{Foo};
     var a: E = error.Foo;
@@ -2258,7 +2279,7 @@ test "peer type resolution: vector and optional vector" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     var a: ?@Vector(3, u32) = .{ 0, 1, 2 };
@@ -2279,6 +2300,7 @@ test "peer type resolution: vector and optional vector" {
 }
 
 test "peer type resolution: optional fixed-width int and comptime_int" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2303,7 +2325,7 @@ test "peer type resolution: array and tuple" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var arr: [3]i32 = .{ 1, 2, 3 };
     _ = &arr;
@@ -2324,7 +2346,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.cpu.arch.isSpirv()) 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
@@ -2351,7 +2373,7 @@ test "peer type resolution: vector and array and tuple" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var vec: @Vector(2, i8) = .{ 10, 20 };
     var arr: [2]i8 = .{ 30, 40 };
@@ -2393,7 +2415,7 @@ test "peer type resolution: vector and array and tuple" {
 test "peer type resolution: empty tuple pointer and slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [:0]const u8 = "Hello";
     var b = &.{};
@@ -2414,7 +2436,7 @@ test "peer type resolution: empty tuple pointer and slice" {
 test "peer type resolution: tuple pointer and slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [:0]const u8 = "Hello";
     var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
@@ -2436,7 +2458,7 @@ test "peer type resolution: tuple pointer and optional slice" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     // Miscompilation on Intel's OpenCL CPU runtime.
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
 
     var a: ?[:0]const u8 = null;
     var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
@@ -2457,7 +2479,7 @@ test "peer type resolution: tuple pointer and optional slice" {
 test "peer type resolution: many compatible pointers" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf = "foo-3".*;
 
@@ -2521,6 +2543,7 @@ test "peer type resolution: many compatible pointers" {
 }
 
 test "peer type resolution: tuples with comptime fields" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2553,7 +2576,7 @@ test "peer type resolution: tuples with comptime fields" {
 test "peer type resolution: C pointer and many pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf = "hello".*;
 
@@ -2576,7 +2599,7 @@ test "peer type resolution: C pointer and many pointer" {
 test "peer type resolution: pointer attributes are combined correctly" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf_a align(4) = "foo".*;
     var buf_b align(4) = "bar".*;
@@ -2663,7 +2686,7 @@ test "peer type resolution: arrays of compatible types" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var e0: u8 = 3;
     var e1: u8 = 2;
@@ -2680,7 +2703,7 @@ test "peer type resolution: arrays of compatible types" {
 test "cast builtins can wrap result in optional" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const MyEnum = enum(u32) { _ };
@@ -2715,7 +2738,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2755,7 +2778,7 @@ test "cast builtins can wrap result in error union" {
 test "cast builtins can wrap result in error union and optional" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const MyEnum = enum(u32) { _ };
@@ -2791,7 +2814,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.cpu.arch.isSpirv()) 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
@@ -2836,7 +2859,7 @@ test "@ptrFromInt on vector" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -2860,7 +2883,7 @@ test "@intFromPtr on vector" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -2880,7 +2903,7 @@ test "@intFromPtr on vector" {
 }
 
 test "@floatFromInt on vector" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -2900,7 +2923,7 @@ test "@floatFromInt on vector" {
 }
 
 test "@intFromFloat on vector" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -2920,6 +2943,7 @@ test "@intFromFloat on vector" {
 }
 
 test "@floatFromInt and @intFromFloat on vectors of any length" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -2950,7 +2974,7 @@ test "@floatFromInt and @intFromFloat on vectors of any length" {
 }
 
 test "@intFromBool on vector" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -2970,6 +2994,8 @@ test "@intFromBool on vector" {
 }
 
 test "numeric coercions with undefined" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const from: i32 = undefined;
     var to: f32 = from;
     to = @floatFromInt(from);
@@ -2987,6 +3013,7 @@ test "15-bit int to float" {
 }
 
 test "@as does not corrupt values with incompatible representations" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -3003,7 +3030,7 @@ test "@as does not corrupt values with incompatible representations" {
 test "result information is preserved through many nested structures" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -3025,6 +3052,7 @@ test "result information is preserved through many nested structures" {
 }
 
 test "@intCast vector of signed integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -3047,6 +3075,7 @@ test "result type is preserved into comptime block" {
 }
 
 test "bitcast vector" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const u8x32 = @Vector(32, u8);
@@ -3058,7 +3087,7 @@ test "bitcast vector" {
 }
 
 test "peer type resolution: slice of sentinel-terminated array" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var f: bool = undefined;
     f = false;
@@ -3077,6 +3106,7 @@ test "peer type resolution: slice of sentinel-terminated array" {
 
 test "@intFromFloat boundary cases" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn case(comptime I: type, x: f32, bump: enum { up, down }, expected: I) !void {
@@ -3107,6 +3137,7 @@ test "@intFromFloat boundary cases" {
 }
 
 test "@intFromFloat vector boundary cases" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -3135,6 +3166,7 @@ test "@intFromFloat vector boundary cases" {
 }
 
 test "coerce enum to union with zero-bit fields through local variables" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const E = enum(u1) { foo, bar };
diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig
index 50a1b74d8ab76bdccf8b04795a04ca77bdee078b..c623fb3b5ed2cd253fb3271874554c16ae127e13 100644
--- a/test/behavior/cast_int.zig
+++ b/test/behavior/cast_int.zig
@@ -6,6 +6,7 @@ const maxInt = std.math.maxInt;
 const minInt = std.math.minInt;
 
 test "@intCast i32 to u7" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -33,6 +34,7 @@ test "coerce i8 to i32 and @intCast back" {
 }
 
 test "coerce non byte-sized integers accross 32bits boundary" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     {
@@ -143,7 +145,8 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     try testIntCast(i32, minInt(i32), i64, minInt(i32));
     try testIntCast(i32, maxInt(i32), i64, maxInt(i32));
     try testIntCast(u32, maxInt(u32), u64, maxInt(u32));
@@ -168,7 +171,7 @@ test "@intCast <= 64 bits" {
 
 test "@intCast > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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 e88fe23c86c294627dad536044be9528416edd1d..9e0e10dbd2d8d2592c72546935d5b1cc73874aae 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -415,6 +415,8 @@ test "dereference undefined pointer to zero-bit type" {
 }
 
 test "type pun extern struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = extern struct { f: u8 };
     comptime var s = S{ .f = 123 };
     @as(*u8, @ptrCast(&s)).* = 72;
@@ -434,7 +436,7 @@ test "type pun null pointer-like optional" {
 }
 
 test "write empty array to end" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     comptime var array: [5]u8 = "hello".*;
     array[5..5].* = .{};
@@ -514,7 +516,8 @@ fn fieldPtrTest() u32 {
     return a.value;
 }
 test "pointer in aggregate field can mutate comptime state" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     try comptime std.testing.expect(fieldPtrTest() == 2);
 }
 
@@ -598,6 +601,8 @@ test "reinterpret sentinel-terminated array as packed struct" {
 }
 
 test "reinterpret pointer as optional pointer via double-pointer coercion" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const p0: *const *anyopaque = &@ptrFromInt(0x1000);
     const p1: *const ?*anyopaque = p0;
 
diff --git a/test/behavior/const_slice_child.zig b/test/behavior/const_slice_child.zig
index 83ac5c16a9b1429bd9d05f4792a96035f6593fa5..e9e47101d4a16f8ef456cf4e73425a440f8f0201 100644
--- a/test/behavior/const_slice_child.zig
+++ b/test/behavior/const_slice_child.zig
@@ -10,7 +10,7 @@ test "const slice child" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const strs = [_][*]const u8{ "one", "two", "three" };
     argv = &strs;
diff --git a/test/behavior/decl_literals.zig b/test/behavior/decl_literals.zig
index 08576cf4a6980ee7e855627094513a59cf780544..a26c61d80f390fc81c5a03bde35c1684c39eb173 100644
--- a/test/behavior/decl_literals.zig
+++ b/test/behavior/decl_literals.zig
@@ -33,6 +33,7 @@ test "decl literal with pointer" {
 }
 
 test "call decl literal with optional" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
@@ -48,7 +49,7 @@ test "call decl literal with optional" {
 }
 
 test "call decl literal with pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         x: u32,
@@ -62,6 +63,7 @@ test "call decl literal with pointer" {
 }
 
 test "call decl literal" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         x: u32,
         fn init() @This() {
@@ -74,7 +76,7 @@ test "call decl literal" {
 }
 
 test "call decl literal with error union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     const S = struct {
         x: u32,
diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig
index be22d37ea2f9c71f5fd44dbbb5db099136e4cf14..f310092c170a49c495deb078381035536a9f01d8 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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     testBreakContInDefer(10);
     comptime testBreakContInDefer(10);
 }
@@ -32,6 +34,7 @@ test "defer and labeled break" {
 }
 
 test "errdefer does not apply to fn inside fn" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad);
@@ -49,6 +52,7 @@ fn testNestedFnErrDefer() anyerror!void {
 }
 
 test "return variable while defer expression in scope to modify it" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -89,7 +93,7 @@ fn runSomeErrorDefers(x: bool) !bool {
 }
 
 test "mixing normal and error defers" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -109,7 +113,8 @@ test "mixing normal and error defers" {
 
 test "simple else prong doesn't emit an error for unreachable else prong" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         fn foo() error{Foo}!void {
             return error.Foo;
diff --git a/test/behavior/destructure.zig b/test/behavior/destructure.zig
index a14c05536d7ebe4db08718f15850f1ba233fd4bb..f5f2e06d1c794906c2e66388e63432ef00645a0a 100644
--- a/test/behavior/destructure.zig
+++ b/test/behavior/destructure.zig
@@ -4,6 +4,8 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 
 test "simple destructure" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             var x: u32 = undefined;
@@ -23,6 +25,8 @@ test "simple destructure" {
 }
 
 test "destructure with comptime syntax" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             {
@@ -78,6 +82,8 @@ test "destructure with comptime syntax" {
 }
 
 test "destructure from labeled block" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(rt_true: bool) !void {
             const x: u32, const y: u8, const z: i64 = blk: {
@@ -96,6 +102,8 @@ test "destructure from labeled block" {
 }
 
 test "destructure tuple value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const tup: struct { f32, u32, i64 } = .{ 10.0, 20, 30 };
     const x, const y, const z = tup;
 
@@ -109,6 +117,8 @@ test "destructure tuple value" {
 }
 
 test "destructure array value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const arr: [3]u32 = .{ 10, 20, 30 };
     const x, const y, const z = arr;
 
@@ -122,6 +132,8 @@ test "destructure array value" {
 }
 
 test "destructure from struct init with named tuple fields" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const Tuple = struct { u8, u16, u32 };
     const x, const y, const z = Tuple{
         .@"0" = 100,
@@ -149,6 +161,8 @@ test "destructure of comptime-known tuple is comptime-known" {
 }
 
 test "destructure of comptime-known tuple where some destinations are runtime-known is comptime-known" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var z: u32 = undefined;
     var x: u8, const y, z = .{ 1, 2, 3 };
     _ = &x;
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index 6eacd6a5194dd16f116f4b7bab0cfe12c5faa8e0..ea525e14238832c9ddab8a318dc8d8f85e0e4ede 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -12,6 +12,8 @@ fn shouldEqual(n: Number, expected: u3) !void {
 }
 
 test "enum to int" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try shouldEqual(Number.Zero, 0);
     try shouldEqual(Number.One, 1);
     try shouldEqual(Number.Two, 2);
@@ -614,6 +616,7 @@ test "enum with specified tag values" {
 }
 
 test "non-exhaustive enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -657,6 +660,8 @@ test "non-exhaustive enum" {
 }
 
 test "empty non-exhaustive enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const E = enum(u8) { _ };
 
@@ -678,6 +683,7 @@ test "empty non-exhaustive enum" {
 }
 
 test "single field non-exhaustive enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -796,6 +802,8 @@ test "enum with 1 field but explicit tag type should still have the tag type" {
 }
 
 test "signed integer as enum tag" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const SignedEnum = enum(i2) {
         A0 = -1,
         A1 = 0,
@@ -880,6 +888,8 @@ test "method call on an enum" {
 }
 
 test "enum value allocation" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const LargeEnum = enum(u32) {
         A0 = 0x80000000,
         A1,
@@ -892,6 +902,7 @@ test "enum value allocation" {
 }
 
 test "enum literal casting to tagged union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -918,6 +929,7 @@ test "enum literal casting to tagged union" {
 const Bar = enum { A, B, C, D };
 
 test "enum literal casting to error union with payload enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var bar: error{B}!Bar = undefined;
@@ -927,6 +939,7 @@ test "enum literal casting to error union with payload enum" {
 }
 
 test "constant enum initialization with differing sizes" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -972,7 +985,7 @@ test "@tagName" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
     comptime assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
@@ -988,7 +1001,7 @@ test "@tagName non-exhaustive enum" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
@@ -1000,7 +1013,7 @@ test "@tagName is null-terminated" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1016,7 +1029,7 @@ test "tag name with assigned enum values" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const LocalFoo = enum(u8) {
@@ -1030,7 +1043,7 @@ test "tag name with assigned enum values" {
 
 test "@tagName on enum literals" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
     comptime assert(mem.eql(u8, @tagName(.FooBar), "FooBar"));
@@ -1040,7 +1053,7 @@ test "tag name with signed enum values" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const LocalFoo = enum(isize) {
@@ -1057,7 +1070,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Kdf = enum(u128) {
         aes_kdf = 0xea4f8ac1080d74bf60448a629af3d9c9,
@@ -1077,7 +1090,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn testEnumSigned(comptime T: type) !void {
@@ -1177,7 +1190,7 @@ test "@tagName in callconv(.c) 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;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(mem.orderZ(u8, testEnumTagNameCallconvC(), "Two") == .eq);
@@ -1191,6 +1204,7 @@ fn testEnumTagNameCallconvC() callconv(.c) [*:0]const u8 {
 }
 
 test "enum literal casting to optional" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1217,6 +1231,7 @@ const bit_field_1 = BitFieldOfEnums{
 };
 
 test "bit field access with enum fields" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     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
@@ -1260,7 +1275,7 @@ test "tag name functions are unique" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     {
@@ -1279,7 +1294,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = enum(u8) { nope = 10 };
     const S0 = struct { e: E };
@@ -1314,7 +1329,7 @@ test "switch on an extern enum with negative value" {
 }
 
 test "switch on an enum with small signed tag type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = enum(i3) {
         y = -2,
@@ -1358,7 +1373,7 @@ test "enum tag from a local variable" {
 }
 
 test "auto-numbered enum with signed tag type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = enum(i32) { a, b };
 
@@ -1375,6 +1390,7 @@ test "auto-numbered enum with signed tag type" {
 }
 
 test "lazy initialized field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     try std.testing.expectEqual(@as(u8, @alignOf(struct {})), getLazyInitialized(.a));
 }
 
@@ -1403,6 +1419,7 @@ test "matching captures causes enum equivalence" {
 }
 
 test "large enum field values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     {
@@ -1451,6 +1468,8 @@ test "comptime @enumFromInt with signed arithmetic" {
 }
 
 test "enum int tag type uses declaration inside the enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const static = struct {
         const E = enum(E.IntTag) {
             const IntTag = u8;
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index c6ad8ca25744096162d43d23b0000e40a94e16ac..b67e64875ceebdd0aad160e56001d5963347664a 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -30,6 +30,7 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
 }
 
 test "error binary operator" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const a = errBinaryOperatorG(true) catch 3;
@@ -61,12 +62,14 @@ pub fn baz() anyerror!i32 {
 }
 
 test "error wrapping" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect((baz() catch unreachable) == 15);
 }
 
 test "unwrap simple value from error" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const i = unwrapSimpleValueFromErrorDo() catch unreachable;
@@ -77,6 +80,7 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
 }
 
 test "error return in assignment" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     doErrReturnInAssignment() catch unreachable;
@@ -98,6 +102,7 @@ test "syntax: optional operator in front of error union operator" {
 }
 
 test "widen cast integer payload of error union function call" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -124,7 +129,7 @@ test "debug info for optional error set" {
 
 test "implicit cast to optional to error union to return result loc" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn entry() !void {
@@ -145,12 +150,14 @@ 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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     entry();
     comptime entry();
 }
 
 test "fn returning empty error set can be passed as fn returning any error - pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     entryPtr();
     comptime entryPtr();
@@ -182,6 +189,8 @@ fn fooPtr(f: *const fn () anyerror!void) void {
 fn bar2() (error{}!void) {}
 
 test "error union type " {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testErrorUnionType();
     try comptime testErrorUnionType();
 }
@@ -195,6 +204,8 @@ fn testErrorUnionType() !void {
 }
 
 test "error set type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testErrorSetType();
     try comptime testErrorSetType();
 }
@@ -218,6 +229,7 @@ fn testErrorSetType() !void {
 }
 
 test "explicit error set cast" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testExplicitErrorSetCast(Set1.A);
@@ -236,6 +248,7 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
 }
 
 test "@errorCast on error unions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         fn doTheTest() !void {
             {
@@ -262,6 +275,7 @@ test "@errorCast on error unions" {
 }
 
 test "comptime test error for empty error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testComptimeTestErrorEmptySet(1234);
@@ -298,6 +312,8 @@ test "inferred empty error set comptime catch" {
 }
 
 test "error inference with an empty set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const Struct = struct {
             pub fn func() (error{})!usize {
@@ -319,6 +335,7 @@ test "error inference with an empty set" {
 }
 
 test "error union peer type resolution" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testErrorUnionPeerTypeResolution(1);
@@ -350,6 +367,7 @@ fn quux_1() !i32 {
 }
 
 test "error: Zero sized error set returned with value payload crash" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     _ = try foo3(0);
@@ -363,7 +381,7 @@ fn foo3(b: usize) Error!usize {
 
 test "error: Infer error set from literals" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     _ = nullLiteral("n") catch |err| handleErrors(err);
     _ = floatLiteral("n") catch |err| handleErrors(err);
@@ -400,6 +418,7 @@ fn intLiteral(str: []const u8) !?i64 {
 }
 
 test "nested error union function call in optional unwrap" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -446,6 +465,7 @@ test "nested error union function call in optional unwrap" {
 }
 
 test "return function call to error set from error union function" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -477,6 +497,7 @@ test "optional error set is the same size as error set" {
 }
 
 test "nested catch" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -502,7 +523,7 @@ test "nested catch" {
 
 test "function pointer with return type that is error union with payload which is pointer of parent struct" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Foo = struct {
@@ -524,6 +545,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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -555,6 +577,7 @@ test "return result loc as peer result loc in inferred error set function" {
 }
 
 test "error payload type is correctly resolved" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -585,7 +608,7 @@ test "error union comptime caching" {
 test "@errorName" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
@@ -599,7 +622,7 @@ fn gimmeItBroke() anyerror {
 test "@errorName sentinel length matches slice length" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const name = testBuiltinErrorName(error.FooBar);
@@ -613,6 +636,8 @@ pub fn testBuiltinErrorName(err: anyerror) [:0]const u8 {
 }
 
 test "error set equality" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const a = error{One};
     const b = error{One};
 
@@ -628,6 +653,7 @@ test "error set equality" {
 }
 
 test "inferred error set equality" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -691,6 +717,7 @@ test "coerce error set to the current inferred error set" {
 }
 
 test "error union payload is properly aligned" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -723,6 +750,7 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" {
 }
 
 test "simple else prong allowed even when all errors handled" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -750,7 +778,7 @@ test "simple else prong allowed even when all errors handled" {
 test "pointer to error union 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var err_union: anyerror!u8 = 15;
@@ -781,7 +809,7 @@ const NoReturn = struct {
 };
 
 test "error union of noreturn used with if" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest;
@@ -795,7 +823,7 @@ test "error union of noreturn used with if" {
 }
 
 test "error union of noreturn used with try" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest;
@@ -806,7 +834,7 @@ test "error union of noreturn used with try" {
 }
 
 test "error union of noreturn used with catch" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest;
@@ -819,7 +847,7 @@ test "error union of noreturn used with catch" {
 test "alignment of wrapping an error union payload" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -835,6 +863,7 @@ test "alignment of wrapping an error union payload" {
 }
 
 test "compare error union and error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: anyerror = error.Foo;
@@ -872,7 +901,7 @@ test "catch within a function that calls no errorable functions" {
 test "error from comptime string" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const name = "Weird error name!";
@@ -887,6 +916,8 @@ test "error from comptime string" {
 }
 
 test "field access of anyerror results in smaller error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const E1 = @TypeOf(error.Foo);
     try expect(@TypeOf(E1.Foo) == E1);
     const E2 = error{ A, B, C };
@@ -895,6 +926,7 @@ test "field access of anyerror results in smaller error set" {
 }
 
 test "optional error union return type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -933,7 +965,7 @@ test "optional error set function parameter" {
 
 test "returning an error union containing a type with no runtime bits" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const ZeroByteType = struct {
         foo: void,
@@ -949,7 +981,7 @@ test "returning an error union containing a type with no runtime bits" {
 
 test "try used in recursive function with inferred error set" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Value = union(enum) {
         values: []const @This(),
@@ -1010,6 +1042,7 @@ test "function called at runtime is properly analyzed for inferred error set" {
 }
 
 test "errorCast to adhoc inferred error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         inline fn baz() !i32 {
             return @errorCast(err());
@@ -1022,6 +1055,7 @@ test "errorCast to adhoc inferred error set" {
 }
 
 test "@errorCast from error set to error union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         fn doTheTest(set: error{ A, B }) error{A}!i32 {
             return @errorCast(set);
@@ -1032,6 +1066,7 @@ test "@errorCast from error set to error union" {
 }
 
 test "@errorCast from error union to error union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         fn doTheTest(set: error{ A, B }!i32) error{A}!i32 {
             return @errorCast(set);
@@ -1045,7 +1080,7 @@ test "result location initialization of error union with OPV payload" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -1067,6 +1102,7 @@ test "result location initialization of error union with OPV payload" {
 }
 
 test "return error union with i65" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(try add(1000, 234) == 1234);
@@ -1077,6 +1113,7 @@ fn add(x: i65, y: i65) anyerror!i65 {
 }
 
 test "compare error union to error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         fn doTheTest(val: error{Foo}!i32) !void {
             if (error.Foo == val) return error.Unexpected;
@@ -1107,6 +1144,7 @@ test "'if' ignores error via local while 'else' ignores error directly" {
 }
 
 test "@errorCast into own inferred error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const static = struct {
         fn foo(b: bool) !void {
             if (b) {
@@ -1140,6 +1178,7 @@ test "@errorCast into other inferred error set" {
 }
 
 test "error union with vector type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     var x: anyerror!@Vector(5, f64) = undefined;
     x = error.Expected;
     try expect(x == error.Expected);
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 4aaeb641d4621ddeb545e2c8285ebc7c1c4c5a2c..f0ac5e572493d3daaedb2711820438cd37ce4f20 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 test "compile time recursion" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(some_data.len == 21);
 }
@@ -72,6 +72,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
 }
 
 test "constant expressions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var array: [array_size]u8 = undefined;
@@ -93,6 +94,7 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {
     return max(bool, a, b);
 }
 test "inlined block and runtime block phi" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(letsTryToCompareBools(true, true));
@@ -141,7 +143,7 @@ test "pointer to type" {
 test "a type constructed in a global expression" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var l: List = undefined;
     l.array[0] = 10;
@@ -234,6 +236,7 @@ const vertices = [_]Vertex{
 };
 
 test "statically initialized list" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(static_point_list[0].x == 1);
@@ -303,6 +306,7 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
 }
 
 test "comptime iterate over fn ptr list" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     try expect(performFn('t', 1) == 6);
     try expect(performFn('o', 0) == 1);
     try expect(performFn('w', 99) == 99);
@@ -339,6 +343,7 @@ fn doesAlotT(comptime T: type, value: usize) T {
 }
 
 test "@setEvalBranchQuota at same scope as generic function call" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(doesAlotT(u32, 2) == 2);
@@ -390,7 +395,7 @@ test "return 0 from function that has u0 return type" {
 }
 
 test "statically initialized struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     st_init_str_foo.x += 1;
@@ -406,6 +411,7 @@ var st_init_str_foo = StInitStrFoo{
 };
 
 test "inline for with same type but different values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     var res: usize = 0;
     inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
         var a: T = undefined;
@@ -441,7 +447,7 @@ fn copyWithPartialInline(s: []u32, b: []u8) void {
 test "binary math operator in partially inlined function" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var s: [4]u32 = undefined;
     var b: [16]u8 = undefined;
@@ -484,6 +490,7 @@ test "comptime bitwise operators" {
 }
 
 test "comptime shlWithOverflow" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -498,7 +505,7 @@ test "comptime shlWithOverflow" {
 
 test "const ptr to variable data changes at runtime" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(foo_ref.name[0] == 'a');
     foo_ref.name = "b";
@@ -515,7 +522,7 @@ const foo_ref = &foo_contents;
 test "runtime 128 bit integer division" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var a: u128 = 152313999999999991610955792383;
@@ -527,13 +534,14 @@ test "runtime 128 bit integer division" {
 
 test "@tagName of @typeInfo" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const str = @tagName(@typeInfo(u8));
     try expect(std.mem.eql(u8, str, "int"));
 }
 
 test "static eval list init" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -551,6 +559,7 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
 }
 
 test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var runtime = [1]i32{3};
@@ -603,7 +612,7 @@ const hi1 = "hi";
 const hi2 = hi1;
 test "const global shares pointer with other same one" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try assertEqualPtrs(&hi1[0], &hi2[0]);
     comptime assert(&hi1[0] == &hi2[0]);
@@ -722,7 +731,7 @@ fn testVarInsideInlineLoop(args: anytype) !void {
 test "array concatenation of function calls" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a = oneItem(3) ++ oneItem(4);
     try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
@@ -737,6 +746,7 @@ fn scalar(x: u32) u32 {
 }
 
 test "array concatenation peer resolves element types - value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -755,7 +765,7 @@ test "array concatenation peer resolves element types - value" {
 test "array concatenation peer resolves element types - pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a = [2]u3{ 1, 7 };
     var b = [3]u8{ 200, 225, 255 };
@@ -772,7 +782,7 @@ test "array concatenation sets the sentinel - value" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a = [2]u3{ 1, 7 };
     var b = [3:69]u8{ 200, 225, 255 };
@@ -791,7 +801,7 @@ test "array concatenation sets the sentinel - value" {
 test "array concatenation sets the sentinel - pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a = [2]u3{ 1, 7 };
     var b = [3:69]u8{ 200, 225, 255 };
@@ -926,7 +936,7 @@ test "closure capture type of runtime-known var" {
 }
 
 test "comptime break passing through runtime condition converted to runtime break" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -959,7 +969,7 @@ test "comptime break passing through runtime condition converted to runtime brea
 }
 
 test "comptime break to outer loop passing through runtime condition converted to runtime break" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -996,6 +1006,8 @@ test "comptime break to outer loop passing through runtime condition converted t
 }
 
 test "comptime break operand passing through runtime condition converted to runtime break" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(runtime: u8) !void {
             const result = inline for ([3]u8{ 'a', 'b', 'c' }) |byte| {
@@ -1012,6 +1024,7 @@ test "comptime break operand passing through runtime condition converted to runt
 }
 
 test "comptime break operand passing through runtime switch converted to runtime break" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -1038,7 +1051,7 @@ test "equality of pointers to comptime const" {
 test "storing an array of type in a 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() void {
@@ -1066,7 +1079,7 @@ test "storing an array of type in a field" {
 
 test "pass pointer to field of comptime-only type as a runtime parameter" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Mixed = struct {
@@ -1192,7 +1205,8 @@ test "lazy value is resolved as slice operand" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const A = struct { a: u32 };
     var a: [512]u64 = undefined;
 
@@ -1203,6 +1217,8 @@ test "lazy value is resolved as slice operand" {
 }
 
 test "break from inline loop depends on runtime condition" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn foo(a: u8) bool {
             return a == 4;
@@ -1249,6 +1265,7 @@ test "inline for inside a runtime condition" {
 }
 
 test "continue in inline for inside a comptime switch" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const arr = .{ 1, 2, 3 };
@@ -1267,7 +1284,7 @@ test "continue in inline for inside a comptime switch" {
 }
 
 test "length of global array is determinable at comptime" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var bytes: [1024]u8 = undefined;
@@ -1316,7 +1333,7 @@ test "continue nested inline for loop in named block expr" {
 }
 
 test "x and false is comptime-known false" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const T = struct {
@@ -1344,7 +1361,7 @@ test "x and false is comptime-known false" {
 }
 
 test "x or true is comptime-known true" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const T = struct {
@@ -1372,6 +1389,7 @@ test "x or true is comptime-known true" {
 }
 
 test "non-optional and optional array elements concatenated" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -1391,6 +1409,8 @@ test "inline call in @TypeOf inherits is_inline property" {
 }
 
 test "comptime function turns function value to function pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn fnPtr(function: anytype) *const @TypeOf(function) {
             return &function;
@@ -1406,7 +1426,7 @@ test "comptime function turns function value to function pointer" {
 }
 
 test "container level const and var have unique addresses" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         x: i32,
@@ -1451,6 +1471,8 @@ test "struct in comptime false branch is not evaluated" {
 }
 
 test "result of nested switch assigned to variable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var zds: u32 = 0;
     zds = switch (zds) {
         0 => switch (zds) {
@@ -1465,6 +1487,8 @@ test "result of nested switch assigned to variable" {
 }
 
 test "inline for loop of functions returning error unions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const T1 = struct {
         fn v() error{}!usize {
             return 1;
@@ -1519,6 +1543,8 @@ test "early exit in container level const" {
 }
 
 test "@inComptime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn inComptime() bool {
             return @inComptime();
@@ -1584,6 +1610,8 @@ test "comptime labeled block implicit exit" {
 }
 
 test "comptime block has intermediate runtime-known values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const arr: [2]u8 = .{ 1, 2 };
 
     var idx: usize = undefined;
diff --git a/test/behavior/export_builtin.zig b/test/behavior/export_builtin.zig
index ff46cda875af235356f751a05744b3fc7451dd2e..42ca44673a7f23b09c04da2780b6d356aad2b75f 100644
--- a/test/behavior/export_builtin.zig
+++ b/test/behavior/export_builtin.zig
@@ -4,7 +4,7 @@ const expect = std.testing.expect;
 
 test "exporting enum value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const E = enum(c_int) { one, two };
@@ -18,7 +18,7 @@ test "exporting enum value" {
 
 test "exporting using namespace access" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Inner = struct {
@@ -35,7 +35,7 @@ test "exporting using namespace access" {
 test "exporting comptime-known value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const x: u32 = 10;
     @export(&x, .{ .name = "exporting_comptime_known_value_foo" });
diff --git a/test/behavior/export_keyword.zig b/test/behavior/export_keyword.zig
index fa69c74747b0e171ba8b31ef24ccd57d09f60b5b..0ccf19340298bdac6454a0cc2c10d8e1e300d470 100644
--- a/test/behavior/export_keyword.zig
+++ b/test/behavior/export_keyword.zig
@@ -43,7 +43,7 @@ export fn testPackedStuff(a: *const PackedStruct, b: *const PackedUnion) void {
 }
 
 test "export function alias" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     _ = struct {
         fn foo_internal() callconv(.c) u32 {
diff --git a/test/behavior/extern.zig b/test/behavior/extern.zig
index f9e2f853ac3107a7918ffacd439c98a51de270b4..657e4d6d8782dac693f72201b2b50d8ac9282389 100644
--- a/test/behavior/extern.zig
+++ b/test/behavior/extern.zig
@@ -4,7 +4,7 @@ const expect = std.testing.expect;
 
 test "anyopaque extern symbol" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
     const b: *i32 = @ptrCast(@alignCast(a));
@@ -15,7 +15,7 @@ export var a_mystery_symbol: i32 = 1234;
 
 test "function extern symbol" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = @extern(*const fn () callconv(.c) i32, .{ .name = "a_mystery_function" });
     try expect(a() == 4567);
@@ -27,7 +27,7 @@ export fn a_mystery_function() i32 {
 
 test "function extern symbol matches extern decl" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         extern fn another_mystery_function() u32;
diff --git a/test/behavior/field_parent_ptr.zig b/test/behavior/field_parent_ptr.zig
index 8694f366a586cd4a756f7f1acb7862c656b04f02..dd6b61aadcbc056f6afd3f5ae669126a4f6fe0df 100644
--- a/test/behavior/field_parent_ptr.zig
+++ b/test/behavior/field_parent_ptr.zig
@@ -2,7 +2,7 @@ const expect = @import("std").testing.expect;
 const builtin = @import("builtin");
 
 test "@fieldParentPtr struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const C = struct {
@@ -139,7 +139,7 @@ test "@fieldParentPtr struct" {
 
 test "@fieldParentPtr extern struct" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const C = extern struct {
         a: bool = true,
@@ -274,7 +274,7 @@ test "@fieldParentPtr extern struct" {
 }
 
 test "@fieldParentPtr extern struct first zero-bit field" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const C = extern struct {
@@ -378,7 +378,7 @@ test "@fieldParentPtr extern struct first zero-bit field" {
 }
 
 test "@fieldParentPtr extern struct middle zero-bit field" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const C = extern struct {
@@ -482,7 +482,7 @@ test "@fieldParentPtr extern struct middle zero-bit field" {
 }
 
 test "@fieldParentPtr extern struct last zero-bit field" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const C = extern struct {
@@ -587,7 +587,7 @@ test "@fieldParentPtr extern struct last zero-bit field" {
 
 test "@fieldParentPtr unaligned packed struct" {
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -725,7 +725,7 @@ test "@fieldParentPtr unaligned packed struct" {
 
 test "@fieldParentPtr aligned packed struct" {
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -863,7 +863,7 @@ test "@fieldParentPtr aligned packed struct" {
 
 test "@fieldParentPtr nested packed struct" {
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -1026,7 +1026,7 @@ test "@fieldParentPtr nested packed struct" {
 
 test "@fieldParentPtr packed struct first zero-bit field" {
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -1132,7 +1132,7 @@ test "@fieldParentPtr packed struct first zero-bit field" {
 
 test "@fieldParentPtr packed struct middle zero-bit field" {
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -1238,7 +1238,7 @@ test "@fieldParentPtr packed struct middle zero-bit field" {
 
 test "@fieldParentPtr packed struct last zero-bit field" {
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -1344,7 +1344,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {
 
 test "@fieldParentPtr tagged union" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const C = union(enum) {
         a: bool,
@@ -1479,7 +1479,7 @@ test "@fieldParentPtr tagged union" {
 }
 
 test "@fieldParentPtr untagged union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const C = union {
@@ -1617,7 +1617,7 @@ test "@fieldParentPtr untagged union" {
 test "@fieldParentPtr extern union" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const C = extern union {
         a: bool,
@@ -1752,7 +1752,7 @@ test "@fieldParentPtr extern union" {
 }
 
 test "@fieldParentPtr packed union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -1896,7 +1896,7 @@ test "@fieldParentPtr packed union" {
 
 test "@fieldParentPtr tagged union all zero-bit fields" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const C = union(enum) {
         a: u0,
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index f7a23bd904e7f6af3c5d60efdc1ddfa4b8da3091..6624564de6bfacf383630c12c972ea15302692d0 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -28,7 +28,7 @@ test "add f32/f64" {
 }
 
 test "add f80/f128/c_longdouble" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testAdd(f80);
@@ -62,7 +62,7 @@ test "sub f32/f64" {
 }
 
 test "sub f80/f128/c_longdouble" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testSub(f80);
@@ -96,7 +96,7 @@ test "mul f32/f64" {
 }
 
 test "mul f80/f128/c_longdouble" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testMul(f80);
@@ -116,6 +116,7 @@ fn testMul(comptime T: type) !void {
 }
 
 test "cmp f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -124,7 +125,7 @@ test "cmp f16" {
 }
 
 test "cmp f32" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765
@@ -137,6 +138,7 @@ test "cmp f64" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     try testCmp(f64);
     try comptime testCmp(f64);
@@ -145,7 +147,7 @@ test "cmp f64" {
 test "cmp f128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCmp(f128);
     try comptime testCmp(f128);
@@ -153,7 +155,7 @@ test "cmp f128" {
 
 test "cmp f80/c_longdouble" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testCmp(f80);
@@ -217,6 +219,7 @@ fn testCmp(comptime T: type) !void {
 }
 
 test "vector cmp f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -228,7 +231,7 @@ test "vector cmp f16" {
 
 test "vector cmp f32" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_llvm and builtin.cpu.arch.isArm()) return error.SkipZigTest;
@@ -247,6 +250,7 @@ test "vector cmp f64" {
     if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     try testCmpVector(f64);
     try comptime testCmpVector(f64);
@@ -255,7 +259,7 @@ test "vector cmp f64" {
 test "vector cmp f128" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
 
@@ -267,7 +271,7 @@ test "vector cmp f80/c_longdouble" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCmpVector(f80);
     try comptime testCmpVector(f80);
@@ -357,7 +361,7 @@ test "@sqrt f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSqrt(f16);
     try comptime testSqrt(f16);
@@ -366,7 +370,7 @@ test "@sqrt f16" {
 test "@sqrt f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSqrt(f32);
     try comptime testSqrt(f32);
@@ -378,7 +382,7 @@ test "@sqrt f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
 
     try testSqrt(f80);
@@ -457,6 +461,7 @@ fn testSqrt(comptime T: type) !void {
 }
 
 test "@sqrt with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -479,7 +484,7 @@ test "@sin f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSin(f16);
     try comptime testSin(f16);
@@ -489,7 +494,7 @@ test "@sin f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSin(f32);
     comptime try testSin(f32);
@@ -501,7 +506,7 @@ test "@sin f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSin(f80);
     comptime try testSin(f80);
@@ -524,6 +529,7 @@ fn testSin(comptime T: type) !void {
 }
 
 test "@sin with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -546,7 +552,7 @@ test "@cos f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCos(f16);
     try comptime testCos(f16);
@@ -556,7 +562,7 @@ test "@cos f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCos(f32);
     try comptime testCos(f32);
@@ -568,7 +574,7 @@ test "@cos f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCos(f80);
     try comptime testCos(f80);
@@ -591,6 +597,7 @@ fn testCos(comptime T: type) !void {
 }
 
 test "@cos with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -613,7 +620,7 @@ test "@tan f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testTan(f16);
     try comptime testTan(f16);
@@ -623,7 +630,7 @@ test "@tan f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testTan(f32);
     try comptime testTan(f32);
@@ -635,7 +642,7 @@ test "@tan f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testTan(f80);
     try comptime testTan(f80);
@@ -658,6 +665,7 @@ fn testTan(comptime T: type) !void {
 }
 
 test "@tan with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -680,7 +688,7 @@ test "@exp f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testExp(f16);
     try comptime testExp(f16);
@@ -690,7 +698,7 @@ test "@exp f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testExp(f32);
     try comptime testExp(f32);
@@ -702,7 +710,7 @@ test "@exp f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testExp(f80);
     try comptime testExp(f80);
@@ -729,6 +737,7 @@ fn testExp(comptime T: type) !void {
 }
 
 test "@exp with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -751,7 +760,7 @@ test "@exp2 f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testExp2(f16);
     try comptime testExp2(f16);
@@ -761,7 +770,7 @@ test "@exp2 f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testExp2(f32);
     try comptime testExp2(f32);
@@ -773,7 +782,7 @@ test "@exp2 f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testExp2(f80);
     try comptime testExp2(f80);
@@ -795,6 +804,7 @@ fn testExp2(comptime T: type) !void {
 }
 
 test "@exp2 with @vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -817,7 +827,7 @@ test "@log f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog(f16);
     try comptime testLog(f16);
@@ -827,7 +837,7 @@ test "@log f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog(f32);
     try comptime testLog(f32);
@@ -839,7 +849,7 @@ test "@log f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog(f80);
     try comptime testLog(f80);
@@ -865,7 +875,7 @@ test "@log with @vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     {
         var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
@@ -882,7 +892,7 @@ test "@log2 f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog2(f16);
     try comptime testLog2(f16);
@@ -892,7 +902,7 @@ test "@log2 f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog2(f32);
     try comptime testLog2(f32);
@@ -904,7 +914,7 @@ test "@log2 f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog2(f80);
     try comptime testLog2(f80);
@@ -926,6 +936,7 @@ fn testLog2(comptime T: type) !void {
 }
 
 test "@log2 with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -957,7 +968,7 @@ test "@log10 f16" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog10(f16);
     try comptime testLog10(f16);
@@ -967,7 +978,7 @@ test "@log10 f32/f64" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog10(f32);
     try comptime testLog10(f32);
@@ -979,7 +990,7 @@ test "@log10 f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog10(f80);
     try comptime testLog10(f80);
@@ -1004,7 +1015,7 @@ test "@log10 with vectors" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testLog10WithVectors();
     try comptime testLog10WithVectors();
@@ -1024,6 +1035,7 @@ test "@abs f16" {
     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.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     try testFabs(f16);
     try comptime testFabs(f16);
@@ -1032,6 +1044,7 @@ test "@abs f16" {
 test "@abs f32/f64" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     try testFabs(f32);
     try comptime testFabs(f32);
@@ -1042,7 +1055,7 @@ test "@abs f32/f64" {
 test "@abs f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testFabs(f80);
@@ -1118,6 +1131,7 @@ fn testFabs(comptime T: type) !void {
 }
 
 test "@abs with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1137,6 +1151,7 @@ fn testFabsWithVectors() !void {
 }
 
 test "@floor f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1146,6 +1161,7 @@ test "@floor f16" {
 }
 
 test "@floor f32/f64" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1159,7 +1175,7 @@ test "@floor f32/f64" {
 test "@floor f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testFloor(f80);
@@ -1201,6 +1217,7 @@ fn testFloor(comptime T: type) !void {
 }
 
 test "@floor with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1220,6 +1237,7 @@ fn testFloorWithVectors() !void {
 }
 
 test "@ceil f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1229,6 +1247,7 @@ test "@ceil f16" {
 }
 
 test "@ceil f32/f64" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1242,7 +1261,7 @@ test "@ceil f32/f64" {
 test "@ceil f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testCeil(f80);
@@ -1256,7 +1275,7 @@ test "@ceil f80/f128/c_longdouble" {
 test "@ceil f80 maxInt(u64)" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var x: u64 = std.math.maxInt(u64);
@@ -1296,6 +1315,7 @@ fn testCeil(comptime T: type) !void {
 }
 
 test "@ceil with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1315,6 +1335,7 @@ fn testCeilWithVectors() !void {
 }
 
 test "@trunc f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1324,6 +1345,7 @@ test "@trunc f16" {
 }
 
 test "@trunc f32/f64" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1337,7 +1359,7 @@ test "@trunc f32/f64" {
 test "@trunc f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testTrunc(f80);
@@ -1379,6 +1401,7 @@ fn testTrunc(comptime T: type) !void {
 }
 
 test "@trunc with vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1398,6 +1421,7 @@ fn testTruncWithVectors() !void {
 }
 
 test "neg f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1407,6 +1431,7 @@ test "neg f16" {
 }
 
 test "neg f32/f64" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1420,7 +1445,7 @@ test "neg f32/f64" {
 test "neg f80/f128/c_longdouble" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testNeg(f80);
@@ -1501,7 +1526,7 @@ fn testNeg(comptime T: type) !void {
 }
 
 test "negate f80" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var f: f80 = 0.0;
     const a: u80 = @bitCast(f);
@@ -1535,7 +1560,7 @@ test "f128 at compile time is lossy" {
 test "comptime fixed-width float zero divided by zero produces NaN" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     inline for (.{ f16, f32, f64, f80, f128 }) |F| {
@@ -1544,6 +1569,7 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
 }
 
 test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1687,7 +1713,7 @@ test "comptime calls are only memoized when float arguments are bit-for-bit equa
 test "result location forwarded through unary float builtins" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var x: u32 = 10;
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index 69b32ca20271f8bbdf660eb5cc8039c6e0a5bfb1..b7b561cac6088bee21948f1fd5220e9080b06aa8 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -21,6 +21,8 @@ fn testLocVars(b: i32) void {
 }
 
 test "mutable local variables" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var zero: i32 = 0;
     _ = &zero;
     try expect(zero == 0);
@@ -70,13 +72,14 @@ fn outer(y: u32) *const fn (u32) u32 {
 }
 
 test "return inner function which references comptime variable of outer function" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const func = outer(10);
     try expect(func(3) == 7);
 }
 
 test "discard the result of a function that returns a struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -101,7 +104,7 @@ test "discard the result of a function that returns a struct" {
 test "inline function call that calls optional function pointer, return pointer at callsite interacts correctly with callsite return type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         field: u32,
@@ -147,7 +150,7 @@ fn fnWithUnreachable() noreturn {
 
 test "extern struct with stdcallcc fn pointer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = extern struct {
         ptr: *const fn () callconv(if (builtin.target.cpu.arch == .x86) .{ .x86_stdcall = .{} } else .c) i32,
@@ -175,6 +178,7 @@ fn fComplexCallconvRet(x: u32) callconv(blk: {
 }
 
 test "function with complex callconv and return type expressions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -182,6 +186,7 @@ test "function with complex callconv and return type expressions" {
 }
 
 test "pass by non-copying value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
@@ -197,6 +202,7 @@ fn addPointCoords(pt: Point) i32 {
 }
 
 test "pass by non-copying value through var arg" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
@@ -208,6 +214,7 @@ fn addPointCoordsVar(pt: anytype) !i32 {
 }
 
 test "pass by non-copying value as method" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var pt = Point2{ .x = 1, .y = 2 };
@@ -224,6 +231,7 @@ const Point2 = struct {
 };
 
 test "pass by non-copying value as method, which is generic" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var pt = Point3{ .x = 1, .y = 2 };
@@ -252,7 +260,7 @@ test "pass by non-copying value as method, at comptime" {
 test "implicit cast fn call result to optional in field result" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn entry() !void {
@@ -290,6 +298,7 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void {
 }
 
 test "call function with empty string" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     acceptsString("");
@@ -302,7 +311,7 @@ fn acceptsString(foo: []u8) void {
 test "function pointers" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const fns = [_]*const @TypeOf(fn1){
         &fn1,
@@ -337,6 +346,7 @@ fn numberLiteralArg(a: anytype) !void {
 }
 
 test "function call with anon list literal" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -356,6 +366,7 @@ test "function call with anon list literal" {
 }
 
 test "function call with anon list literal - 2D" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -394,6 +405,8 @@ test "ability to give comptime types and non comptime types to same parameter" {
 }
 
 test "function with inferred error set but returning no error" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn foo() !void {}
     };
@@ -404,7 +417,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn get() @import("std").ArrayList(i32) {
@@ -418,7 +431,7 @@ test "import passed byref to function in return type" {
 
 test "implicit cast function to function ptr" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S1 = struct {
         export fn someFunctionThatReturnsAValue() c_int {
@@ -439,7 +452,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         x: i32 = 1234,
@@ -459,7 +472,7 @@ test "method call with optional and error union first param" {
 test "method call with optional pointer 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         x: i32 = 1234,
@@ -477,7 +490,7 @@ test "method call with optional pointer first param" {
 test "using @ptrCast on function pointers" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const A = struct { data: [4]u8 };
@@ -514,6 +527,8 @@ test "function returns function returning type" {
 }
 
 test "peer type resolution of inferred error set with non-void payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn openDataFile(mode: enum { read, write }) !u32 {
             return switch (mode) {
@@ -532,6 +547,8 @@ test "peer type resolution of inferred error set with non-void payload" {
 }
 
 test "lazy values passed to anytype parameter" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const A = struct {
         a: u32,
         fn foo(comptime a: anytype) !void {
@@ -570,7 +587,7 @@ test "pass and return comptime-only types" {
 
 test "pointer to alias behaves same as pointer to function" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo() u32 {
@@ -593,6 +610,7 @@ test "comptime parameters don't have to be marked comptime if only called at com
 }
 
 test "inline function with comptime-known comptime-only return type called at runtime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         inline fn foo(x: *i32, y: *const i32) type {
             x.* = y.*;
@@ -607,7 +625,7 @@ test "inline function with comptime-known comptime-only return type called at ru
 }
 
 test "address of function parameter is consistent" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn paramAddrMatch(x: u8) bool {
@@ -635,6 +653,8 @@ test "address of function parameter is consistent in function return type" {
 }
 
 test "function parameter self equality" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn equal(x: u32) bool {
             return x == x;
@@ -664,6 +684,8 @@ test "function parameter self equality" {
 }
 
 test "inline call propagates comptime-known argument to generic parameter and return types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         inline fn f(x: bool, y: if (x) u8 else u16) if (x) bool else u32 {
             if (x) {
@@ -744,7 +766,7 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var global: i32 = 1;
diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig
index 95dbfeb4b2b75489a00e6be9cc9abd868d3e174a..31b79038ecdb6ded1982d08d6019d6c27acc74c3 100644
--- a/test/behavior/fn_delegation.zig
+++ b/test/behavior/fn_delegation.zig
@@ -32,6 +32,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
 }
 
 test "fn delegation" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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/fn_in_struct_in_comptime.zig b/test/behavior/fn_in_struct_in_comptime.zig
index 4057727077314f9f644005848a2076b54b2325d6..ea9e313eaf8b6989b8a6ce6f01e6a6782f6e614e 100644
--- a/test/behavior/fn_in_struct_in_comptime.zig
+++ b/test/behavior/fn_in_struct_in_comptime.zig
@@ -12,7 +12,7 @@ fn get_foo() fn (*u8) usize {
 }
 
 test "define a function in an anonymous struct in comptime" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const foo = get_foo();
     try expect(foo(@as(*u8, @ptrFromInt(12345))) == 12345);
diff --git a/test/behavior/for.zig b/test/behavior/for.zig
index f2a8cba44665dccff95b013778a45f810f7e2664..ca2bd76b39f8dbf7e376a9385cd7d85f3d9114a3 100644
--- a/test/behavior/for.zig
+++ b/test/behavior/for.zig
@@ -5,6 +5,7 @@ const expectEqual = std.testing.expectEqual;
 const mem = std.mem;
 
 test "continue in for loop" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const array = [_]i32{ 1, 2, 3, 4, 5 };
@@ -67,7 +68,7 @@ test "ignore lval with underscore (for loop)" {
 test "basic for loop" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const expected_result: [24]u8 = .{
         9, 8, 7, 6, 0, 1, 2, 3,
@@ -114,7 +115,7 @@ test "basic for loop" {
 test "for with null and T peer types and inferred result location type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(slice: []const u8) !void {
@@ -133,6 +134,7 @@ test "for with null and T peer types and inferred result location type" {
 }
 
 test "2 break statements and an else" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -154,7 +156,7 @@ test "2 break statements and an else" {
 test "for loop with pointer elem var" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const source = "abcdefg";
     var target: [source.len]u8 = undefined;
@@ -179,6 +181,7 @@ fn mangleString(s: []u8) void {
 }
 
 test "for copies its payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -198,7 +201,7 @@ test "for copies its payload" {
 test "for on slice with allowzero ptr" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(slice: []const u8) !void {
@@ -213,7 +216,7 @@ test "for on slice with allowzero ptr" {
 
 test "else continue outer for" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var i: usize = 6;
     var buf: [5]u8 = undefined;
@@ -226,6 +229,7 @@ test "else continue outer for" {
 }
 
 test "for loop with else branch" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     {
         var x = [_]u32{ 1, 2 };
         _ = &x;
@@ -272,6 +276,7 @@ test "two counters" {
 }
 
 test "1-based counter and ptr to array" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -306,7 +311,7 @@ test "1-based counter and ptr to array" {
 test "slice and two counters, one is offset and one is runtime" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const slice: []const u8 = "blah";
     var start: usize = 0;
@@ -335,7 +340,7 @@ test "slice and two counters, one is offset and one is runtime" {
 test "two slices, one captured by-ref" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [10]u8 = undefined;
     const slice1: []const u8 = "blah";
@@ -354,7 +359,7 @@ test "two slices, one captured by-ref" {
 test "raw pointer and slice" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [10]u8 = undefined;
     const slice: []const u8 = "blah";
@@ -373,7 +378,7 @@ test "raw pointer and slice" {
 test "raw pointer and counter" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [10]u8 = undefined;
     const ptr: [*]u8 = &buf;
@@ -391,7 +396,7 @@ test "raw pointer and counter" {
 test "inline for with slice as the comptime-known" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const comptime_slice = "hello";
     var runtime_i: usize = 3;
@@ -422,7 +427,7 @@ test "inline for with slice as the comptime-known" {
 test "inline for with counter as the comptime-known" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var runtime_slice = "hello";
     var runtime_i: usize = 3;
@@ -451,6 +456,7 @@ test "inline for with counter as the comptime-known" {
 }
 
 test "inline for on tuple pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -465,6 +471,7 @@ test "inline for on tuple pointer" {
 }
 
 test "ref counter that starts at zero" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -479,6 +486,7 @@ test "ref counter that starts at zero" {
 }
 
 test "inferred alloc ptr of for loop" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -501,6 +509,7 @@ test "inferred alloc ptr of for loop" {
 }
 
 test "for loop results in a bool" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try std.testing.expect(for ([1]u8{0}) |x| {
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index a30529a193a20693b87158fe7ad90079c1f00c8b..bdc36ad10eae66f97c54c4dea14af3c53e1fd510 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -5,6 +5,8 @@ const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
 test "one param, explicit comptime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x: usize = 0;
     x += checkSize(i32);
     x += checkSize(bool);
@@ -17,6 +19,7 @@ fn checkSize(comptime T: type) usize {
 }
 
 test "simple generic fn" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(max(i32, 3, -1) == 3);
@@ -51,6 +54,7 @@ fn sameButWithFloats(a: f64, b: f64) f64 {
 }
 
 test "fn with comptime args" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -86,7 +90,7 @@ fn max_f64(a: f64, b: f64) f64 {
 test "type constructed by comptime function call" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var l: SimpleList(10) = undefined;
     l.array[0] = 10;
@@ -108,6 +112,7 @@ fn SimpleList(comptime L: usize) type {
 }
 
 test "function with return type type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -150,7 +155,7 @@ fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
 test "generic fn with implicit cast" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(getFirstByte(u8, &[_]u8{13}) == 13);
     try expect(getFirstByte(u16, &[_]u16{
@@ -169,7 +174,7 @@ test "generic fn keeps non-generic parameter types" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const A = 128;
 
@@ -204,7 +209,7 @@ fn foo2(arg: anytype) bool {
 
 test "generic struct" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a1 = GenNode(i32){
         .value = 13,
@@ -245,7 +250,7 @@ test "function parameter is generic" {
 test "generic function instantiation turns into comptime call" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -273,6 +278,7 @@ test "generic function instantiation turns into comptime call" {
 }
 
 test "generic function with void and comptime parameter" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct { x: i32 };
@@ -288,6 +294,7 @@ test "generic function with void and comptime parameter" {
 }
 
 test "anonymous struct return type referencing comptime parameter" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -306,7 +313,7 @@ test "anonymous struct return type referencing comptime parameter" {
 test "generic function instantiation non-duplicates" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn copy(comptime T: type, dest: []T, source: []const T) void {
@@ -339,7 +346,7 @@ test "generic instantiation of tagged union with only one field" {
 }
 
 test "generic parameter type is function type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void {
@@ -374,6 +381,7 @@ test "extern function used as generic parameter" {
 }
 
 test "generic struct as parameter type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -389,7 +397,7 @@ test "generic struct as parameter type" {
 }
 
 test "slice as parameter type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -406,7 +414,7 @@ test "slice as parameter type" {
 }
 
 test "null sentinel pointer passed as generic argument" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(a: anytype) !void {
@@ -417,6 +425,8 @@ test "null sentinel pointer passed as generic argument" {
 }
 
 test "generic function passed as comptime argument" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doMath(comptime f: fn (comptime type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {
             const result = try f(i32, a, b);
@@ -427,7 +437,7 @@ test "generic function passed as comptime argument" {
 }
 
 test "return type of generic function is function pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn b(comptime T: type) ?*const fn () error{}!T {
@@ -439,6 +449,8 @@ test "return type of generic function is function pointer" {
 }
 
 test "coerced function body has inequal value with its uncoerced body" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const A = B(i32, c);
         fn c() !i32 {
@@ -485,7 +497,9 @@ test "union in struct captures argument" {
 }
 
 test "function argument tuple used as struct field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn DeleagateWithContext(comptime Function: type) type {
             const ArgArgs = std.meta.ArgsTuple(Function);
@@ -516,7 +530,7 @@ test "comptime callconv(.c) function ptr uses comptime type argument" {
 }
 
 test "call generic function with from function called by the generic function" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     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
@@ -559,6 +573,7 @@ fn StructCapture(comptime T: type) type {
 }
 
 test "call generic function that uses capture from function declaration's scope" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = StructCapture(f64);
@@ -573,7 +588,7 @@ comptime {
 }
 
 test "generic parameter resolves to comptime-only type but is not marked comptime" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(comptime T: type, rt_false: bool, func: fn (T) void) T {
diff --git a/test/behavior/globals.zig b/test/behavior/globals.zig
index bb3ba105e92d324d6b2b58b8c49f6ee643d82594..3b19d499dda9e2ddc249140f5c0ced3dec7357ed 100644
--- a/test/behavior/globals.zig
+++ b/test/behavior/globals.zig
@@ -4,7 +4,7 @@ const expect = std.testing.expect;
 
 var pos = [2]f32{ 0.0, 0.0 };
 test "store to global array" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
@@ -15,7 +15,7 @@ test "store to global array" {
 
 var vpos = @Vector(2, f32){ 0.0, 0.0 };
 test "store to global vector" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
@@ -27,7 +27,7 @@ test "store to global vector" {
 test "slices pointing at the same address as global array." {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const a = [_]u8{ 1, 2, 3 };
@@ -44,7 +44,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
@@ -68,6 +68,8 @@ test "global loads can affect liveness" {
 }
 
 test "global const can be self-referential" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         self: *const @This(),
         x: u32,
@@ -83,7 +85,7 @@ test "global const can be self-referential" {
 }
 
 test "global var can be self-referential" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         self: *@This(),
@@ -112,6 +114,8 @@ test "global var can be self-referential" {
 }
 
 test "global const can be indirectly self-referential" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         other: *const @This(),
         x: u32,
@@ -136,7 +140,7 @@ test "global const can be indirectly self-referential" {
 }
 
 test "global var can be indirectly self-referential" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         other: *@This(),
@@ -175,7 +179,7 @@ var callbacks: Callbacks = undefined;
 var callbacks_loaded: bool = false;
 
 test "function pointer field call on global extern struct, conditional on global" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     if (callbacks_loaded) {
         try std.testing.expectEqual(42, callbacks.key_callback(42));
@@ -184,7 +188,7 @@ test "function pointer field call on global extern struct, conditional on global
 
 test "function pointer field call on global extern struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn keyCallback(key: i32) callconv(.c) i32 {
diff --git a/test/behavior/hasdecl.zig b/test/behavior/hasdecl.zig
index bba8f1f32f33ba09d9526d23609b65c34129fcbb..afe71cce4caad2f4a15dce3e9839ccdbfe7c370c 100644
--- a/test/behavior/hasdecl.zig
+++ b/test/behavior/hasdecl.zig
@@ -12,6 +12,7 @@ pub const Bar = struct {
 };
 
 test "@hasDecl" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(@hasDecl(Foo, "public_thing"));
@@ -24,6 +25,7 @@ test "@hasDecl" {
 }
 
 test "@hasDecl using a sliced string literal" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(@hasDecl(@This(), "Bar") == true);
diff --git a/test/behavior/hasfield.zig b/test/behavior/hasfield.zig
index 52680f1aa5ea2dc02d3e4bb9badc8542f583c53f..6536141db4317020391b95d9d4535ecc92c72006 100644
--- a/test/behavior/hasfield.zig
+++ b/test/behavior/hasfield.zig
@@ -2,6 +2,8 @@ const expect = @import("std").testing.expect;
 const builtin = @import("builtin");
 
 test "@hasField" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const struc = struct {
         a: i32,
         b: []u8,
diff --git a/test/behavior/if.zig b/test/behavior/if.zig
index 3d0d40a334f8b977a278ad68d9eecac9053a353c..bc79f52f12d40f3de1b73460a6ce1016c88bd465 100644
--- a/test/behavior/if.zig
+++ b/test/behavior/if.zig
@@ -4,6 +4,8 @@ const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 test "if statements" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     shouldBeEqual(1, 1);
     firstEqlThird(2, 1, 2);
 }
@@ -44,7 +46,7 @@ var global_with_val: anyerror!u32 = 0;
 var global_with_err: anyerror!u32 = error.SomeError;
 
 test "unwrap mutable global var" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     if (global_with_val) |v| {
@@ -94,6 +96,7 @@ test "const result loc, runtime if cond, else unreachable" {
 }
 
 test "if copies its payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -131,7 +134,7 @@ test "if prongs cast to expected type instead of peer type resolution" {
 test "if peer expressions inferred optional type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var self: []const u8 = "abcdef";
     var index: usize = 0;
@@ -147,6 +150,7 @@ test "if peer expressions inferred optional type" {
 }
 
 test "if-else expression with runtime condition result location is inferred optional" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -158,6 +162,8 @@ test "if-else expression with runtime condition result location is inferred opti
 }
 
 test "result location with inferred type ends up being pointer to comptime_int" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var a: ?u32 = 1234;
     var b: u32 = 2000;
     _ = .{ &a, &b };
@@ -186,6 +192,7 @@ fn returnTrue() bool {
 }
 
 test "if value shouldn't be load-elided if used later (structs)" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const Foo = struct { x: i32 };
@@ -205,6 +212,7 @@ test "if value shouldn't be load-elided if used later (structs)" {
 }
 
 test "if value shouldn't be load-elided if used later (optionals)" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     var a: ?i32 = 1;
diff --git a/test/behavior/import_c_keywords.zig b/test/behavior/import_c_keywords.zig
index 3e17e30b37a7382924095ca8b175843bfc115c47..c22bc5caacf45aba6c393166ccf82e06ad45d3f4 100644
--- a/test/behavior/import_c_keywords.zig
+++ b/test/behavior/import_c_keywords.zig
@@ -29,7 +29,7 @@ extern fn an_alias_of_some_non_c_keyword_function() Id;
 test "import c keywords" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
diff --git a/test/behavior/incomplete_struct_param_tld.zig b/test/behavior/incomplete_struct_param_tld.zig
index 0dc585820f7220d4458e55ca7b3caf39c1c12580..02facd1e11a127a0100ac7d01205a4499f225382 100644
--- a/test/behavior/incomplete_struct_param_tld.zig
+++ b/test/behavior/incomplete_struct_param_tld.zig
@@ -23,7 +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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = A{
         .b = B{
diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig
index 54c41f4fac3bd5c1a386a95b55a590c257aa1afe..05b025059c189f960824ba4036c786b30821d8f0 100644
--- a/test/behavior/inline_switch.zig
+++ b/test/behavior/inline_switch.zig
@@ -3,6 +3,7 @@ const expect = std.testing.expect;
 const builtin = @import("builtin");
 
 test "inline scalar prongs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x: usize = 0;
@@ -42,6 +43,7 @@ test "inline switch enums" {
 
 const U = union(E) { a: void, b: u2, c: u3, d: u4 };
 test "inline switch unions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     var x: U = .a;
@@ -67,6 +69,7 @@ test "inline switch unions" {
 }
 
 test "inline else bool" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     var a = true;
     _ = &a;
@@ -89,6 +92,7 @@ test "inline else error" {
 }
 
 test "inline else enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };
@@ -134,6 +138,8 @@ test "inline else int all values" {
 }
 
 test "inline switch capture is set when switch operand is comptime known" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U2 = union(enum) {
         a: u32,
     };
diff --git a/test/behavior/int128.zig b/test/behavior/int128.zig
index f02aed4f90c68d6676404aed8e728b2b9a4916ba..6404c8636e8e290abb2e402aee13b9ed99eb5557 100644
--- a/test/behavior/int128.zig
+++ b/test/behavior/int128.zig
@@ -5,6 +5,7 @@ const minInt = std.math.minInt;
 const builtin = @import("builtin");
 
 test "uint128" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -25,7 +26,7 @@ test "uint128" {
 test "undefined 128 bit int" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     @setRuntimeSafety(true);
@@ -42,6 +43,7 @@ test "undefined 128 bit int" {
 }
 
 test "int128" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -66,7 +68,7 @@ test "int128" {
 test "truncate int128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     {
@@ -87,6 +89,7 @@ test "truncate int128" {
 }
 
 test "shift int128" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
diff --git a/test/behavior/int_comparison_elision.zig b/test/behavior/int_comparison_elision.zig
index 31dad143ec0a11b82867d46b0768e9e884b31735..0b22694064afef212bd3d845c4ecdf5d67fad3ce 100644
--- a/test/behavior/int_comparison_elision.zig
+++ b/test/behavior/int_comparison_elision.zig
@@ -4,6 +4,7 @@ const maxInt = std.math.maxInt;
 const builtin = @import("builtin");
 
 test "int comparison elision" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     testIntEdges(u0);
@@ -14,7 +15,7 @@ test "int comparison elision" {
 
     // TODO: support int types > 128 bits wide in other backends
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // TODO: panic: integer overflow with int types > 65528 bits wide
     // TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide
diff --git a/test/behavior/ir_block_deps.zig b/test/behavior/ir_block_deps.zig
index 4708af87f4bd27060125a8e2c0e111e0996badab..c5406ee7f3bf1c85b9f91b9402378bd31f56b503 100644
--- a/test/behavior/ir_block_deps.zig
+++ b/test/behavior/ir_block_deps.zig
@@ -18,6 +18,7 @@ fn getErrInt() anyerror!i32 {
 }
 
 test "ir block deps" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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/lower_strlit_to_vector.zig b/test/behavior/lower_strlit_to_vector.zig
index 11998d7d96034511002eb80053d851488fd385e3..22b563403f7c290a98293aeb3478921065da9ea0 100644
--- a/test/behavior/lower_strlit_to_vector.zig
+++ b/test/behavior/lower_strlit_to_vector.zig
@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 test "strlit to vector" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const strlit = "0123456789abcdef0123456789ABCDEF";
     const vec_from_strlit: @Vector(32, u8) = strlit.*;
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index 78b409af179da2308d225bb6f4d62389e8e8d1c2..bd486e8f3b9327259f5ac4c609592471c72c6164 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -10,6 +10,7 @@ const mem = std.mem;
 const math = std.math;
 
 test "assignment operators" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -40,6 +41,8 @@ test "assignment operators" {
 }
 
 test "three expr in a row" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testThreeExprInARow(false, true);
     try comptime testThreeExprInARow(false, true);
 }
@@ -64,7 +67,7 @@ fn assertFalse(b: bool) !void {
 test "@clz small" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     try testClzSmall();
@@ -82,7 +85,7 @@ fn testClzSmall() !void {
 test "@clz big ints" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testClzBigInts();
@@ -102,7 +105,7 @@ test "@clz vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testClzVectors();
@@ -143,7 +146,7 @@ test "@ctz small" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCtzSmall();
     try comptime testCtzSmall();
@@ -165,7 +168,7 @@ fn testOneCtz(comptime T: type, x: T) u32 {
 test "@ctz 128-bit 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testCtz128();
@@ -184,7 +187,7 @@ test "@ctz vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCtzVectors();
     try comptime testCtzVectors();
@@ -258,6 +261,8 @@ test "quad hex float literal parsing in range" {
 }
 
 test "underscore separator parsing" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try expect(1_234_567 == 1234567);
     try expect(1_234_567 == 1234567);
     try expect(1_2_3_4_5_6_7 == 1234567);
@@ -334,6 +339,7 @@ test "comptime_int multi-limb partial shift right" {
 }
 
 test "xor" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try test_xor();
@@ -382,6 +388,7 @@ fn not(comptime T: type, a: T) T {
 }
 
 test "binary not" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(not(u0, 0) == 0);
@@ -421,6 +428,7 @@ test "binary not" {
 }
 
 test "binary not big int <= 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -456,7 +464,8 @@ test "division" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     try testIntDivision();
     try comptime testIntDivision();
 
@@ -629,7 +638,7 @@ test "large integer division" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     {
@@ -650,7 +659,7 @@ test "division half-precision floats" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testDivisionFP16();
     try comptime testDivisionFP16();
@@ -737,6 +746,7 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {
 }
 
 test "negation wrapping" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -750,6 +760,7 @@ fn negateWrap(comptime T: type, x: T) T {
 }
 
 test "unsigned 64-bit division" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -791,7 +802,7 @@ fn testShrTrunc(x: u16) !void {
 test "f128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try test_f128();
@@ -817,6 +828,7 @@ fn should_not_be_zero(x: f128) !void {
 }
 
 test "umax wrapped squaring" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -873,6 +885,7 @@ test "umax wrapped squaring" {
 }
 
 test "128-bit multiplication" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -905,6 +918,7 @@ fn testAddWithOverflow(comptime T: type, a: T, b: T, add: T, bit: u1) !void {
 }
 
 test "@addWithOverflow" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest; // TODO
@@ -923,6 +937,7 @@ test "@addWithOverflow" {
 }
 
 test "@addWithOverflow <= 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -968,7 +983,7 @@ test "@addWithOverflow > 128 bits" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     try testAddWithOverflow(u129, 4, 105, 109, 0);
     try testAddWithOverflow(u129, 1000, 100, 1100, 0);
@@ -1008,6 +1023,7 @@ test "@addWithOverflow > 128 bits" {
 }
 
 test "small int addition" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest; // TODO
@@ -1036,6 +1052,7 @@ fn testMulWithOverflow(comptime T: type, a: T, b: T, mul: T, bit: u1) !void {
 }
 
 test "basic @mulWithOverflow" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest; // TODO
@@ -1048,6 +1065,7 @@ test "basic @mulWithOverflow" {
 }
 
 test "extensive @mulWithOverflow" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1087,6 +1105,7 @@ test "extensive @mulWithOverflow" {
 }
 
 test "@mulWithOverflow bitsize > 32" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1123,6 +1142,7 @@ fn testMutiplyUnwrap(comptime T: type, wrapped_a: anyerror!T, comptime b: T, exp
 }
 
 test "Multiply unwrap error * immediate" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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;
@@ -1139,7 +1159,7 @@ test "@mulWithOverflow bitsize 128 bits" {
     if (builtin.zig_backend == .stage2_riscv64) 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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0);
     try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1);
@@ -1162,7 +1182,7 @@ test "@mulWithOverflow bitsize 128 bits" {
 
 test "@mulWithOverflow > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMulWithOverflow(u140, 0, maxInt(u140), 0, 0);
     try testMulWithOverflow(u140, 1, maxInt(u140), maxInt(u140), 0);
@@ -1191,7 +1211,7 @@ test "@mulWithOverflow > 128 bits" {
 
 test "@mulWithOverflow bitsize 256 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     {
@@ -1235,6 +1255,7 @@ fn testSubWithOverflow(comptime T: type, a: T, b: T, sub: T, bit: u1) !void {
 }
 
 test "@subWithOverflow" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1251,6 +1272,7 @@ test "@subWithOverflow" {
 }
 
 test "@subWithOverflow <= 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1294,7 +1316,7 @@ test "@subWithOverflow > 128 bits" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     try testSubWithOverflow(u129, 4, 105, maxInt(u129) - 100, 1);
     try testSubWithOverflow(u129, 1000, 100, 900, 0);
@@ -1340,7 +1362,7 @@ fn testShlWithOverflow(comptime T: type, a: T, b: math.Log2Int(T), shl: T, bit:
 test "@shlWithOverflow" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testShlWithOverflow(u4, 2, 1, 4, 0);
@@ -1359,7 +1381,7 @@ test "@shlWithOverflow" {
 test "@shlWithOverflow > 64 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 7, 0x0_8000_0000_0000_0000, 0);
@@ -1385,7 +1407,7 @@ test "@shlWithOverflow > 64 bits" {
 
 test "@shlWithOverflow > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testShlWithOverflow(u140, 1 << 100, 20, 1 << 120, 0);
     try testShlWithOverflow(u140, 1 << 100, 40, 0, 1);
@@ -1413,6 +1435,7 @@ fn testAnd(comptime T: type, a: T, b: T, expected: T) !void {
 }
 
 test "and > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testAnd(u140, (1 << 139) | (1 << 70) | 0xaa, (1 << 139) | (1 << 69) | 0xcc, (1 << 139) | 0x88);
@@ -1441,6 +1464,7 @@ fn testOr(comptime T: type, a: T, b: T, expected: T) !void {
 }
 
 test "or > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testOr(u140, 0, 1 << 139, 1 << 139);
@@ -1469,6 +1493,7 @@ fn testXor(comptime T: type, a: T, b: T, expected: T) !void {
 }
 
 test "xor > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testXor(u140, 0, maxInt(u140), maxInt(u140));
@@ -1497,6 +1522,7 @@ fn testNot(comptime T: type, a: T, expected: T) !void {
 }
 
 test "not > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testNot(u140, 0, maxInt(u140));
@@ -1525,6 +1551,7 @@ fn testShl(comptime T: type, a: T, b: std.math.Log2Int(T), expected: T) !void {
 }
 
 test "shl > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testShl(u140, 1 << 5, 10, 1 << 15);
@@ -1553,6 +1580,7 @@ fn testShr(comptime T: type, a: T, b: std.math.Log2Int(T), expected: T) !void {
 }
 
 test "shr > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testShr(u140, 1 << 139, 39, 1 << 100);
@@ -1582,7 +1610,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testClz(u140, 0, 140);
     try testClz(u140, 1 << 139, 0);
@@ -1611,7 +1639,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testCtz(u140, 0, 140);
     try testCtz(u140, 1 << 139, 139);
@@ -1640,7 +1668,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testPopCount(u140, 0, 0);
     try testPopCount(u140, maxInt(u140), 140);
@@ -1669,7 +1697,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testBitReverse(u140, 1 << 139, 1);
     try testBitReverse(u140, 1 << 70, 1 << 69);
@@ -1698,7 +1726,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testByteSwap(u144, 1 << 136, 1);
     try testByteSwap(u144, 1, 1 << 136);
@@ -1727,7 +1755,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMax(u140, 0, maxInt(u140), maxInt(u140));
     try testMax(u140, 1 << 139, 1 << 138, 1 << 139);
@@ -1756,7 +1784,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMin(u140, 0, maxInt(u140), 0);
     try testMin(u140, 1 << 139, 1 << 138, 1 << 138);
@@ -1784,6 +1812,7 @@ fn testAbs(comptime T: type, a: T, expected: anytype) !void {
 }
 
 test "@abs > 128 bits" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     try testAbs(u140, 0, 0);
@@ -1808,7 +1837,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testRem(u140, 0, maxInt(u140), 0);
     try testRem(u140, maxInt(u140), maxInt(u140), 0);
@@ -1835,7 +1864,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMod(u140, 0, maxInt(u140), 0);
     try testMod(u140, maxInt(u140), maxInt(u140), 0);
@@ -1862,7 +1891,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testDivFloor(u140, 0, maxInt(u140), 0);
     try testDivFloor(u140, maxInt(u140), maxInt(u140), 1);
@@ -1890,7 +1919,7 @@ fn testDivCeil(comptime T: type, numerator: T, denominator: T, expected: T) !voi
 
 test "@divCeil > 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testDivCeil(u140, 0, maxInt(u140), 0);
     try testDivCeil(u140, maxInt(u140), maxInt(u140), 1);
@@ -1918,7 +1947,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testDivTrunc(u140, 0, maxInt(u140), 0);
     try testDivTrunc(u140, maxInt(u140), maxInt(u140), 1);
@@ -1941,6 +1970,8 @@ test "@divTrunc > 128 bits" {
 }
 
 test "overflow arithmetic with u0 values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     {
         var a: u0 = 0;
         _ = &a;
@@ -1972,6 +2003,8 @@ test "overflow arithmetic with u0 values" {
 }
 
 test "allow signed integer division/remainder when values are comptime-known and positive or exact" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try expect(5 / 3 == 1);
     try expect(-5 / -3 == 1);
     try expect(-6 / 3 == -2);
@@ -1983,7 +2016,7 @@ test "allow signed integer division/remainder when values are comptime-known and
 test "quad hex float literal parsing accurate" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const a: f128 = 0x1.1111222233334444555566667777p+0;
@@ -2089,6 +2122,7 @@ fn testShlTrunc(x: u16) !void {
 }
 
 test "exact shift left" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testShlExact(0b00110101);
@@ -2141,7 +2175,7 @@ test "remainder division" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_x86_64 and builtin.object_format == .coff and builtin.abi != .gnu) return error.SkipZigTest;
@@ -2174,7 +2208,7 @@ fn remdivOne(comptime T: type, a: T, b: T, c: T) !void {
 test "float remainder division using @rem" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime frem(f16);
@@ -2216,7 +2250,7 @@ test "float modulo division using @mod" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_x86_64 and builtin.object_format == .coff and builtin.abi != .gnu) return error.SkipZigTest;
@@ -2284,7 +2318,7 @@ test "@round f32/f64" {
 test "@round f80" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testRound(f80, 12.0);
@@ -2294,7 +2328,7 @@ test "@round f80" {
 test "@round f128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testRound(f128, 12.0);
@@ -2312,7 +2346,7 @@ test "vector integer addition" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -2332,7 +2366,7 @@ test "vector integer addition" {
 test "NaN comparison" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testNanEqNan(f16);
@@ -2348,7 +2382,7 @@ test "NaN comparison" {
 test "NaN comparison f80" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testNanEqNan(f80);
@@ -2372,7 +2406,7 @@ test "vector comparison" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -2401,7 +2435,7 @@ test "compare undefined literal with comptime_int" {
 test "signed zeros are represented properly" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -2463,7 +2497,7 @@ test "@clz works on both vector and scalar inputs" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: u32 = 0x1;
     _ = &x;
@@ -2478,7 +2512,7 @@ test "@clz works on both vector and scalar inputs" {
 test "runtime comparison to NaN is comptime-known" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -2534,7 +2568,7 @@ test "float divide by zero" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_x86_64 and builtin.object_format == .coff and builtin.abi != .gnu) return error.SkipZigTest;
 
@@ -2569,7 +2603,7 @@ test "partially-runtime integer vector division would be illegal if vector eleme
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
 
     var lhs: @Vector(2, i8) = .{ -128, 5 };
@@ -2593,6 +2627,7 @@ test "partially-runtime integer vector division would be illegal if vector eleme
 }
 
 test "float vector division of comptime zero by runtime nan is nan" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -2613,6 +2648,7 @@ test "float vector multiplication of comptime zero by runtime nan is nan" {
     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.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     const ct_zero: @Vector(1, f32) = .{0};
     var rt_nan: @Vector(1, f32) = .{math.nan(f32)};
@@ -2649,7 +2685,7 @@ test "comptime float vector multiplication of zero by nan is nan" {
 }
 
 test "i96 operations" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // This is coverage for some stuff used by std.Io timestamps, to catch
     // issues earlier than bootstrapping.
diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig
index 533f44869573a924e50a08b3806a03c4243fc7ee..8fe5678d9c7cd8155985c678be957eaa624e3b39 100644
--- a/test/behavior/maximum_minimum.zig
+++ b/test/behavior/maximum_minimum.zig
@@ -6,6 +6,7 @@ const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 test "@max" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -31,7 +32,7 @@ test "@max on vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -62,6 +63,7 @@ test "@min" {
     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.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
 
     const S = struct {
         fn doTheTest() !void {
@@ -84,7 +86,7 @@ test "@min for vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -114,7 +116,7 @@ test "@min for vectors" {
 test "@min/max for floats" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -151,6 +153,8 @@ test "@min/@max on lazy values" {
 }
 
 test "@min/@max more than two arguments" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const x: u32 = 30;
     const y: u32 = 10;
     const z: u32 = 20;
@@ -159,7 +163,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.cpu.arch.isSpirv()) 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
@@ -173,6 +177,7 @@ test "@min/@max more than two vector arguments" {
 }
 
 test "@min/@max notices bounds" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -189,7 +194,7 @@ test "@min/@max notices bounds" {
 }
 
 test "@min/@max notices vector bounds" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -221,6 +226,7 @@ test "@min/@max on comptime_int" {
 }
 
 test "@min/@max notices bounds from types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -240,7 +246,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.cpu.arch.isSpirv()) 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
@@ -281,6 +287,7 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {
 }
 
 test "@min/@max notices bounds from vector types when element of comptime-known vector is undef" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -303,6 +310,8 @@ test "@min/@max notices bounds from vector types when element of comptime-known
 }
 
 test "@min/@max of signed and unsigned runtime integers" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x: i32 = -1;
     var y: u31 = 1;
     _ = .{ &x, &y };
@@ -348,7 +357,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.cpu.arch.isSpirv()) 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/member_func.zig b/test/behavior/member_func.zig
index 3626e391aca9bf599840903de085413309884991..62561307ab5b8915a45549dd7ab53b78404a6660 100644
--- a/test/behavior/member_func.zig
+++ b/test/behavior/member_func.zig
@@ -29,7 +29,7 @@ const HasFuncs = struct {
 test "standard field calls" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(HasFuncs.one(0) == 1);
     try expect(HasFuncs.two(0) == 2);
@@ -72,7 +72,7 @@ test "standard field calls" {
 test "@field field calls" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(@field(HasFuncs, "one")(0) == 1);
     try expect(@field(HasFuncs, "two")(0) == 2);
diff --git a/test/behavior/memcpy.zig b/test/behavior/memcpy.zig
index cd2cdeda583c4c986271094d71957344044223fe..cc75d99cb8bc74c261c595f8c7d0ee0fc4c9f7f1 100644
--- a/test/behavior/memcpy.zig
+++ b/test/behavior/memcpy.zig
@@ -6,7 +6,7 @@ const assert = std.debug.assert;
 test "memcpy and memset intrinsics" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemcpyMemset();
     try comptime testMemcpyMemset();
@@ -27,7 +27,7 @@ fn testMemcpyMemset() !void {
 test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
     try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();
@@ -47,7 +47,7 @@ fn testMemcpyBothSinglePtrArrayOneIsNullTerminated() !void {
 test "@memcpy dest many pointer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemcpyDestManyPtr();
     try comptime testMemcpyDestManyPtr();
@@ -69,7 +69,7 @@ fn testMemcpyDestManyPtr() !void {
 test "@memcpy C pointer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemcpyCPointer();
     try comptime testMemcpyCPointer();
@@ -90,7 +90,7 @@ test "@memcpy slice" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemcpySlice();
     try comptime testMemcpySlice();
@@ -133,7 +133,7 @@ test "@memcpy comptime-only type" {
 }
 
 test "@memcpy zero-bit type with aliasing" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() void {
@@ -153,7 +153,7 @@ test "@memcpy zero-bit type with aliasing" {
 
 test "@memcpy with sentinel" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() void {
@@ -182,6 +182,8 @@ test "@memcpy no sentinel source into sentinel destination" {
 }
 
 test "@memcpy a global array" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         var array_u8: [1]u8 = .{1};
         const slice_u8: []u8 = &array_u8;
diff --git a/test/behavior/memmove.zig b/test/behavior/memmove.zig
index c2a8d7427098483506ae7f4ba7a9b11cfcc45e3c..01efeb52e8d828dbf318147b144bd35e8a7f8c26 100644
--- a/test/behavior/memmove.zig
+++ b/test/behavior/memmove.zig
@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 test "memmove and memset intrinsics" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testMemmoveMemset();
@@ -32,7 +32,7 @@ fn testMemmoveMemset() !void {
 test "@memmove with both operands single-ptr-to-array, one is null-terminated" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testMemmoveBothSinglePtrArrayOneIsNullTerminated();
@@ -75,7 +75,7 @@ fn testMemmoveBothSinglePtrArrayOneIsNullTerminated() !void {
 test "@memmove dest many pointer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testMemmoveDestManyPtr();
@@ -117,7 +117,7 @@ test "@memmove slice" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testMemmoveSlice();
@@ -172,6 +172,8 @@ comptime {
 }
 
 test "@memmove a global array" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         var array_u8: [1]u8 = .{1};
         const slice_u8: []u8 = &array_u8;
diff --git a/test/behavior/memset.zig b/test/behavior/memset.zig
index ffe62f20352b5edd7d9748b90970289e223e1505..4a9e3b09bad440084c9ab0bd5a52bfa671d27b5f 100644
--- a/test/behavior/memset.zig
+++ b/test/behavior/memset.zig
@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 test "@memset on array pointers" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemsetArray();
     try comptime testMemsetArray();
@@ -33,7 +33,7 @@ fn testMemsetArray() !void {
 test "@memset preserves array sentinel" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testMemsetArraySentinel();
     try comptime testMemsetArraySentinel();
@@ -55,7 +55,7 @@ fn testMemsetArraySentinel() !void {
 test "@memset on slices" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testMemsetSlice();
@@ -90,7 +90,7 @@ fn testMemsetSlice() !void {
 test "memset with bool element" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [5]bool = undefined;
     @memset(&buf, true);
@@ -101,7 +101,7 @@ test "memset with bool element" {
 test "memset with 1-byte struct element" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct { x: bool };
     var buf: [5]S = undefined;
@@ -113,7 +113,7 @@ test "memset with 1-byte struct element" {
 test "memset with 1-byte array element" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const A = [1]bool;
     var buf: [5]A = undefined;
@@ -126,7 +126,7 @@ test "memset with large array element, runtime known" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const A = [128]u64;
@@ -144,7 +144,7 @@ test "memset with large array element, runtime known" {
 test "memset with large array element, comptime known" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const A = [128]u64;
@@ -161,7 +161,7 @@ test "memset with large array element, comptime known" {
 test "@memset provides result type" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct { x: u32 };
@@ -179,7 +179,7 @@ test "@memset provides result type" {
 test "zero keys with @memset" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Keys = struct {
         up: bool,
@@ -201,7 +201,7 @@ test "@memset with zero-length array" {
 }
 
 test "@memset a global array" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var array_u8: [1]u8 = .{1};
@@ -232,7 +232,7 @@ test "@memset a global array" {
 }
 
 test "@memset array of booleans" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var x: bool = false;
diff --git a/test/behavior/merge_error_sets.zig b/test/behavior/merge_error_sets.zig
index 492cb276999f508d6010eef7bb9fdee7c60a2717..e686857fbaa42ad7004af2c5b940ac8235522c91 100644
--- a/test/behavior/merge_error_sets.zig
+++ b/test/behavior/merge_error_sets.zig
@@ -12,6 +12,7 @@ fn foo() C!void {
 }
 
 test "merge error sets" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     if (foo()) {
diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig
index bde6459e849c14384d69fc57811f59b747a0f2de..d107048cfce5bb984fe217ecd0243069373683e2 100644
--- a/test/behavior/muladd.zig
+++ b/test/behavior/muladd.zig
@@ -48,7 +48,7 @@ fn testMulAdd16() !void {
 test "@mulAdd f80" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime testMulAdd80();
@@ -66,7 +66,7 @@ fn testMulAdd80() !void {
 test "@mulAdd f128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime testMulAdd128();
@@ -95,6 +95,7 @@ fn vector16() !void {
 }
 
 test "vector f16" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -118,6 +119,7 @@ fn vector32() !void {
 }
 
 test "vector f32" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -141,6 +143,7 @@ fn vector64() !void {
 }
 
 test "vector f64" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -166,7 +169,7 @@ test "vector f80" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector80();
@@ -190,7 +193,7 @@ test "vector f128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector128();
diff --git a/test/behavior/multiple_externs_with_conflicting_types.zig b/test/behavior/multiple_externs_with_conflicting_types.zig
index e0965665b697b61d10017da94ace744150ba7c91..8aee34abbe41803febaeb0e37a7ef4aae42c37e0 100644
--- a/test/behavior/multiple_externs_with_conflicting_types.zig
+++ b/test/behavior/multiple_externs_with_conflicting_types.zig
@@ -5,7 +5,7 @@ const A = extern struct {
 extern fn issue529(?*A) void;
 
 comptime {
-    if (builtin.zig_backend != .stage2_spirv) {
+    if (!builtin.cpu.arch.isSpirv()) {
         _ = @import("conflicting_externs/b.zig");
     }
 }
@@ -15,7 +15,7 @@ const builtin = @import("builtin");
 test "call extern function defined with conflicting 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     @import("conflicting_externs/a.zig").issue529(null);
diff --git a/test/behavior/nan.zig b/test/behavior/nan.zig
index b96fe1a6497a7b894a0965fe2da9ef925c5d9f9f..43b7ea2e0b04adccdf24fc3c045c3b07a366c28c 100644
--- a/test/behavior/nan.zig
+++ b/test/behavior/nan.zig
@@ -24,7 +24,7 @@ const snan_f128: f128 = math.snan(f128);
 test "nan memory equality" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // signaled
     try testing.expect(mem.eql(u8, mem.asBytes(&snan_u16), mem.asBytes(&snan_f16)));
diff --git a/test/behavior/null.zig b/test/behavior/null.zig
index ba9ce5127b9539b2e00b85486d33ac28a141d3de..268fa6fdadcfd2a9c458f83b0da38579df0dc2c5 100644
--- a/test/behavior/null.zig
+++ b/test/behavior/null.zig
@@ -29,6 +29,7 @@ test "optional type" {
 }
 
 test "test maybe object and get a pointer to the inner value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -50,6 +51,7 @@ test "rhs maybe unwrap return" {
 }
 
 test "maybe return" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -69,6 +71,7 @@ fn foo(x: ?i32) ?bool {
 }
 
 test "test null runtime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -130,7 +133,7 @@ test "null with default unwrap" {
 
 test "optional pointer to 0 bit type null value at runtime" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const EmptyStruct = struct {};
     var x: ?*EmptyStruct = null;
@@ -139,6 +142,7 @@ test "optional pointer to 0 bit type null value at runtime" {
 }
 
 test "if var maybe pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -183,7 +187,7 @@ const SillyStruct = struct {
 const here_is_a_null_literal = SillyStruct{ .context = null };
 
 test "unwrap optional which is field of global var" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index f19877ab5c151db2d3d82532bb59c75c961a5e56..d6b147d37bb4d29eaf9c5850713ddbfdfae38191 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -7,6 +7,7 @@ const expectEqual = testing.expectEqual;
 const expectEqualStrings = std.testing.expectEqualStrings;
 
 test "passing an optional integer as a parameter" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -28,7 +29,7 @@ pub const EmptyStruct = struct {};
 
 test "optional pointer to size zero struct" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var e = EmptyStruct{};
     const o: ?*EmptyStruct = &e;
@@ -36,7 +37,7 @@ test "optional pointer to size zero struct" {
 }
 
 test "equality compare optional pointers" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testNullPtrsEql();
     try comptime testNullPtrsEql();
@@ -94,7 +95,7 @@ test "optional error equality" {
 
 test "optional with zero-bit type" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime ZeroBit: type, comptime zero_bit: ZeroBit) !void {
@@ -147,7 +148,7 @@ test "address of unwrap optional" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Foo = struct {
@@ -166,6 +167,7 @@ test "address of unwrap optional" {
 }
 
 test "nested optional field in struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -183,6 +185,7 @@ test "nested optional field in struct" {
 }
 
 test "equality compare optionals and non-optionals" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -242,6 +245,7 @@ test "equality compare optionals and non-optionals" {
 }
 
 test "compare optionals with modified payloads" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var lhs: ?bool = false;
@@ -269,7 +273,7 @@ test "compare optionals with modified payloads" {
 
 test "unwrap function call with optional pointer return value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -290,6 +294,7 @@ test "unwrap function call with optional pointer return value" {
 }
 
 test "nested orelse" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -318,7 +323,7 @@ test "nested orelse" {
 test "self-referential struct through a slice of optional" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Node = struct {
@@ -351,6 +356,7 @@ test "assigning to an unwrapped optional field in an inline loop" {
 }
 
 test "coerce an anon struct literal to optional struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -369,6 +375,7 @@ test "coerce an anon struct literal to optional struct" {
 }
 
 test "0-bit child type coerced to optional return ptr result location" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     const S = struct {
@@ -395,7 +402,7 @@ test "0-bit child type coerced to optional return ptr result location" {
 test "0-bit child type coerced to optional" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     const S = struct {
         fn doTheTest() !void {
             var it: Foo = .{
@@ -419,6 +426,7 @@ test "0-bit child type coerced to optional" {
 }
 
 test "array of optional unaligned types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -454,6 +462,7 @@ test "array of optional unaligned types" {
 }
 
 test "optional pointer to zero bit optional payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -475,7 +484,7 @@ test "optional pointer to zero bit optional payload" {
 test "optional pointer to zero bit error union 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const B = struct {
@@ -509,7 +518,7 @@ const NoReturn = struct {
 };
 
 test "optional of noreturn used with if" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     NoReturn.a = 64;
@@ -521,7 +530,7 @@ test "optional of noreturn used with if" {
 }
 
 test "optional of noreturn used with orelse" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     NoReturn.a = 64;
@@ -551,6 +560,7 @@ test "orelse on C pointer" {
 }
 
 test "alignment of wrapping an optional payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -571,7 +581,7 @@ test "alignment of wrapping an optional payload" {
 test "Optional slice size is optimized" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
     var a: ?[]const u8 = null;
@@ -584,7 +594,7 @@ test "Optional slice passed to function" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(a: ?[]const u8) !void {
@@ -599,6 +609,7 @@ test "Optional slice passed to function" {
 }
 
 test "peer type resolution in nested if expressions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const Thing = struct { n: i32 };
@@ -626,7 +637,7 @@ test "peer type resolution in nested if expressions" {
 test "cast slice to const slice nested in error union and optional" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -647,6 +658,7 @@ test "variable of optional of noreturn" {
 }
 
 test "copied optional doesn't alias source" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -664,7 +676,7 @@ test "result location initialization of optional with OPV payload" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -697,6 +709,8 @@ test "global comptime only optional" {
 }
 
 test "optional ptr payload alignment" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(p: *align(1) ?u32) !void {
             comptime assert(@TypeOf(&p.*.?) == *align(1) u32);
diff --git a/test/behavior/overlapping_assign.zig b/test/behavior/overlapping_assign.zig
index 74425a8fab1c7c2799b91e8b2d1e98a893a72885..5381a1d9da17b6ff832e8ecadbe52342d267d756 100644
--- a/test/behavior/overlapping_assign.zig
+++ b/test/behavior/overlapping_assign.zig
@@ -3,7 +3,7 @@ const std = @import("std");
 const expect = std.testing.expect;
 
 test "assignment to overlapping memory" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try theTest();
     try comptime theTest();
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 82256ba7782d503b1c476a28785841aba3bf4bbc..499db3ca181112c6dd1dc3edc9c44a0e61b24175 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -119,6 +119,7 @@ test "consistent size of packed structs" {
 }
 
 test "correct sizeOf and offsets in packed structs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -183,6 +184,7 @@ test "correct sizeOf and offsets in packed structs" {
 }
 
 test "nested packed structs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -225,6 +227,7 @@ test "nested packed structs" {
 }
 
 test "regular in irregular packed struct" {
+    if (builtin.cpu.arch.isSpirv()) 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_aarch64) return error.SkipZigTest;
@@ -247,7 +250,8 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S1 = packed struct {
         a: u4,
         b: u4,
@@ -316,7 +320,7 @@ test "nested packed struct unaligned" {
 test "byte-aligned field pointer offsets" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = struct {
@@ -403,7 +407,7 @@ test "nested packed struct field pointers" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
     const S2 = packed struct {
         base: u8,
@@ -438,7 +442,7 @@ test "nested packed struct field pointers" {
 test "@intFromPtr on a packed struct field" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const P = packed struct {
@@ -459,7 +463,7 @@ test "@intFromPtr on a packed struct field" {
 test "@intFromPtr on a packed struct field unaligned and nested" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S1 = packed struct {
         a: u4,
@@ -555,7 +559,7 @@ test "packed struct fields modification" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     // Originally reported at https://github.com/ziglang/zig/issues/16615
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Small = packed struct(u16) {
         val: u8 = 0,
@@ -580,7 +584,7 @@ test "packed struct fields modification" {
 test "nested packed struct field access test" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -698,7 +702,7 @@ test "nested packed struct field access test" {
 
 test "nested packed struct at non-zero offset" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const Pair = packed struct(u24) {
@@ -730,7 +734,7 @@ test "nested packed struct at non-zero offset 2" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -792,6 +796,7 @@ test "nested packed struct at non-zero offset 2" {
 }
 
 test "runtime init of unnamed packed struct type" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -810,7 +815,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Packed = packed struct(u64) {
@@ -835,7 +840,7 @@ test "packed struct passed to callconv(.c) function" {
 test "overaligned pointer to packed struct" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = packed struct { a: u32, b: u32 };
@@ -862,7 +867,7 @@ test "pointer to container level packed struct field" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = packed struct(u32) {
@@ -885,6 +890,7 @@ test "pointer to container level packed struct field" {
 }
 
 test "store undefined to packed result location" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     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;
@@ -907,6 +913,7 @@ test "bitcast back and forth" {
 
 // Originally reported at https://github.com/ziglang/zig/issues/14200
 test "field access of packed struct smaller than its abi size inside struct initialized with rls" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
@@ -929,7 +936,7 @@ test "modify nested packed struct aligned field" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Options = packed struct {
         foo: bool = false,
@@ -958,7 +965,7 @@ test "modify nested packed struct aligned field" {
 test "assigning packed struct inside another packed struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Inner = packed struct {
@@ -1001,6 +1008,7 @@ test "packed struct acts as a namespace" {
 }
 
 test "assignment to non-byte-aligned field in packed struct" {
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest; // TODO
@@ -1023,7 +1031,7 @@ test "assignment to non-byte-aligned field in packed struct" {
 test "packed struct field pointer aligned properly" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     const Foo = packed struct {
         a: i32,
@@ -1039,6 +1047,7 @@ test "packed struct field pointer aligned properly" {
 }
 
 test "load flag from packed struct in union" {
+    if (builtin.cpu.arch.isSpirv()) 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_arm) return error.SkipZigTest; // TODO
@@ -1116,7 +1125,7 @@ test "2-byte packed struct argument in C calling convention" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = packed struct(u16) {
         x: u15 = 0,
@@ -1162,6 +1171,7 @@ test "packed struct equality" {
 }
 
 test "packed struct equality ignores padding bits" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = packed struct { b: bool };
@@ -1172,6 +1182,7 @@ test "packed struct equality ignores padding bits" {
 }
 
 test "packed struct with signed field" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     var s: packed struct {
@@ -1184,6 +1195,7 @@ test "packed struct with signed field" {
 }
 
 test "assign packed struct initialized with RLS to packed struct literal field" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -1200,6 +1212,7 @@ test "assign packed struct initialized with RLS to packed struct literal field"
 }
 
 test "packed struct store of comparison result" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
@@ -1250,6 +1263,7 @@ test "convert from/to backing int" {
 }
 
 test "equality with wide backing integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/35982
 
     const S = packed struct(i200) {
diff --git a/test/behavior/packed-union.zig b/test/behavior/packed-union.zig
index 91166a0a596640a92d882b5b8aa0b1a835391e2d..8a899532e7472640f701d9e98c1683d97135ffb0 100644
--- a/test/behavior/packed-union.zig
+++ b/test/behavior/packed-union.zig
@@ -8,7 +8,7 @@ test "flags in packed union" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     try testFlagsInPackedUnion();
@@ -51,7 +51,7 @@ test "flags in packed union at offset" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     try testFlagsInPackedUnionAtOffset();
@@ -107,7 +107,7 @@ fn testFlagsInPackedUnionAtOffset() !void {
 test "packed union in packed struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testPackedUnionInPackedStruct();
     try comptime testPackedUnionInPackedStruct();
@@ -144,7 +144,7 @@ test "packed union initialized with a runtime 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_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Fields = packed struct {
         timestamp: u50,
@@ -182,7 +182,7 @@ test "assigning to non-active field at comptime" {
 test "packed union with explicit backing integer" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = packed union(i32) {
         raw: i32,
@@ -201,7 +201,7 @@ test "packed union with explicit backing integer" {
 }
 
 test "packed union equality" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Foo = packed union {
         a: u4,
@@ -229,7 +229,7 @@ test "initialize packed union field to undefined at comptime" {
 }
 
 test "convert from/to backing int" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = packed union(u10) {
         a: i10,
@@ -246,7 +246,7 @@ test "convert from/to backing int" {
 
 test "equality with wide backing integer" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/35982
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = packed union(i200) {
         x: u200,
diff --git a/test/behavior/packed_struct_explicit_backing_int.zig b/test/behavior/packed_struct_explicit_backing_int.zig
index 84255d05853bafec6b1c19f6a6d9f4ead35c88d2..567fb8fb54dae49a751fa0b13982313481a5ac80 100644
--- a/test/behavior/packed_struct_explicit_backing_int.zig
+++ b/test/behavior/packed_struct_explicit_backing_int.zig
@@ -5,6 +5,7 @@ const expectEqual = std.testing.expectEqual;
 const native_endian = builtin.cpu.arch.endian();
 
 test "packed struct explicit backing integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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/pointers.zig b/test/behavior/pointers.zig
index 67316d9619890852230d6d4928e38a7823d4dc41..0c004eaad3b542f4387cc81e11bd258eb4873c43 100644
--- a/test/behavior/pointers.zig
+++ b/test/behavior/pointers.zig
@@ -20,7 +20,7 @@ fn testDerefPtr() !void {
 test "pointer-integer arithmetic" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var ptr: [*]const u8 = "abcd";
 
@@ -45,7 +45,7 @@ test "pointer-integer arithmetic" {
 
 test "pointer subtraction" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     {
         const a: *u8 = @ptrFromInt(100);
@@ -100,7 +100,7 @@ test "pointer subtraction" {
 }
 
 test "pointer arithmetic with non-trivial RHS" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var t: bool = undefined;
     t = true;
@@ -126,7 +126,7 @@ fn PtrOf(comptime T: type) type {
 
 test "implicit cast single item pointer to C pointer and back" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var y: u8 = 11;
     const x: [*c]u8 = &y;
@@ -143,7 +143,7 @@ test "initialize const optional C pointer to null" {
 
 test "assigning integer to C pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     var x: i32 = 0;
     var y: i32 = 1;
     var ptr: [*c]u8 = 0;
@@ -160,7 +160,7 @@ test "assigning integer to C pointer" {
 
 test "C pointer comparison and arithmetic" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -204,7 +204,7 @@ fn testDerefPtrOneVal() !void {
 }
 
 test "peer type resolution with C pointers" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const ptr_one: *u8 = undefined;
     const ptr_many: [*]u8 = undefined;
@@ -222,6 +222,7 @@ test "peer type resolution with C pointers" {
 }
 
 test "peer type resolution with C pointer and const pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     var ptr_c: [*c]u8 = undefined;
     var ptr_const: *const u8 = &undefined;
     _ = .{ &ptr_c, &ptr_const };
@@ -232,7 +233,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var slice: []const u8 = "aoeu";
     _ = &slice;
@@ -247,7 +248,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
 test "implicit cast error unions with non-optional to optional pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -276,7 +277,7 @@ test "allowzero pointer and slice" {
     if (builtin.zig_backend == .stage2_c) 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var ptr: [*]allowzero i32 = @ptrFromInt(0);
     const opt_ptr: ?[*]allowzero i32 = ptr;
@@ -295,7 +296,7 @@ test "allowzero pointer and slice" {
 test "assign null directly to C pointer and test null equality" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: [*c]i32 = null;
     _ = &x;
@@ -353,6 +354,8 @@ test "assign null directly to C pointer and test null equality" {
 }
 
 test "array initialization types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const E = enum { A, B, C };
     try expect(@TypeOf([_]u8{}) == [0]u8);
     try expect(@TypeOf([_:0]u8{}) == [0:0]u8);
@@ -362,7 +365,7 @@ test "array initialization types" {
 
 test "null terminated pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -380,7 +383,7 @@ test "null terminated pointer" {
 test "allow any sentinel" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -396,7 +399,7 @@ test "allow any sentinel" {
 test "pointer sentinel with enums" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Number = enum {
@@ -419,7 +422,7 @@ test "pointer sentinel with optional element" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -436,7 +439,7 @@ test "pointer sentinel with +inf" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -458,7 +461,7 @@ test "pointer to array at fixed address" {
 }
 
 test "pointer-integer arithmetic affects the alignment" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     {
         var ptr: [*]align(8) u32 = undefined;
@@ -507,7 +510,7 @@ test "@intFromPtr on null optional at comptime" {
 test "indexing array with sentinel returns correct 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var s: [:0]const u8 = "abc";
     try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
@@ -515,7 +518,7 @@ test "indexing array with sentinel returns correct type" {
 
 test "element pointer to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -537,7 +540,7 @@ test "element pointer to slice" {
 
 test "element pointer arithmetic to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -562,7 +565,7 @@ test "element pointer arithmetic to slice" {
 
 test "array slicing to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -592,7 +595,7 @@ test "pointer to constant decl preserves alignment" {
 test "ptrCast comptime known slice to C pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s: [:0]const u8 = "foo";
     var p: [*c]const u8 = @ptrCast(s);
@@ -611,7 +614,7 @@ test "pointer alignment and element type include call expression" {
 }
 
 test "pointer to array has explicit alignment" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Base = extern struct { a: u8 };
@@ -636,6 +639,8 @@ test "result type preserved through multiple references" {
 }
 
 test "result type found through optional pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const ptr1: ?*const u32 = &@intCast(123);
     const ptr2: ?[]const u8 = &.{ @intCast(123), @truncate(0xABCD) };
     try expect(ptr1.?.* == 123);
@@ -688,14 +693,15 @@ fn constant() !void {
 
 test "pointer-to-array constness for zero-size elements, var" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     try mutable();
     try comptime mutable();
 }
 
 test "pointer-to-array constness for zero-size elements, const" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try constant();
     try comptime constant();
@@ -735,7 +741,7 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const buf: [2]u32 = .{ 123, 456 };
 
@@ -749,7 +755,7 @@ test "comptime pointer equality through distinct elements with well-defined layo
 }
 
 test "pointers to elements of slice of zero-bit type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var slice: []const u0 = undefined;
     slice = &.{ 0, 0 };
@@ -761,7 +767,7 @@ test "pointers to elements of slice of zero-bit type" {
 }
 
 test "pointers to elements of many-ptr to zero-bit type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var many_ptr: [*]const u0 = undefined;
     many_ptr = &.{ 0, 0 };
@@ -773,6 +779,8 @@ test "pointers to elements of many-ptr to zero-bit type" {
 }
 
 test "comptime C pointer to optional pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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/popcount.zig b/test/behavior/popcount.zig
index b68ca6602f7e142d348695d9f0aaa9e2095a2964..d641b4d00b0cd91157070de7d9cdd2102f61d6b3 100644
--- a/test/behavior/popcount.zig
+++ b/test/behavior/popcount.zig
@@ -6,7 +6,7 @@ const expectEqual = std.testing.expectEqual;
 test "@popCount 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     try comptime testPopCountIntegers();
@@ -17,7 +17,7 @@ test "@popCount 128bit integer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     comptime {
@@ -79,7 +79,7 @@ test "@popCount vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime testPopCountVectors();
diff --git a/test/behavior/prefetch.zig b/test/behavior/prefetch.zig
index df3220f750c86793a13cf8bf4359865718c037ea..ee4dfb8c8d229db421c69790b21c9162a9947f14 100644
--- a/test/behavior/prefetch.zig
+++ b/test/behavior/prefetch.zig
@@ -2,7 +2,7 @@ const builtin = @import("builtin");
 const std = @import("std");
 
 test "@prefetch()" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: [2]u32 = .{ 42, 42 };
     var a_len = a.len;
diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig
index d468fd7ceb962c8b26dc6775330a98bf678dedcc..5fa0b16afd157347c871011efc35e46a30eaae8d 100644
--- a/test/behavior/ptrcast.zig
+++ b/test/behavior/ptrcast.zig
@@ -6,7 +6,7 @@ const native_endian = builtin.target.cpu.arch.endian();
 
 test "reinterpret bytes as integer with nonzero offset" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testReinterpretBytesAsInteger();
     try comptime testReinterpretBytesAsInteger();
@@ -22,6 +22,7 @@ fn testReinterpretBytesAsInteger() !void {
 }
 
 test "reinterpret an array over multiple elements, with no well-defined layout" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -39,7 +40,7 @@ fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void {
 
 test "reinterpret bytes inside auto-layout struct as integer with nonzero offset" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testReinterpretStructWrappedBytesAsInteger();
     try comptime testReinterpretStructWrappedBytesAsInteger();
@@ -57,7 +58,7 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
 
 test "reinterpret bytes of an array into an extern struct" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testReinterpretBytesAsExternStruct();
     try comptime testReinterpretBytesAsExternStruct();
@@ -171,7 +172,7 @@ test "lower reinterpreted comptime field ptr" {
 
 test "reinterpret struct field at comptime" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const numNative = comptime Bytes.init(0x12345678);
     if (native_endian != .little) {
@@ -194,7 +195,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;
+    if (builtin.cpu.arch.isSpirv()) 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)];
@@ -229,7 +230,7 @@ test "ptrcast of const integer has the correct object size" {
 test "implicit optional pointer to optional anyopaque pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [4]u8 = "aoeu".*;
     const x: ?[*]u8 = &buf;
@@ -241,7 +242,7 @@ test "implicit optional pointer to optional anyopaque pointer" {
 test "@ptrCast slice to slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(slice: []u32) []i32 {
@@ -281,6 +282,8 @@ test "@ptrCast undefined value at comptime" {
 }
 
 test "comptime @ptrCast with packed struct leaves value unmodified" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = packed struct { three: u3 };
     const st: S = .{ .three = 6 };
     try expect(st.three == 6);
@@ -332,7 +335,7 @@ test "@ptrCast restructures comptime-only array" {
 }
 
 test "@ptrCast restructures sliced comptime-only array" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a3a2: [4][2]comptime_int = .{
         .{ 1, 2 },
@@ -351,7 +354,7 @@ test "@ptrCast restructures sliced comptime-only array" {
 test "@ptrCast slice multiplying length" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(zero: u32) !void {
@@ -368,7 +371,7 @@ test "@ptrCast slice multiplying length" {
 test "@ptrCast array pointer to slice multiplying length" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(zero: u32) !void {
@@ -385,7 +388,7 @@ test "@ptrCast array pointer to slice multiplying length" {
 test "@ptrCast slice dividing length" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(zero: u8) !void {
@@ -402,7 +405,7 @@ test "@ptrCast slice dividing length" {
 test "@ptrCast array pointer to slice dividing length" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(zero: u8) !void {
@@ -419,7 +422,7 @@ test "@ptrCast array pointer to slice dividing length" {
 test "@ptrCast slice with complex length increase" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const TwoBytes = [2]u8;
     const ThreeBytes = [3]u8;
@@ -439,7 +442,7 @@ test "@ptrCast slice with complex length increase" {
 test "@ptrCast array pointer to slice with complex length increase" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const TwoBytes = [2]u8;
     const ThreeBytes = [3]u8;
@@ -459,7 +462,7 @@ test "@ptrCast array pointer to slice with complex length increase" {
 test "@ptrCast slice with complex length decrease" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const TwoBytes = [2]u8;
     const ThreeBytes = [3]u8;
@@ -479,7 +482,7 @@ test "@ptrCast slice with complex length decrease" {
 test "@ptrCast array pointer to slice with complex length decrease" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const TwoBytes = [2]u8;
     const ThreeBytes = [3]u8;
@@ -499,7 +502,7 @@ test "@ptrCast array pointer to slice with complex length decrease" {
 test "@ptrCast slice of zero-bit type to different slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime T: type, zero_bits: []const T) !void {
@@ -518,7 +521,7 @@ test "@ptrCast slice of zero-bit type to different slice" {
 test "@ptrCast single-item pointer to slice with length 1" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime T: type, ptr: *const T) !void {
@@ -538,7 +541,7 @@ test "@ptrCast single-item pointer to slice with length 1" {
 test "@ptrCast single-item pointer to slice of bytes" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime T: type, ptr: *const T) !void {
diff --git a/test/behavior/ptrfromint.zig b/test/behavior/ptrfromint.zig
index f72e64f87f74ce2f177273a9d7ead40ff5495678..726c82903cea8c633e095d47d1d96048fb5b1680 100644
--- a/test/behavior/ptrfromint.zig
+++ b/test/behavior/ptrfromint.zig
@@ -3,7 +3,7 @@ const builtin = @import("builtin");
 const expectEqual = std.testing.expectEqual;
 
 test "casting integer address to function pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     addressToFunction();
     comptime addressToFunction();
@@ -18,7 +18,7 @@ fn addressToFunction() void {
 test "mutate through ptr initialized with constant ptrFromInt value" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
 }
@@ -35,13 +35,14 @@ fn forceCompilerAnalyzeBranchHardCodedPtrDereference(x: bool) void {
 test "@ptrFromInt creates null pointer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const ptr = @as(?*u32, @ptrFromInt(0));
     try expectEqual(@as(?*u32, null), ptr);
 }
 
 test "@ptrFromInt creates allowzero zero pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
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 95448a382c305b7cccbd6dfae870d1037ced4732..f6de33cae8355285e84749e84e680cdad4f94607 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
@@ -7,7 +7,7 @@ var ok: bool = false;
 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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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 c5f5d8eff3cc866589528af6e53ce2751dfc1457..65dc78c057223e5e8665df3791e31d37fd302442 100644
--- a/test/behavior/reflection.zig
+++ b/test/behavior/reflection.zig
@@ -26,6 +26,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
 }
 
 test "reflection: @field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var f = Foo{
diff --git a/test/behavior/return_address.zig b/test/behavior/return_address.zig
index d7fb76d3b09459e157f9b17013fbcec6bef20b01..1c3035cd5ec86922935326c7a598f1bd13c83351 100644
--- a/test/behavior/return_address.zig
+++ b/test/behavior/return_address.zig
@@ -8,7 +8,7 @@ fn retAddr() usize {
 test "return address" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     _ = retAddr();
     // TODO: #14938
diff --git a/test/behavior/saturating_arithmetic.zig b/test/behavior/saturating_arithmetic.zig
index c5fa221c124d4113a73db22ab33778e521a9c52a..9b7206a71821fd9eb339c6874bbcfeae9b7246a4 100644
--- a/test/behavior/saturating_arithmetic.zig
+++ b/test/behavior/saturating_arithmetic.zig
@@ -16,7 +16,7 @@ test "saturating add" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -55,7 +55,7 @@ test "saturating add 128bit" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -82,7 +82,7 @@ test "saturating subtraction" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -120,7 +120,7 @@ test "saturating subtraction 128bit" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -143,7 +143,7 @@ fn testSatMul(comptime T: type, a: T, b: T, expected: T) !void {
 test "saturating multiplication <= 32 bits" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testSatMul(u8, 0, maxInt(u8), 0);
@@ -207,7 +207,7 @@ test "saturating multiplication <= 32 bits" {
 test "saturating mul i64, i128" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSatMul(i64, 0, maxInt(i64), 0);
     try testSatMul(i64, 0, minInt(i64), 0);
@@ -236,7 +236,7 @@ test "saturating multiplication" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -276,7 +276,7 @@ test "saturating shift-left" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -312,7 +312,7 @@ test "saturating shift-left" {
 test "saturating shift-left large rhs" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
 
     {
@@ -330,7 +330,7 @@ test "saturating shl uses the LHS type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const lhs_const: u8 = 1;
@@ -358,7 +358,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSatAdd(u140, 0, 0, 0);
     try testSatAdd(u140, maxInt(u140), 1, maxInt(u140));
@@ -373,7 +373,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSatSub(u140, 0, 1, 0);
     try testSatSub(u140, maxInt(u140), maxInt(u140), 0);
@@ -388,7 +388,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSatMul(u140, 0, maxInt(u140), 0);
     try testSatMul(u140, 1 << 70, 1 << 69, 1 << 139);
@@ -403,7 +403,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSatShl(u140, 0, u8, 17, 0);
     try testSatShl(u140, 1 << 100, u8, 20, 1 << 120);
diff --git a/test/behavior/select.zig b/test/behavior/select.zig
index 0bac089d7be2db12da742b2b45b8141075805e38..f63dfce29ec1a6e1ff3b1823df010624ef14d30f 100644
--- a/test/behavior/select.zig
+++ b/test/behavior/select.zig
@@ -8,7 +8,7 @@ test "@select vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try comptime selectVectors();
     try selectVectors();
@@ -52,7 +52,7 @@ test "@select arrays" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try comptime selectArrays();
     try selectArrays();
diff --git a/test/behavior/shuffle.zig b/test/behavior/shuffle.zig
index 0ba5f6f72882c0f3e5ec029198b429f99f7810dd..727ebe10110cee6c849d95bbfb1423597a670bf8 100644
--- a/test/behavior/shuffle.zig
+++ b/test/behavior/shuffle.zig
@@ -9,7 +9,7 @@ test "@shuffle int" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -50,6 +50,7 @@ test "@shuffle int" {
 }
 
 test "@shuffle int strange sizes" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -133,7 +134,8 @@ test "@shuffle bool 1" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             var x: @Vector(4, bool) = [4]bool{ false, true, false, true };
@@ -154,7 +156,7 @@ test "@shuffle bool 2" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index 9e881ff480fbad959f7c8479ec771786c88881bc..ee1c0dfe727a2fbcfcc0a59c2fb39bbf307eb389 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -12,6 +12,8 @@ const x: u16 = 13;
 const z: @TypeOf(x) = 19;
 
 test "@TypeOf() with multiple arguments" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     {
         var var_1: u32 = undefined;
         var var_2: u8 = undefined;
@@ -73,7 +75,7 @@ const P = packed struct {
 
 test "@offsetOf" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // Packed structs have fixed memory layout
     try expect(@offsetOf(P, "a") == 0);
@@ -100,6 +102,7 @@ test "@offsetOf" {
 }
 
 test "@bitOffsetOf" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     // Packed structs have fixed memory layout
@@ -134,7 +137,7 @@ test "@TypeOf() has no runtime side effects" {
 }
 
 test "branching logic inside @TypeOf" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const S = struct {
@@ -150,6 +153,8 @@ test "branching logic inside @TypeOf" {
 }
 
 test "@bitSizeOf" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try expect(@bitSizeOf(u2) == 2);
     try expect(@bitSizeOf(u8) == @sizeOf(u8) * 8);
     try expect(@bitSizeOf(packed struct {
@@ -158,6 +163,8 @@ test "@bitSizeOf" {
 }
 
 test "@sizeOf comparison against zero" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S0 = struct {
         f: *@This(),
     };
@@ -240,6 +247,7 @@ test "lazy size cast to float" {
 }
 
 test "runtime instructions inside typeof in comptime only scope" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -288,7 +296,8 @@ test "lazy abi size used in comparison" {
 
 test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const T = struct {
         next: @TypeOf(null, @as(*const @This(), undefined)),
     };
@@ -327,11 +336,11 @@ const exp = struct {
     }
 };
 comptime {
-    if (builtin.zig_backend != .stage2_spirv) _ = exp;
+    if (!builtin.cpu.arch.isSpirv()) _ = exp;
 }
 
 test "Extern function calls in @TypeOf" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = extern struct {
         state: c_short,
@@ -382,6 +391,7 @@ test "Peer resolution of extern function calls in @TypeOf" {
 }
 
 test "Extern function calls, dereferences and field access in @TypeOf" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const Test = struct {
@@ -406,7 +416,7 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
 }
 
 test "@sizeOf struct is resolved when used as operand of slicing" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const dummy = struct {};
     const S = struct {
diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig
index 6f521a724349c176e5ff693c521394d0fca9d73b..a93bee2c56e5ed25d88f4711d339f846fd1a006b 100644
--- a/test/behavior/slice.zig
+++ b/test/behavior/slice.zig
@@ -30,7 +30,7 @@ comptime {
 
 test "slicing" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var array: [20]i32 = undefined;
 
@@ -59,7 +59,7 @@ test "const slice" {
 }
 
 test "comptime slice of undefined pointer of length 0" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const slice1 = @as([*]i32, undefined)[0..0];
     try expect(slice1.len == 0);
@@ -69,7 +69,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var msg = [_]u8{};
     try assertLenIsZero(&msg);
@@ -81,7 +81,7 @@ fn assertLenIsZero(msg: []const u8) !void {
 
 test "access len index of sentinel-terminated slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -105,7 +105,7 @@ test "comptime slice of slice preserves comptime var" {
 
 test "open slice of open slice with sentinel" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var slice: [:0]const u8 = "hello";
     _ = &slice;
@@ -123,7 +123,7 @@ test "open slice of open slice with sentinel" {
 
 test "open slice with sentinel of slice with end index" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var slice: [:0]const u8 = "hello";
     _ = &slice;
@@ -162,6 +162,8 @@ test "slice of type" {
 }
 
 test "pass a slice of types to a function" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn checkTypesSlice(comptime types_slice: []const type) !void {
             try expect(types_slice.len == 2);
@@ -175,7 +177,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const a = memAlloc(u8, 10) catch unreachable;
     memFree(u8, a);
@@ -189,7 +191,8 @@ fn memFree(comptime T: type, memory: []T) void {
 }
 
 test "slice of hardcoded address to pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             const pointer = @as([*]u8, @ptrFromInt(0x04))[0..2];
@@ -213,7 +216,7 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
 
@@ -229,7 +232,8 @@ test "comptime pointer cast array and then slice" {
 
 test "slicing zero length array" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const s1 = ""[0..];
     const s2 = ([_]u32{})[0..];
     try expect(s1.len == 0);
@@ -239,7 +243,7 @@ test "slicing zero length array" {
 }
 
 test "slicing pointer by length" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
     const ptr: [*]const u8 = @as([*]const u8, @ptrCast(&array));
@@ -254,6 +258,8 @@ test "slicing pointer by length" {
 const x = @as([*]i32, @ptrFromInt(0x1000))[0..0x500];
 const y = x[0x100..];
 test "compile time slice of pointer to hard coded address" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try expect(@intFromPtr(x) == 0x1000);
     try expect(x.len == 0x500);
 
@@ -262,7 +268,7 @@ test "compile time slice of pointer to hard coded address" {
 }
 
 test "slice string literal has correct type" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     comptime {
         try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
@@ -278,7 +284,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = struct {
         entries: []u32,
@@ -291,7 +297,7 @@ test "result location zero sized array inside struct field implicit cast to slic
 test "runtime safety lets us slice from len..len" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var an_array = [_]u8{ 1, 2, 3 };
     try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
@@ -303,7 +309,7 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
 
 test "C pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
     var len: u32 = 10;
@@ -315,7 +321,7 @@ test "C pointer" {
 test "C pointer slice access" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [10]u32 = @splat(42);
     const c_ptr = @as([*c]const u32, @ptrCast(&buf));
@@ -345,7 +351,7 @@ fn sliceSum(comptime q: []const u8) i32 {
 
 test "slice type with custom alignment" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const LazilyResolvedType = struct {
         anything: i32,
@@ -359,7 +365,7 @@ test "slice type with custom alignment" {
 
 test "obtaining a null terminated slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // here we have a normal array
     var buf: [50]u8 = undefined;
@@ -385,6 +391,8 @@ test "obtaining a null terminated slice" {
 }
 
 test "empty array to slice" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             const empty: []align(16) u8 = &[_]u8{};
@@ -422,7 +430,7 @@ test "comptime-known slice of a global constant" {
 
 test "@ptrCast slice to pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -439,7 +447,7 @@ test "@ptrCast slice to pointer" {
 
 test "slice multi-pointer without end" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -477,7 +485,7 @@ test "slice multi-pointer without end" {
 test "slice syntax resulting in pointer-to-array" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -692,7 +700,7 @@ test "slice syntax resulting in pointer-to-array" {
 
 test "slice pointer-to-array null terminated" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     comptime {
         var array = [5:0]u8{ 1, 2, 3, 4, 5 };
@@ -711,7 +719,7 @@ test "slice pointer-to-array null terminated" {
 
 test "slice pointer-to-array zero length" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     comptime {
         {
@@ -745,7 +753,7 @@ test "slice pointer-to-array zero length" {
 test "type coercion of pointer to anon struct literal to pointer to slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const U = union {
@@ -792,7 +800,7 @@ test "array concat of slices gives ptr to array" {
 
 test "slice bounds in comptime concatenation" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const bs = comptime blk: {
         const b = "........1........";
@@ -808,6 +816,8 @@ test "slice bounds in comptime concatenation" {
 }
 
 test "slice sentinel access at comptime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     {
         const str0 = &[_:0]u8{ '1', '2', '3' };
         const slice0: [:0]const u8 = str0;
@@ -833,7 +843,8 @@ test "slice sentinel access at comptime" {
 
 test "slicing array with sentinel as end index" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         fn do() !void {
             var array = [_:0]u8{ 1, 2, 3, 4 };
@@ -850,7 +861,7 @@ test "slicing array with sentinel as end index" {
 
 test "slicing slice with sentinel as end index" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn do() !void {
@@ -879,7 +890,8 @@ test "slice len modification at comptime" {
 }
 
 test "slice field ptr const" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const const_slice: []const u8 = "string";
 
     const const_ptr_const_slice = &const_slice;
@@ -909,7 +921,7 @@ test "global slice field access" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var slice: []const u8 = undefined;
@@ -921,7 +933,7 @@ test "global slice field access" {
 }
 
 test "slice of void" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var n: usize = 10;
     _ = &n;
@@ -931,7 +943,7 @@ test "slice of void" {
 }
 
 test "slice with dereferenced value" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: usize = 0;
     const idx: *usize = &a;
@@ -947,7 +959,7 @@ test "slice with dereferenced value" {
 }
 
 test "empty slice ptr is non null" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // Test assumes `undefined` is non-zero
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Test assumes `undefined` is non-zero
 
     {
         const empty_slice: []u8 = &[_]u8{};
@@ -965,7 +977,7 @@ test "empty slice ptr is non null" {
 
 test "slice decays to many pointer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var buf: [8]u8 = "abcdefg\x00".*;
     const p: [*:0]const u8 = buf[0..7 :0];
@@ -975,7 +987,7 @@ test "slice decays to many pointer" {
 test "write through pointer to optional slice arg" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn bar(foo: *?[]const u8) !void {
@@ -994,7 +1006,7 @@ test "write through pointer to optional slice arg" {
 test "modify slice length at comptime" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const arr: [2]u8 = .{ 10, 20 };
     comptime var s: []const u8 = arr[0..0];
@@ -1009,7 +1021,7 @@ test "modify slice length at comptime" {
 
 test "slicing zero length array field of struct" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1024,7 +1036,7 @@ test "slicing zero length array field of struct" {
 
 test "slicing slices gives correct result" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const foo = "1234";
     const bar = foo[0..4];
@@ -1037,7 +1049,7 @@ test "slicing slices gives correct result" {
 
 test "get address of element of zero-sized slice" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn destroy(_: *void) void {}
@@ -1049,7 +1061,7 @@ test "get address of element of zero-sized slice" {
 
 test "sentinel-terminated 0-length slices" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
 
@@ -1068,7 +1080,7 @@ test "sentinel-terminated 0-length slices" {
 }
 
 test "peer slices keep abi alignment with empty struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var cond: bool = undefined;
     cond = false;
@@ -1078,7 +1090,7 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const sentinel = std.math.maxInt(u16);
 
@@ -1101,7 +1113,7 @@ test "sentinel expression in slice operation has result type" {
 }
 
 test "conditionally return second argument slice" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn foo(cond: bool, slice: []const u8) []const u8 {
@@ -1115,7 +1127,7 @@ test "conditionally return second argument slice" {
 }
 
 test "slice field alignment" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(p: *align(1) const []u8) !void {
diff --git a/test/behavior/spirv.zig b/test/behavior/spirv.zig
index dd8b6d093e01625c361288c76d1a6dce033d7561..c4d5222fcae50cd656c9e89a82be67fb58936152 100644
--- a/test/behavior/spirv.zig
+++ b/test/behavior/spirv.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 const Sampler = @SpirvType(.sampler);
@@ -50,6 +51,8 @@ test "@SpirvType" {
 }
 
 test "@ptrCast to first field type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const Inner = extern struct { a: u32 };
     const Outer = extern struct { a: Inner, b: u32 };
     var outer: Outer = undefined;
@@ -58,6 +61,8 @@ test "@ptrCast to first field type" {
 }
 
 test "@SpirvType equality" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try expect(@SpirvType(.sampler) == Sampler);
     try expect(@SpirvType(.{ .runtime_array = u32 }) == RuntimeArray);
     try expect(@SpirvType(.{ .sampled_image = Image }) == SampledImage);
diff --git a/test/behavior/splat.zig b/test/behavior/splat.zig
index e5ac1290ea93ee5debeee3f2231d74e7da5e8bc4..3c7475e95bbf4f73dd146a13b3e026d28ec196e2 100644
--- a/test/behavior/splat.zig
+++ b/test/behavior/splat.zig
@@ -5,6 +5,7 @@ const expect = std.testing.expect;
 const assert = std.debug.assert;
 
 test "@splat array" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -33,7 +34,7 @@ test "@splat array" {
 }
 
 test "@splat array with sentinel" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -56,7 +57,7 @@ test "@splat array with sentinel" {
 }
 
 test "@splat zero-length array" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -79,6 +80,7 @@ test "@splat zero-length array" {
 }
 
 test "splat with an error union or optional result type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = struct {
@@ -92,7 +94,7 @@ test "splat with an error union or optional result type" {
 }
 
 test "read/write through global variable array of struct fields initialized via splat" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -113,6 +115,7 @@ test "read/write through global variable array of struct fields initialized via
 }
 
 test "vector @splat" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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/src.zig b/test/behavior/src.zig
index 61c0467eb7fa2574829ed55d69148381f5107587..61897811d6689dabdaf5899a7f421a1e7ca14b90 100644
--- a/test/behavior/src.zig
+++ b/test/behavior/src.zig
@@ -18,7 +18,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 test "@src" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try doTheTest();
 }
diff --git a/test/behavior/string_literals.zig b/test/behavior/string_literals.zig
index 68861deda6462f3c46e799da19b9825572eaaab5..d7db9eee511b1645f622d973ea9574737a1f3e5e 100644
--- a/test/behavior/string_literals.zig
+++ b/test/behavior/string_literals.zig
@@ -7,7 +7,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
 
 test "@tagName() returns a string literal" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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));
@@ -20,7 +20,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
 
 test "@errorName() returns a string literal" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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));
@@ -33,7 +33,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
 
 test "@typeName() returns a string literal" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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.string_literals.TestType", type_name));
@@ -47,7 +47,7 @@ const expected_contents = "hello zig\n";
 test "@embedFile() returns a string literal" {
     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;
+    if (builtin.cpu.arch.isSpirv()) 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));
@@ -62,7 +62,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;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const src = testFnForSrc();
     try std.testing.expect([:0]const u8 == @TypeOf(src.file));
@@ -84,7 +84,7 @@ test "string literal pointer sentinel" {
 }
 
 test "sentinel slice of string literal" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const string = "Hello!\x00World!";
     try std.testing.expect(@TypeOf(string) == *const [13:0]u8);
@@ -102,7 +102,8 @@ test "Peer type resolution with string literals and unknown length u8 pointers"
 }
 
 test "including the sentinel when dereferencing a string literal" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     var var_str = "abc";
     const var_derefed = var_str[0 .. var_str.len + 1].*;
 
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 4c12786161707d848fa11627cc952c6b0a72b10c..e0dc857d2e1c60d4db98f7d6e8c41677cc12abdf 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -10,6 +10,7 @@ const maxInt = std.math.maxInt;
 top_level_field: i32,
 
 test "top level fields" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var instance = @This(){
@@ -43,6 +44,7 @@ const StructWithFields = struct {
 };
 
 test "non-packed struct has fields padded out to the required alignment" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const foo = StructWithFields{ .a = 5, .b = 1, .c = 10, .d = 2 };
@@ -66,6 +68,7 @@ const SmallStruct = struct {
 };
 
 test "lower unnamed constants" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var foo = SmallStruct{ .a = 1, .b = 255 };
@@ -88,7 +91,7 @@ const StructFoo = struct {
 test "structs" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo: StructFoo = undefined;
     @memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0);
@@ -106,6 +109,7 @@ fn testMutation(foo: *StructFoo) void {
 }
 
 test "struct byval assign" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var foo1: StructFoo = undefined;
@@ -170,6 +174,7 @@ const MemberFnTestFoo = struct {
 };
 
 test "call member function directly" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const instance = MemberFnTestFoo{ .x = 1234 };
@@ -178,6 +183,7 @@ test "call member function directly" {
 }
 
 test "store member function in variable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const instance = MemberFnTestFoo{ .x = 1234 };
@@ -187,6 +193,7 @@ test "store member function in variable" {
 }
 
 test "member functions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const r = MemberFnRand{ .seed = 1234 };
     try expect(r.getSeed() == 1234);
 }
@@ -198,6 +205,7 @@ const MemberFnRand = struct {
 };
 
 test "return struct byval from function" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const Bar = struct {
@@ -215,6 +223,7 @@ test "return struct byval from function" {
 }
 
 test "call method with mutable reference to struct with no fields" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     const S = struct {
         fn doC(s: *const @This()) bool {
             _ = s;
@@ -234,6 +243,7 @@ test "call method with mutable reference to struct with no fields" {
 }
 
 test "struct field init with catch" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -277,7 +287,7 @@ const Val = struct {
 
 test "struct point to self" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var root: Node = undefined;
     root.val.x = 1;
@@ -320,7 +330,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
 
 test "pass slice of empty struct to fn" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
 }
@@ -331,7 +341,7 @@ fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize {
 test "self-referencing struct via array member" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct {
         children: [1]*@This(),
@@ -342,6 +352,8 @@ test "self-referencing struct via array member" {
 }
 
 test "empty struct method call" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const es = EmptyStruct{};
     try expect(es.method() == 1234);
 }
@@ -355,7 +367,7 @@ const EmptyStruct = struct {
 test "align 1 field before self referential align 8 field as slice return type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const result = alloc(Expr);
     try expect(result.len == 0);
@@ -376,6 +388,7 @@ const APackedStruct = packed struct {
 };
 
 test "packed struct" {
+    if (builtin.cpu.arch.isSpirv()) 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_aarch64) return error.SkipZigTest;
@@ -401,7 +414,7 @@ const Foo96Bits = packed struct {
 
 test "packed struct 24bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest; // TODO
@@ -443,7 +456,7 @@ test "packed struct 24bits" {
 }
 
 test "runtime struct initialization of bitfield" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -486,7 +499,8 @@ test "packed struct fields are ordered from LSB to MSB" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     var all: u64 = 0x7765443322221111;
     var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;
     @memcpy(bytes[0..8], @as([*]u8, @ptrCast(&all)));
@@ -502,6 +516,7 @@ test "packed struct fields are ordered from LSB to MSB" {
 }
 
 test "implicit cast packed struct field to const ptr" {
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -523,6 +538,7 @@ test "implicit cast packed struct field to const ptr" {
 }
 
 test "zero-bit field in packed struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = packed struct {
@@ -537,7 +553,7 @@ test "packed struct with non-ABI-aligned 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_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = packed struct {
@@ -564,6 +580,7 @@ const bit_field_1 = BitField1{
 };
 
 test "bit field access" {
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -596,6 +613,7 @@ fn getC(data: *const BitField1) u2 {
 }
 
 test "default struct initialization fields" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -622,7 +640,7 @@ test "packed array 24bits" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     comptime {
         try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
@@ -686,6 +704,7 @@ const FooArrayOfAligned = packed struct {
 };
 
 test "pointer to packed struct member in a stack variable" {
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -715,7 +734,7 @@ test "packed struct with u0 field access" {
 }
 
 test "access to global struct fields" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     g_foo.bar.value = 42;
@@ -739,7 +758,7 @@ var g_foo: S0 = S0.init();
 test "packed struct with fp 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
@@ -766,6 +785,7 @@ test "packed struct with fp fields" {
 }
 
 test "fn with C calling convention returns struct by value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -792,7 +812,7 @@ test "fn with C calling convention returns struct by value" {
 test "non-packed struct with u128 entry in 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const U = union(enum) {
@@ -815,6 +835,7 @@ test "non-packed struct with u128 entry in union" {
 }
 
 test "packed struct field passed to generic function" {
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -839,6 +860,7 @@ test "packed struct field passed to generic function" {
 }
 
 test "anonymous struct literal syntax" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -862,6 +884,8 @@ test "anonymous struct literal syntax" {
 }
 
 test "fully anonymous struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             try dump(.{
@@ -884,6 +908,8 @@ test "fully anonymous struct" {
 }
 
 test "fully anonymous list literal" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
@@ -901,6 +927,8 @@ test "fully anonymous list literal" {
 }
 
 test "tuple assigned to variable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var vec = .{ @as(i32, 22), @as(i32, 55), @as(i32, 99) };
     _ = &vec;
     try expect(vec.@"0" == 22);
@@ -912,6 +940,7 @@ test "tuple assigned to variable" {
 }
 
 test "comptime struct field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const T = struct {
@@ -927,7 +956,7 @@ test "comptime struct field" {
 }
 
 test "tuple element initialized with fn call" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -945,6 +974,7 @@ test "tuple element initialized with fn call" {
 }
 
 test "struct with union field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -965,6 +995,7 @@ test "struct with union field" {
 }
 
 test "struct with 0-length union array field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -983,7 +1014,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.cpu.arch.isSpirv()) 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
@@ -1014,7 +1045,7 @@ test "packed struct with undefined initializers" {
 }
 
 test "for loop over pointers to struct, getting field from struct pointer" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1056,7 +1087,7 @@ test "anon init through error unions and optionals" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         a: u32,
@@ -1080,6 +1111,7 @@ test "anon init through error unions and optionals" {
 }
 
 test "anon init through optional" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1100,7 +1132,7 @@ test "anon init through optional" {
 test "anon init through error 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         a: u32,
@@ -1117,6 +1149,7 @@ test "anon init through error union" {
 }
 
 test "typed init through error unions and optionals" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -1143,6 +1176,7 @@ test "typed init through error unions and optionals" {
 }
 
 test "initialize struct with empty literal" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct { x: i32 = 1234 };
@@ -1152,6 +1186,7 @@ test "initialize struct with empty literal" {
 }
 
 test "loading a struct pointer perfoms a copy" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -1197,6 +1232,7 @@ test "packed struct aggregate init" {
 }
 
 test "packed struct field access via pointer" {
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -1237,6 +1273,7 @@ test "store to comptime field" {
 }
 
 test "struct field init value is size of the struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const namespace = struct {
@@ -1253,7 +1290,7 @@ test "struct field init value is size of the struct" {
 test "under-aligned struct 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const U = extern union {
@@ -1275,7 +1312,7 @@ test "under-aligned struct field" {
 
 test "fieldParentPtr of a zero-bit field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1323,7 +1360,7 @@ test "fieldParentPtr of a zero-bit field" {
 }
 
 test "struct field has a pointer to an aligned version of itself" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = struct {
         next: *align(1) @This(),
@@ -1335,7 +1372,7 @@ test "struct field has a pointer to an aligned version of itself" {
 }
 
 test "struct has only one reference" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn optionalStructParam(_: ?struct { x: u8 }) void {}
@@ -1384,7 +1421,7 @@ test "struct has only one reference" {
 
 test "no dependency loop on pointer to optional struct" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const A = struct { b: B };
@@ -1404,7 +1441,7 @@ test "discarded struct initialization works as expected" {
 }
 
 test "function pointer in struct returns the struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const A = struct {
         const A = @This();
@@ -1420,7 +1457,7 @@ test "function pointer in struct returns the struct" {
 }
 
 test "no dependency loop on optional field wrapped in generic function" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn Atomic(comptime T: type) type {
@@ -1438,6 +1475,7 @@ test "no dependency loop on optional field wrapped in generic function" {
 }
 
 test "optional field init with tuple" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -1452,6 +1490,8 @@ test "optional field init with tuple" {
 }
 
 test "if inside struct init inside if" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const MyStruct = struct { x: u32 };
     const b: u32 = 5;
     var i: u32 = 1;
@@ -1478,7 +1518,7 @@ test "optional generic function label struct field" {
 }
 
 test "struct fields get automatically reordered" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S1 = struct {
@@ -1539,7 +1579,7 @@ test "instantiate struct with comptime field" {
 test "struct field pointer has correct alignment" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1568,7 +1608,7 @@ test "struct field pointer has correct alignment" {
 test "extern struct field pointer has correct alignment" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1617,6 +1657,8 @@ fn countFields(v: anytype) usize {
 }
 
 test "struct init with no result pointer sets field result types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         // A function parameter has a result type, but no result pointer.
         fn f(s: struct { x: u32 }) u32 {
@@ -1631,6 +1673,8 @@ test "struct init with no result pointer sets field result types" {
 }
 
 test "runtime side-effects in comptime-known struct init" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var side_effects: u4 = 0;
     const S = struct { a: u4, b: u4, c: u4, d: u4 };
     const init = S{
@@ -1656,7 +1700,7 @@ test "runtime side-effects in comptime-known struct init" {
 }
 
 test "pointer to struct initialized through reference to anonymous initializer provides result types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct { a: u8, b: u16, c: *const anyopaque };
     var my_u16: u16 = 0xABCD;
@@ -1693,6 +1737,8 @@ test "comptimeness of optional and error union payload is analyzed properly" {
 }
 
 test "initializer uses own alignment" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         x: u32 = @alignOf(@This()) + 1,
     };
@@ -1704,6 +1750,8 @@ test "initializer uses own alignment" {
 }
 
 test "initializer uses own size" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         x: u32 = @sizeOf(@This()) + 1,
     };
@@ -1715,7 +1763,7 @@ test "initializer uses own size" {
 }
 
 test "initializer takes a pointer to a variable inside its struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const namespace = struct {
         const S = struct {
@@ -1735,7 +1783,7 @@ test "initializer takes a pointer to a variable inside its struct" {
 }
 
 test "circular dependency through pointer field of a struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const StructInner = extern struct {
@@ -1758,7 +1806,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         x: u32 = blk: {
@@ -1787,6 +1835,7 @@ test "tuple with comptime-only field" {
 }
 
 test "extern struct fields are aligned to 1" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const Foo = extern struct {
@@ -1806,7 +1855,7 @@ test "assign to slice.len of global variable" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1819,6 +1868,8 @@ test "assign to slice.len of global variable" {
 }
 
 test "pointers to fields of volatile pointer to struct are also volatile" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const B = extern struct {
         a: u32,
         b: i32,
@@ -1833,6 +1884,8 @@ test "pointers to fields of volatile pointer to struct are also volatile" {
 }
 
 test "pointers to fields of volatile pointer to union are also volatile" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const D = extern union {
         a: u32,
         b: i32,
@@ -1856,7 +1909,7 @@ test "array of structs inside struct initialized with undefined" {
 
 test "runtime call in nested initializer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Holder = struct {
         array: []const u8,
@@ -1886,6 +1939,7 @@ test "runtime call in nested initializer" {
 }
 
 test "runtime value in nested initializer passed as pointer to function" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const Bar = struct {
@@ -1909,7 +1963,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1943,6 +1997,8 @@ test "struct field default value is a call" {
 }
 
 test "aggregate initializers should allow initializing comptime fields, verifying equality" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x: u32 = 15;
     _ = &x;
     const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
@@ -1954,6 +2010,7 @@ test "aggregate initializers should allow initializing comptime fields, verifyin
 }
 
 test "assignment of field with padding" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1983,7 +2040,7 @@ test "assignment of field with padding" {
 }
 
 test "initiate global variable with runtime value" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2002,7 +2059,7 @@ test "initiate global variable with runtime value" {
 }
 
 test "struct containing optional pointer to array of @This()" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         x: ?*const [1]@This(),
@@ -2075,6 +2132,7 @@ test "anonymous struct equivalence" {
 }
 
 test "field access through mem ptr arg" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -2118,7 +2176,7 @@ test "field access through mem ptr arg" {
 }
 
 test "align 1 struct parameter dereferenced and returned" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = extern struct {
         a: u32,
@@ -2169,7 +2227,8 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const A = struct {
         a: *anyopaque,
         b: u64,
@@ -2219,7 +2278,8 @@ test "overaligned extern struct fields" {
 }
 
 test "runtime-known slice of comptime-only struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const Mixed = struct { index: u32, T: type };
 
     const static = struct {
@@ -2241,7 +2301,8 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const Slab = struct {
         const Ptr = *align(64) const @This();
         next: Ptr,
@@ -2259,7 +2320,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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const S = struct {
@@ -2295,6 +2356,8 @@ 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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const Foo = struct {
         padding: struct { a: u8, b: ?comptime_int },
         number: u8,
diff --git a/test/behavior/struct_contains_null_ptr_itself.zig b/test/behavior/struct_contains_null_ptr_itself.zig
index 15c14cc3d22967e858fa1547875fcaede21162d6..714de60ba8b16ff2b052f6443a433fea07259f02 100644
--- a/test/behavior/struct_contains_null_ptr_itself.zig
+++ b/test/behavior/struct_contains_null_ptr_itself.zig
@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 
 test "struct contains null pointer which contains original struct" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: ?*NodeLineComment = null;
     _ = &x;
diff --git a/test/behavior/struct_contains_slice_of_itself.zig b/test/behavior/struct_contains_slice_of_itself.zig
index 541babee6bb62d10cf05f141545eafe9766aefd7..1cb6f4ebc7a180cbc37dd9a8b211a2ac2823b5d6 100644
--- a/test/behavior/struct_contains_slice_of_itself.zig
+++ b/test/behavior/struct_contains_slice_of_itself.zig
@@ -13,7 +13,7 @@ const NodeAligned = struct {
 
 test "struct contains slice of itself" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var other_nodes = [_]Node{
         Node{
@@ -53,7 +53,7 @@ test "struct contains slice of itself" {
 
 test "struct contains aligned slice of itself" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var other_nodes = [_]NodeAligned{
         NodeAligned{
diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig
index 76bc40ea3d824f0b1c7f6633ae8a7cfebc6c858a..b2dc5b770e47c0b2b7817d619eec23732018b0d3 100644
--- a/test/behavior/switch.zig
+++ b/test/behavior/switch.zig
@@ -23,6 +23,7 @@ fn testSwitchWithNumbers(x: u32) !void {
 }
 
 test "switch with all ranges" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(testSwitchWithAllRanges(50, 3) == 1);
@@ -44,7 +45,7 @@ test "switch arbitrary int size" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -258,6 +259,7 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
 }
 
 test "switching on booleans" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testSwitchOnBools();
@@ -313,6 +315,7 @@ test "undefined.u0" {
 }
 
 test "switch with disjoint range" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     var q: u8 = 0;
     _ = &q;
@@ -324,6 +327,8 @@ test "switch with disjoint range" {
 }
 
 test "switch variable for range and multiple prongs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             try doTheSwitch(16);
@@ -354,7 +359,7 @@ fn poll() void {
 }
 
 test "switch on global mutable var isn't constant-folded" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     while (state < 2) {
@@ -369,6 +374,7 @@ const SwitchProngWithVarEnum = union(enum) {
 };
 
 test "switch prong with variable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -394,6 +400,7 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void {
 }
 
 test "switch on enum using pointer capture" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -414,6 +421,7 @@ fn testSwitchEnumPtrCapture() !void {
 }
 
 test "switch handles all cases of number" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testSwitchHandleAllCases();
@@ -453,6 +461,7 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 {
 }
 
 test "switch on union with some prongs capturing" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -490,6 +499,7 @@ test "switch on const enum with var" {
 }
 
 test "anon enum literal used in switch on union enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const Foo = union(enum) {
@@ -506,6 +516,7 @@ test "anon enum literal used in switch on union enum" {
 }
 
 test "switch all prongs unreachable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testAllProngsUnreachable();
@@ -529,6 +540,7 @@ fn switchWithUnreachable(x: i32) i32 {
 }
 
 test "capture value of switch with all unreachable prongs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const x = return_a_number() catch |err| switch (err) {
@@ -562,7 +574,7 @@ test "switch on integer with else capturing expr" {
 test "else prong of switch on error set excludes other cases" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -597,7 +609,7 @@ test "else prong of switch on error set excludes other cases" {
 test "switch prongs with error set cases make a new error set type for capture 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -632,6 +644,7 @@ test "switch prongs with error set cases make a new error set type for capture v
 }
 
 test "return result loc and then switch with range implicit casted to error union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -650,6 +663,7 @@ test "return result loc and then switch with range implicit casted to error unio
 }
 
 test "switch with null and T peer types and inferred result location type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -669,6 +683,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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -777,7 +792,7 @@ test "switch prong pointer capture alignment" {
 test "switch on pointer type" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/176634
 
     const S = struct {
@@ -824,6 +839,7 @@ test "switch on error set with single else" {
 }
 
 test "switch capture copies its payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -915,6 +931,8 @@ test "comptime inline switch" {
 }
 
 test "switch capture peer type resolution" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union(enum) {
         a: u32,
         b: u64,
@@ -930,6 +948,7 @@ test "switch capture peer type resolution" {
 }
 
 test "switch capture peer type resolution for in-memory coercible payloads" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const T1 = c_int;
@@ -954,7 +973,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T1 = c_int;
     const t1_info = @typeInfo(T1).int;
@@ -983,6 +1002,8 @@ test "switch pointer capture peer type resolution" {
 }
 
 test "inline switch range that includes the maximum value of the switched type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const inputs: [3]u8 = .{ 0, 254, 255 };
     for (inputs) |input| {
         switch (input) {
@@ -995,7 +1016,7 @@ test "inline switch range that includes the maximum value of the switched type"
 test "nested break ignores switch conditions and breaks instead" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn register_to_address(ident: []const u8) !u8 {
@@ -1016,7 +1037,7 @@ test "nested break ignores switch conditions and breaks instead" {
 }
 
 test "peer type resolution on switch captures ignores unused payload bits" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Foo = union(enum) {
@@ -1042,7 +1063,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
 
 test "switch prong captures range" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn a(b: []u3, c: u3) void {
@@ -1060,6 +1081,8 @@ test "switch prong captures range" {
 }
 
 test "prong with inline call to unreachable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union(enum) {
         void: void,
         bool: bool,
@@ -1077,6 +1100,8 @@ test "prong with inline call to unreachable" {
 }
 
 test "block error return trace index is reset between prongs" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn returnError() error{TestFailed} {
             return error.TestFailed;
@@ -1105,6 +1130,8 @@ test "block error return trace index is reset between prongs" {
 }
 
 test "labeled switch with break" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var six: u32 = undefined;
     six = 6;
 
@@ -1144,6 +1171,8 @@ test "unlabeled break ignores switch" {
 }
 
 test "switch on a signed value smaller than the smallest prong value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var v: i32 = undefined;
     v = -1;
     switch (v) {
@@ -1153,6 +1182,8 @@ test "switch on a signed value smaller than the smallest prong value" {
 }
 
 test "switch on 8-bit mod result" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var x: u8 = undefined;
     x = 16;
     switch (x % 4) {
@@ -1261,6 +1292,8 @@ test "switch with uninstantiable union fields" {
 }
 
 test "switch with tag capture" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union(enum) {
         a,
         b: i32,
@@ -1312,6 +1345,8 @@ test "switch with tag capture" {
 }
 
 test "switch with complex item expressions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             try doTheSwitch(2000, 20);
@@ -1414,7 +1449,7 @@ test "single range switch prong capture" {
 }
 
 test "switch on packed struct" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const P = packed struct {
         a: u1,
@@ -1446,7 +1481,7 @@ test "switch on packed struct" {
 }
 
 test "switch on packed union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const P = packed union(u2) {
         a: u2,
@@ -1495,7 +1530,7 @@ test "switch on packed union" {
 }
 
 test "switch on nested packed containers" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const P = packed struct {
         iu: u17,
@@ -1550,7 +1585,7 @@ test "switch on nested packed containers" {
 }
 
 test "switch on large types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(a: u128, b: i500) !void {
@@ -1652,6 +1687,8 @@ test "repeated switch analysis overrides previous analysis results" {
 }
 
 test "union field pointer capture preserves alignment in inline prong" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union(enum) {
         a: u32,
         b: u32,
@@ -1671,6 +1708,8 @@ test "union field pointer capture preserves alignment in inline prong" {
 }
 
 test "switch on expression" {
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     var a: []const []const u8 = &.{ "b", "b", "A", "A", "b" };
     _ = &a;
     var c: isize = 0;
diff --git a/test/behavior/switch_loop.zig b/test/behavior/switch_loop.zig
index 6169baef0e02039e042576bae568066668a16138..1f375dd5c226723ddfd3ea8a6a810b1c1aa726ea 100644
--- a/test/behavior/switch_loop.zig
+++ b/test/behavior/switch_loop.zig
@@ -4,6 +4,7 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 
 test "simple switch loop" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -27,6 +28,7 @@ test "simple switch loop" {
 }
 
 test "switch loop with ranges" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -47,6 +49,7 @@ test "switch loop with ranges" {
 }
 
 test "switch loop on enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -70,6 +73,7 @@ test "switch loop on enum" {
 }
 
 test "switch loop with error set" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -93,6 +97,7 @@ test "switch loop with error set" {
 }
 
 test "switch loop on tagged union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -128,7 +133,7 @@ test "switch loop dispatching instructions" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     const S = struct {
         const Inst = union(enum) {
@@ -175,6 +180,7 @@ test "switch loop dispatching instructions" {
 }
 
 test "switch loop with pointer capture" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -222,7 +228,7 @@ test "unanalyzed continue with operand" {
 
 test "switch loop on larger than pointer integer" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var entry: @Int(.unsigned, @bitSizeOf(usize) + 1) = undefined;
     entry = 0;
@@ -242,6 +248,7 @@ test "switch loop on larger than pointer integer" {
 }
 
 test "switch loop on non-exhaustive enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -290,6 +297,8 @@ test "switch loop with discarded tag capture" {
 }
 
 test "switch loop with single catch-all prong" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         const E = enum { a, b, c };
         const U = union(E) { a: u32, b: u16, c: u8 };
@@ -337,7 +346,7 @@ test "switch loop with single catch-all prong" {
 }
 
 test "switch loop on type with opv" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const E = enum { opv };
@@ -385,7 +394,7 @@ test "switch loop on type with opv" {
 }
 
 test "switch loop with tag capture" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = union(enum) {
         a,
@@ -456,6 +465,8 @@ test "switch loop with tag capture" {
 }
 
 test "switch loop for error handling" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const Error = error{ MyError, MyOtherError };
     const S = struct {
         fn doTheTest() !void {
@@ -500,7 +511,8 @@ test "switch loop for error handling" {
 }
 
 test "switch loop with packed structs" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const P = packed struct {
         a: u7,
         b: u20,
@@ -518,7 +530,7 @@ test "switch loop with packed structs" {
 }
 
 test "switch loop with packed unions" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const P = packed union {
         a: u7,
@@ -558,7 +570,7 @@ test "switch loop with packed unions with OPV" {
 }
 
 test "switch loop on large types" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(a: u128, b: i500) !void {
diff --git a/test/behavior/switch_on_captured_error.zig b/test/behavior/switch_on_captured_error.zig
index a57e93d0d1ca4bd502123b9e13ddcaeb7cbd9b68..3fa1ebaa245c92a5ecb3de8ce6ca317c4d369a93 100644
--- a/test/behavior/switch_on_captured_error.zig
+++ b/test/behavior/switch_on_captured_error.zig
@@ -6,7 +6,7 @@ const expectEqual = std.testing.expectEqual;
 const builtin = @import("builtin");
 
 test "switch on error union catch capture" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -370,7 +370,7 @@ test "switch on error union catch capture" {
 }
 
 test "switch on error union if else capture" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
diff --git a/test/behavior/switch_prong_err_enum.zig b/test/behavior/switch_prong_err_enum.zig
index a316cacc61cd24cc3eac913fed77d33fe1430f7e..5fcad7000f212a7efadf69e163edba94dd9af6ad 100644
--- a/test/behavior/switch_prong_err_enum.zig
+++ b/test/behavior/switch_prong_err_enum.zig
@@ -24,7 +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;
+    if (builtin.cpu.arch.isSpirv()) 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..bf1652e102751e8915f28ed78c22eed46b6f9d42 100644
--- a/test/behavior/switch_prong_implicit_cast.zig
+++ b/test/behavior/switch_prong_implicit_cast.zig
@@ -15,6 +15,7 @@ fn foo(id: u64) !FormValue {
 }
 
 test "switch prong implicit cast" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
diff --git a/test/behavior/this.zig b/test/behavior/this.zig
index c5900073225fd6b52a3968e23816eee536133d20..38f1fb9be7dad886d5b78fdebb1ef5e54d401947 100644
--- a/test/behavior/this.zig
+++ b/test/behavior/this.zig
@@ -26,6 +26,7 @@ test "this refer to module call private fn" {
 }
 
 test "this refer to container" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var pt: Point(i32) = undefined;
@@ -48,7 +49,7 @@ fn prev(p: ?State) void {
 test "this used as optional function parameter" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var global: State = undefined;
     global.enter = prev;
diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig
index 9c888bf762dd521cd3a6d53e0faebffe02d13bc0..6e0c4ef7edd39848a3ed5fef08e655dd8b668dc7 100644
--- a/test/behavior/threadlocal.zig
+++ b/test/behavior/threadlocal.zig
@@ -19,7 +19,7 @@ test "pointer to thread local array" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const s = "Hello world";
     @memcpy(buffer[0..s.len], s);
@@ -32,7 +32,7 @@ test "reference a global threadlocal variable" {
     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_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try nrfx_uart_rx(&g_uart0);
 }
diff --git a/test/behavior/truncate.zig b/test/behavior/truncate.zig
index 506a0d2bea99b768c6761cc3da31558b88eddf11..570aa25d78cbd5b8a9089d99884563e51c547f4b 100644
--- a/test/behavior/truncate.zig
+++ b/test/behavior/truncate.zig
@@ -32,6 +32,8 @@ test "truncate.u0.var" {
 }
 
 test "truncate on comptime integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const x: u16 = @truncate(9999);
     try expect(x == 9999);
     const y: u16 = @truncate(-21555);
@@ -49,7 +51,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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testTruncate(u140, 0, u128, 0);
     try testTruncate(u140, maxInt(u140), u128, maxInt(u128));
@@ -90,7 +92,7 @@ test "truncate on vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/try.zig b/test/behavior/try.zig
index b9a368852d535dfbb7c644fe9208af4490edeebd..2133c651b3a08eddfbe5a5563bef124460181f35 100644
--- a/test/behavior/try.zig
+++ b/test/behavior/try.zig
@@ -4,6 +4,7 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 
 test "try on error union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try tryOnErrorUnionImpl();
@@ -49,7 +50,7 @@ test "try then not executed with assignment" {
 
 test "`try`ing an if/else expression" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -68,6 +69,7 @@ test "`try`ing an if/else expression" {
 }
 
 test "'return try' of empty error set in function returning non-error" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -102,6 +104,8 @@ test "'return try' of empty error set in function returning non-error" {
 }
 
 test "'return try' through conditional" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn get(t: bool) !u32 {
             return try if (t) inner() else error.TestFailed;
@@ -124,7 +128,7 @@ test "'return try' through conditional" {
 
 test "try ptr propagation const" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -156,7 +160,7 @@ test "try ptr propagation const" {
 
 test "try ptr propagation mutate" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -200,6 +204,8 @@ test "try ptr propagation mutate" {
 }
 
 test "try pointer expression alignment" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest(p: *align(1) (anyerror!u32)) !void {
             comptime assert(@TypeOf(&(try p.*)) == *align(1) u32);
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index 2241de5dcb8d12bab80303496a2b83e0c2e7f376..45a9bc2765e3fb92e489ccf8aaf1ae108e697671 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -7,6 +7,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 const expectEqual = std.testing.expectEqual;
 
 test "tuple concatenation" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -29,7 +30,7 @@ test "tuple concatenation" {
 test "more tuple concatenation" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct {
         fn consume_tuple(tuple: anytype, len: usize) !void {
@@ -104,7 +105,9 @@ test "tuple initializer for var" {
 }
 
 test "array-like initializer for tuple types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+
     const T = @Tuple(&.{ i32, u8 });
     const S = struct {
         fn doTheTest() !void {
@@ -169,7 +172,8 @@ test "fieldParentPtr of tuple" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     var x: u32 = 0;
     _ = &x;
     const tuple = .{ x, x };
@@ -180,7 +184,7 @@ test "fieldParentPtr of anon struct" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var x: u32 = 0;
     _ = &x;
@@ -238,6 +242,7 @@ test "tuple in tuple passed to generic function" {
 }
 
 test "coerce tuple to tuple" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -285,6 +290,7 @@ test "tuple type with void field and a runtime field" {
 }
 
 test "branching inside tuple literal" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -303,7 +309,7 @@ test "tuple initialized with a runtime known value" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = union(enum) { e: []const u8 };
     const W = union(enum) { w: E };
@@ -317,7 +323,7 @@ test "tuple of struct concatenation and coercion to array" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const StructWithDefault = struct { value: f32 = 42 };
     const SomeStruct = struct { array: [4]StructWithDefault };
@@ -331,7 +337,7 @@ test "tuple of struct concatenation and coercion to array" {
 test "nested runtime conditionals in tuple initializer" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var data: u8 = 0;
     _ = &data;
@@ -364,6 +370,7 @@ test "sentinel slice in tuple" {
 }
 
 test "tuple pointer is indexable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -386,6 +393,7 @@ test "tuple pointer is indexable" {
 }
 
 test "coerce anon tuple to tuple" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -423,7 +431,7 @@ test "tuple with runtime value coerced into a slice with a sentinel" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn f(a: [:null]const ?u8) !void {
@@ -442,6 +450,8 @@ test "tuple with runtime value coerced into a slice with a sentinel" {
 }
 
 test "tuple implicitly coerced to optional/error union struct/union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const SomeUnion = union(enum) {
         variant: u8,
     };
@@ -495,7 +505,7 @@ test "comptime fields in tuple can be initialized" {
 test "empty struct in tuple" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct { struct {} };
     const info = @typeInfo(T);
@@ -507,7 +517,7 @@ test "empty struct in tuple" {
 test "empty union in tuple" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct { union {} };
     const info = @typeInfo(T);
@@ -517,7 +527,7 @@ test "empty union in tuple" {
 }
 
 test "field pointer of underaligned tuple" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -546,7 +556,7 @@ 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         var foo: [2]struct { u32, u8, void } = .{ .{ 1, 2, {} }, .{ 3, 4, {} } };
diff --git a/test/behavior/tuple_declarations.zig b/test/behavior/tuple_declarations.zig
index 2b75e3d510a0e21f7e820937ab5b18c93940c385..1ccc7d9b614e6ff0a33ac66e9294654c2cfa5f2d 100644
--- a/test/behavior/tuple_declarations.zig
+++ b/test/behavior/tuple_declarations.zig
@@ -6,7 +6,7 @@ const expectEqualStrings = testing.expectEqualStrings;
 
 test "tuple declaration type info" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     {
         const T = struct { comptime u32 = 1, []const u8 };
@@ -34,7 +34,7 @@ test "tuple declaration type info" {
 
 test "tuple declaration usage" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct { u32, []const u8 };
     var t: T = .{ 1, "foo" };
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index 875e77ffcb037bce22bf124d5ecea3689913d163..5279ba40ff7abc4ab8d6e84f1ba82df97728e60d 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -5,6 +5,8 @@ const testing = std.testing;
 const assert = std.debug.assert;
 
 test "Type.Int" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testing.expect(u1 == @Int(.unsigned, 1));
     try testing.expect(i1 == @Int(.signed, 1));
     try testing.expect(u8 == @Int(.unsigned, 8));
@@ -14,6 +16,8 @@ test "Type.Int" {
 }
 
 test "Type.Pointer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     inline for (&[_]type{
         // One Value Pointer Types
         *u8,                               *const u8,
@@ -72,6 +76,8 @@ test "@Pointer create slice with null sentinel" {
 }
 
 test "@Pointer on @typeInfo round-trips sentinels" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     inline for (&[_]type{
         [*:0]u8,                             [*:0]const u8,
         [*:0]volatile u8,                    [*:0]const volatile u8,
@@ -105,7 +111,7 @@ test "Type.Opaque" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Opaque = opaque {};
     try testing.expect(Opaque != opaque {});
@@ -124,7 +130,7 @@ test "Type.Struct" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const A = @Struct(.auto, null, &.{ "x", "y" }, &.{ u8, u32 }, &@splat(.{}));
     const infoA = @typeInfo(A).@"struct";
@@ -193,7 +199,7 @@ test "Type.Struct" {
 
 test "Type.Enum" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Foo = @Enum(u8, .exhaustive, &.{ "a", "b" }, &.{ 1, 5 });
     try testing.expectEqual(std.builtin.Type.Enum.Mode.exhaustive, @typeInfo(Foo).@"enum".mode);
@@ -229,7 +235,7 @@ test "Type.Enum" {
 
 test "Type.Union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Untagged = @Union(.@"extern", null, &.{ "int", "float" }, &.{ i32, f32 }, &.{ .{}, .{} });
     var untagged = Untagged{ .int = 1 };
@@ -264,6 +270,8 @@ test "Type.Union from regular enum" {
 }
 
 test "Type.Union from empty regular enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const E = enum {};
     const U = @Union(.auto, E, &.{}, &.{}, &.{});
 
@@ -274,6 +282,8 @@ test "Type.Union from empty regular enum" {
 }
 
 test "Type.Union from empty Type.Enum" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const E = @Enum(noreturn, .exhaustive, &.{}, &.{});
     const U = @Union(.auto, E, &.{}, &.{}, &.{});
 
@@ -285,7 +295,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const some_opaque = opaque {};
     const some_ptr = *some_opaque;
@@ -406,6 +416,8 @@ test "matching captures causes opaque equivalence" {
 }
 
 test "reify enum where fields refers to part of array" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const field_names: [3][]const u8 = .{ "foo", "bar", undefined };
     const field_values: [3]u8 = .{ undefined, 0, 1 };
     const E = @Enum(u8, .exhaustive, field_names[0..2], field_values[1..3]);
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index 12950e4f0bba3973b3e898f6afab42683ede7ae2..8b62358f99f02035f2915e516141cdecbb154a5a 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -10,6 +10,8 @@ const expect = std.testing.expect;
 const expectEqualStrings = std.testing.expectEqualStrings;
 
 test "type info: integer, floating point type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testIntFloat();
     try comptime testIntFloat();
 }
@@ -37,6 +39,8 @@ fn testOptional() !void {
 }
 
 test "type info: C pointer type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testCPtr();
     try comptime testCPtr();
 }
@@ -60,6 +64,8 @@ test "type info: value is correctly copied" {
 }
 
 test "type info: tag type, void info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testBasic();
     try comptime testBasic();
 }
@@ -72,6 +78,8 @@ fn testBasic() !void {
 }
 
 test "type info: pointer type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testPointer();
     try comptime testPointer();
 }
@@ -88,6 +96,8 @@ fn testPointer() !void {
 }
 
 test "type info: unknown length pointer type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testUnknownLenPtr();
     try comptime testUnknownLenPtr();
 }
@@ -104,6 +114,8 @@ fn testUnknownLenPtr() !void {
 }
 
 test "type info: null terminated pointer type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testNullTerminatedPtr();
     try comptime testNullTerminatedPtr();
 }
@@ -120,6 +132,8 @@ fn testNullTerminatedPtr() !void {
 }
 
 test "type info: slice type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testSlice();
     try comptime testSlice();
 }
@@ -135,6 +149,8 @@ fn testSlice() !void {
 }
 
 test "type info: array type info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testArray();
     try comptime testArray();
 }
@@ -160,7 +176,7 @@ fn testArray() !void {
 test "type info: error set, error union info, anyerror" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testErrorSet();
     try comptime testErrorSet();
@@ -191,7 +207,7 @@ fn testErrorSet() !void {
 test "type info: error set single 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const TestSet = error.One;
 
@@ -204,7 +220,7 @@ test "type info: error set single value" {
 test "type info: error set merged" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const TestSet = error{ One, Two } || error{Three};
 
@@ -219,7 +235,7 @@ test "type info: error set merged" {
 test "type info: enum info" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testEnum();
     try comptime testEnum();
@@ -244,6 +260,8 @@ fn testEnum() !void {
 }
 
 test "type info: union info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testUnion();
     try comptime testUnion();
 }
@@ -287,7 +305,7 @@ fn testUnion() !void {
 
 test "type info: struct info" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testStruct();
     try comptime testStruct();
@@ -310,6 +328,8 @@ const TestStruct = struct {
 };
 
 test "type info: packed struct info" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testPackedStruct();
     try comptime testPackedStruct();
 }
@@ -361,7 +381,7 @@ fn testOpaque() !void {
 }
 
 test "type info: function type info" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testFunction();
@@ -429,6 +449,8 @@ extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.c) usize;
 extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.c) usize;
 
 test "type info: generic function types" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const G1 = @typeInfo(@TypeOf(generic1));
     try expect(G1.@"fn".param_types.len == 1);
     try expect(G1.@"fn".param_types.len == G1.@"fn".param_attrs.len);
@@ -477,6 +499,8 @@ test "typeInfo with comptime parameter in struct fn def" {
 }
 
 test "type info: vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try testVector();
     try comptime testVector();
 }
@@ -549,7 +573,7 @@ fn add(a: i32, b: i32) i32 {
 
 test "Declarations are returned in declaration order" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         pub const a = 1;
@@ -571,8 +595,7 @@ test "Struct.is_tuple for anon list literal" {
 }
 
 test "Struct.is_tuple for anon struct literal" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const info = @typeInfo(@TypeOf(.{ .a = 0 }));
@@ -594,6 +617,7 @@ 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.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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];
@@ -611,7 +635,8 @@ test "@typeInfo function with generic return type and inferred error set" {
 }
 
 test "type info: spirv info" {
-    if (builtin.zig_backend != .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+    if (!builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testSpirv();
     try comptime testSpirv();
diff --git a/test/behavior/typename.zig b/test/behavior/typename.zig
index 2704e75f773bc93dca7c896457c134d41e690347..791293c6d6d0e7605eea957c568aa930ba95e399 100644
--- a/test/behavior/typename.zig
+++ b/test/behavior/typename.zig
@@ -14,7 +14,7 @@ const expectStringStartsWith = std.testing.expectStringStartsWith;
 test "anon fn 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // https://github.com/ziglang/zig/issues/9339
     try expectEqualStringsIgnoreDigits(
@@ -39,7 +39,7 @@ test "anon fn param" {
 test "anon field init" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Foo = .{
         .T1 = struct {},
@@ -64,7 +64,7 @@ test "anon field init" {
 test "basic" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expectEqualStrings("i64", @typeName(i64));
     try expectEqualStrings("*usize", @typeName(*usize));
@@ -85,7 +85,7 @@ test "basic" {
 test "top level decl" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expectEqualStrings(
         "behavior.typename.A_Struct",
@@ -134,7 +134,7 @@ const B = struct {
 test "fn 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // https://github.com/ziglang/zig/issues/675
     try expectEqualStrings(
@@ -213,7 +213,7 @@ pub fn expectEqualStringsIgnoreDigits(expected: []const u8, actual: []const u8)
 test "local 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Foo = struct { a: u32 };
     const Bar = union { a: u32 };
@@ -231,7 +231,7 @@ test "local variable" {
 test "comptime parameters not converted to anytype in function 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = fn (comptime fn (comptime type) void, void) void;
     try expectEqualStrings("fn (comptime fn (comptime type) void, void) void", @typeName(T));
@@ -240,7 +240,7 @@ test "comptime parameters not converted to anytype in function type" {
 test "anon name strategy used in sub expression" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn getTheName() []const u8 {
diff --git a/test/behavior/undefined.zig b/test/behavior/undefined.zig
index 61f5a7e1a6789752e258ba24449c161898b48e10..f0585c799f6555d7c13533af3cb4d1ff8599dc1a 100644
--- a/test/behavior/undefined.zig
+++ b/test/behavior/undefined.zig
@@ -14,6 +14,7 @@ fn initStaticArray() [10]i32 {
 }
 const static_array = initStaticArray();
 test "init static array to undefined" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     // This test causes `initStaticArray()` to be codegen'd, and the
     // C backend does not yet support returning arrays, so it fails
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@@ -45,6 +46,7 @@ fn setFooX(foo: *Foo) void {
 }
 
 test "assign undefined to struct" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -61,6 +63,7 @@ test "assign undefined to struct" {
 }
 
 test "assign undefined to struct with method" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -77,7 +80,7 @@ test "assign undefined to struct with method" {
 }
 
 test "type name of undefined" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const x = undefined;
@@ -88,7 +91,7 @@ var buf: []u8 = undefined;
 
 test "reslice of undefined global var slice" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var stack_buf: [100]u8 = @splat(0);
     buf = &stack_buf;
@@ -98,7 +101,7 @@ test "reslice of undefined global var slice" {
 
 test "returned undef is 0xaa bytes when runtime safety is enabled" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Rect = struct {
diff --git a/test/behavior/underscore.zig b/test/behavior/underscore.zig
index 66b49e52d5ce4c81bc39605144aa042c51b23d8f..7a70b5ead41d04e5e7d8cb8b88cf4da1b60dd49f 100644
--- a/test/behavior/underscore.zig
+++ b/test/behavior/underscore.zig
@@ -7,6 +7,7 @@ test "ignore lval with underscore" {
 }
 
 test "ignore lval with underscore (while loop)" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     while (optionalReturnError()) |_| {
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index e0f294557def1e340f6ffc2d7f1f9e8cfbec2856..e5964f0f31d731c5abd995a285e4e2a5989258a6 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -15,7 +15,7 @@ test "basic unions with 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo = FooWithFloats{ .int = 1 };
     try expect(foo.int == 1);
@@ -28,6 +28,7 @@ fn setFloat(foo: *FooWithFloats, x: f64) void {
 }
 
 test "init union with runtime value - floats" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -41,7 +42,7 @@ test "init union with runtime value - floats" {
 test "basic 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo = Foo{ .int = 1 };
     try expect(foo.int == 1);
@@ -60,7 +61,7 @@ test "init union with runtime value" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo: Foo = undefined;
 
@@ -98,7 +99,7 @@ const FooExtern = extern union {
 
 test "basic extern unions" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var foo = FooExtern{ .int = 1 };
     try expect(foo.int == 1);
@@ -160,6 +161,7 @@ test "unions embedded in aggregate types" {
 }
 
 test "constant tagged union with payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -212,7 +214,7 @@ test "union with specified enum tag" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try doTest();
     try comptime doTest();
@@ -245,7 +247,7 @@ fn testComparison() !void {
 test "comparison between union and enum literal" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testComparison();
     try comptime testComparison();
@@ -258,6 +260,7 @@ const TheUnion = union(TheTag) {
     C: i32,
 };
 test "cast union to tag type of union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -272,12 +275,14 @@ fn testCastUnionToTag() !void {
 }
 
 test "union field access gives the enum values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     try expect(TheUnion.A == TheTag.A);
     try expect(TheUnion.B == TheTag.B);
     try expect(TheUnion.C == TheTag.C);
 }
 
 test "cast tag type of union to union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -293,6 +298,7 @@ const Value2 = union(Letter2) {
 };
 
 test "implicit cast union to its tag type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -315,7 +321,7 @@ pub const PackThis = union(enum) {
 test "constant packed union" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
 }
@@ -407,7 +413,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Literal = union(enum) {
         Number: f64,
@@ -442,7 +448,7 @@ const Foo1 = union(enum) {
 var glbl: Foo1 = undefined;
 
 test "global union with single field is correctly initialized" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -462,7 +468,7 @@ var glbl_array: [2]FooUnion = undefined;
 test "initialize global array of union" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     glbl_array[1] = FooUnion{ .U1 = 2 };
     glbl_array[0] = FooUnion{ .U0 = 1 };
@@ -471,6 +477,7 @@ test "initialize global array of union" {
 }
 
 test "update the tag value for zero-sized unions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -485,6 +492,7 @@ test "update the tag value for zero-sized unions" {
 }
 
 test "union initializer generates padding only if needed" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -499,7 +507,7 @@ test "union initializer generates padding only if needed" {
 
 test "runtime tag name with single field" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = union(enum) {
         A: i32,
@@ -511,6 +519,7 @@ test "runtime tag name with single field" {
 }
 
 test "method call on an empty union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -551,6 +560,7 @@ const FooNoVoid = union(enum) {
 const Baz = enum { A, B, C, D };
 
 test "tagged union type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const foo1 = TaggedFoo{ .One = 13 };
@@ -572,6 +582,7 @@ test "tagged union type" {
 }
 
 test "tagged union as return value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -588,6 +599,7 @@ fn returnAnInt(x: i32) TaggedFoo {
 }
 
 test "tagged union with all void fields but a meaningful tag" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -615,6 +627,7 @@ test "tagged union with all void fields but a meaningful tag" {
 }
 
 test "union(enum(u32)) with specified and unspecified tag values" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -652,6 +665,7 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
 }
 
 test "switch on union with only 1 field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -682,7 +696,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Literal = union(enum) {
         number: f64,
@@ -705,6 +719,7 @@ test "union with only 1 field casted to its enum type which has enum value speci
 }
 
 test "@intFromEnum works on unions" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -724,6 +739,8 @@ test "@intFromEnum works on unions" {
 }
 
 test "comptime union field value equality" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const a0 = Setter(Attribute{ .A = false });
     const a1 = Setter(Attribute{ .A = true });
     const a2 = Setter(Attribute{ .A = false });
@@ -763,6 +780,7 @@ fn Setter(comptime attr: Attribute) type {
 }
 
 test "return union init with void payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     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
@@ -787,6 +805,7 @@ test "return union init with void payload" {
 }
 
 test "@unionInit stored to a const" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -817,6 +836,7 @@ test "@unionInit stored to a const" {
 }
 
 test "@unionInit can modify a union type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -839,6 +859,7 @@ test "@unionInit can modify a union type" {
 }
 
 test "@unionInit can modify a pointer value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -860,7 +881,7 @@ test "@unionInit can modify a pointer value" {
 test "union no tag with struct member" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Struct = struct {};
     const Union = union {
@@ -887,7 +908,8 @@ test "anonymous union literal syntax" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
+
     const S = struct {
         const Number = union {
             int: i32,
@@ -911,6 +933,7 @@ test "anonymous union literal syntax" {
 }
 
 test "function call result coerces from tagged union to the tag" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -946,6 +969,7 @@ test "function call result coerces from tagged union to the tag" {
 }
 
 test "switching on non exhaustive union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -973,6 +997,7 @@ test "switching on non exhaustive union" {
 }
 
 test "containers with single-field enums" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1004,7 +1029,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const Type = enum(u8) { no_op = 105 };
@@ -1049,7 +1074,7 @@ test "union enum type gets a separate scope" {
 test "global variable struct contains union initialized to non-most-aligned 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const T = struct {
         const U = union(enum) {
@@ -1073,6 +1098,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
 }
 
 test "union with no result loc initiated with a runtime value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1090,6 +1116,7 @@ test "union with no result loc initiated with a runtime value" {
 }
 
 test "union with a large struct field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1124,6 +1151,7 @@ test "comptime equality of extern unions with same tag" {
 }
 
 test "union tag is set when initiated as a temporary value at runtime" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1146,7 +1174,7 @@ test "extern union most-aligned field is smaller" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = extern union {
         in6: extern struct {
@@ -1166,7 +1194,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const namespace = struct {
         const S = extern struct {
@@ -1195,6 +1223,7 @@ test "return an extern union from C calling convention" {
 }
 
 test "noreturn field in union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     const U = union(enum) {
@@ -1244,6 +1273,7 @@ test "noreturn field in union" {
 }
 
 test "@unionInit uses tag value instead of field index" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -1274,7 +1304,7 @@ test "@unionInit uses tag value instead of field index" {
 test "union field ptr - zero sized 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = union {
         foo: void,
@@ -1288,7 +1318,7 @@ test "union field ptr - zero sized payload" {
 test "union field ptr - zero sized 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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = union {
         foo: void,
@@ -1303,7 +1333,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = packed struct {
         nested: packed union {
@@ -1353,7 +1383,7 @@ test "union int tag type is properly managed" {
 
 test "no dependency loop when function pointer in union returns the union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const U = union(enum) {
@@ -1373,6 +1403,7 @@ test "no dependency loop when function pointer in union returns the union" {
 }
 
 test "union reassignment can use previous value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -1387,7 +1418,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = packed union {
         tag: enum(u8) { a, b },
@@ -1404,7 +1435,7 @@ test "reinterpreting enum value inside packed union" {
 }
 
 test "access the tag of a global tagged union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = union(enum) {
         a,
@@ -1415,6 +1446,8 @@ test "access the tag of a global tagged union" {
 }
 
 test "coerce enum literal to union in result loc" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union(enum) {
         a,
         b: u8,
@@ -1431,7 +1464,7 @@ test "coerce enum literal to union in result loc" {
 test "defined-layout union field pointer has correct alignment" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime U: type) !void {
@@ -1465,7 +1498,7 @@ test "defined-layout union field pointer has correct alignment" {
 test "undefined-layout union field pointer has correct alignment" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime U: type) !void {
@@ -1500,7 +1533,7 @@ test "packed union field pointer has correct alignment" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
 
     const U = packed union { x: u20 };
     const S = packed struct(u24) { a: u2, u: U, b: u2 };
@@ -1531,6 +1564,7 @@ test "packed union field pointer has correct alignment" {
 }
 
 test "union with 128 bit integer" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const ValueTag = enum { int, other };
@@ -1554,7 +1588,7 @@ test "union with 128 bit integer" {
 }
 
 test "memset extern union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = extern union {
         foo: u8,
@@ -1575,7 +1609,7 @@ test "memset extern union" {
 }
 
 test "memset packed union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = packed union {
         a: u32,
@@ -1677,7 +1711,7 @@ test "reinterpret extern union" {
 
 test "reinterpret packed union" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = packed union {
         foo: packed struct(u64) {
@@ -1755,7 +1789,7 @@ test "reinterpret packed union" {
 
 test "reinterpret packed union inside packed struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const U = packed union {
@@ -1794,6 +1828,8 @@ test "reinterpret packed union inside packed struct" {
 }
 
 test "inner struct initializer uses union layout" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const namespace = struct {
         const U = union {
             a: struct {
@@ -1818,6 +1854,8 @@ test "inner struct initializer uses union layout" {
 }
 
 test "inner struct initializer uses packed union layout" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const namespace = struct {
         const U = packed union {
             a: packed struct {
@@ -1861,7 +1899,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
 
@@ -1884,7 +1922,7 @@ test "packed union initialized via reintepreted struct field initializer" {
 }
 
 test "store of comptime reinterpreted memory to extern union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
 
@@ -1907,7 +1945,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
 
@@ -1933,7 +1971,7 @@ test "store of comptime reinterpreted memory to packed union" {
 
 test "union field is a pointer to an aligned version of itself" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const E = union {
         next: *align(1) @This(),
@@ -1947,7 +1985,7 @@ test "union field is a pointer to an aligned version of itself" {
 test "pass register-sized field as non-register-sized union" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn taggedUnion(u: union(enum) { x: usize, y: [2]usize }) !void {
@@ -1971,7 +2009,7 @@ test "pass register-sized field as non-register-sized union" {
 }
 
 test "circular dependency through pointer field of a union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const UnionInner = extern struct {
@@ -1994,6 +2032,7 @@ test "circular dependency through pointer field of a union" {
 }
 
 test "pass nested union with rls" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Union = union(enum) {
@@ -2014,6 +2053,7 @@ test "pass nested union with rls" {
 }
 
 test "runtime union init, most-aligned field != largest" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -2039,6 +2079,7 @@ test "runtime union init, most-aligned field != largest" {
 }
 
 test "copied union field doesn't alias source" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -2059,7 +2100,7 @@ test "copied union field doesn't alias source" {
 test "create union(enum) from other union(enum)" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const string = "hello world";
@@ -2192,6 +2233,7 @@ test "capture used as explicit field value" {
 }
 
 test "signed enum tag with negative value" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -2247,7 +2289,7 @@ test "extern union @FieldType" {
 }
 
 test "assign global tagged union" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const U = union(enum) {
         a: u16,
@@ -2268,6 +2310,8 @@ test "assign global tagged union" {
 }
 
 test "set mutable union by switching on same union" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union(enum) {
         foo,
         bar: usize,
@@ -2292,6 +2336,8 @@ test "initialize empty field of union inside comptime-known struct constant" {
 }
 
 test "union with function body field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     const U = union {
         f: fn () void,
         fn foo() void {}
diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig
index e1a35322c19720ca2e838818c0150d8b8870dda4..48b1d28c5f727d508b7d72611984fd757a847410 100644
--- a/test/behavior/var_args.zig
+++ b/test/behavior/var_args.zig
@@ -14,6 +14,8 @@ fn add(args: anytype) i32 {
 }
 
 test "add arbitrary args" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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);
@@ -28,6 +30,7 @@ test "send void arg to var args" {
 }
 
 test "pass args directly" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
@@ -40,6 +43,7 @@ fn addSomeStuff(args: anytype) i32 {
 }
 
 test "runtime parameter before var args" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try expect((try extraFn(10, .{})) == 0);
@@ -94,7 +98,7 @@ fn doNothingWithFirstArg(args: anytype) void {
 test "simple variadic function" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
         // https://github.com/ziglang/zig/issues/14096
@@ -155,7 +159,7 @@ test "simple variadic function" {
 test "coerce reference to var arg" {
     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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
         // https://github.com/ziglang/zig/issues/14096
@@ -187,7 +191,7 @@ test "variadic functions" {
     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_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
         // https://github.com/ziglang/zig/issues/14096
         return error.SkipZigTest;
@@ -238,7 +242,7 @@ test "variadic functions" {
 
 test "copy VaList" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
         // https://github.com/ziglang/zig/issues/14096
@@ -272,7 +276,7 @@ test "copy VaList" {
 
 test "unused VaList arg" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
         // https://github.com/ziglang/zig/issues/14096
@@ -303,7 +307,7 @@ test "unused VaList arg" {
 
 test "floating point VaList args" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/16961
 
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 912b189f3926f43eced3fd093592db8d26a8c7fd..02e674ecb4c748faacf31c7609c1ea507a2c6ffc 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -8,7 +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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -31,7 +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.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = struct {
@@ -59,7 +59,7 @@ test "vector wrap operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -82,7 +82,7 @@ test "vector bin compares with mem.eql" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -106,7 +106,7 @@ test "vector int operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -127,7 +127,7 @@ test "vector float operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(T: type) !void {
@@ -164,7 +164,7 @@ test "vector bit operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -195,7 +195,7 @@ test "implicit cast vector to array" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -214,7 +214,7 @@ test "array to vector" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -233,7 +233,7 @@ test "array of abi-sized integer to vector of same type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         const one: u32 = 1;
@@ -318,7 +318,7 @@ test "array of float to vector of same type" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
     const S = struct {
@@ -375,6 +375,7 @@ test "array of float to vector of same type" {
 }
 
 test "array of non-abi-sized integer to vector of same type" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -427,6 +428,7 @@ test "array of non-abi-sized integer to vector of same type" {
 }
 
 test "array vector coercion - odd sizes" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -468,7 +470,7 @@ test "array to vector with element type coercion" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -502,7 +504,7 @@ test "peer type resolution with coercible element types" {
 }
 
 test "tuple to vector" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -529,7 +531,7 @@ test "vector casts of sizes not divisible by 8" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -564,6 +566,7 @@ test "vector casts of sizes not divisible by 8" {
 }
 
 test "load vector elements via comptime index" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -584,6 +587,7 @@ test "load vector elements via comptime index" {
 }
 
 test "store vector elements via comptime index" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -610,6 +614,7 @@ test "store vector elements via comptime index" {
 }
 
 test "initialize vector which is a struct field" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -634,7 +639,7 @@ test "vector comparison operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -679,7 +684,7 @@ test "vector division operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
@@ -798,6 +803,7 @@ test "vector division operators" {
 }
 
 test "vector bitwise not operator" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -830,6 +836,7 @@ test "vector bitwise not operator" {
 }
 
 test "vector boolean not operator" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -856,7 +863,7 @@ test "vector shift operators" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTestShift(x: anytype, y: anytype) !void {
@@ -926,7 +933,7 @@ test "vector reduce operation" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1087,7 +1094,7 @@ test "saturating add" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1187,7 +1194,7 @@ test "saturating subtraction" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1279,7 +1286,7 @@ test "saturating multiplication" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1303,7 +1310,7 @@ test "saturating shift-left" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
@@ -1323,6 +1330,7 @@ test "saturating shift-left" {
 }
 
 test "multiplication-assignment operator with an array operand" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -1346,7 +1354,7 @@ test "@addWithOverflow" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1393,7 +1401,7 @@ test "@subWithOverflow" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1420,7 +1428,7 @@ test "@subWithOverflow" {
 }
 
 test "@mulWithOverflow" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -1441,7 +1449,7 @@ test "@mulWithOverflow" {
 }
 
 test "@shlWithOverflow" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -1462,6 +1470,8 @@ test "@shlWithOverflow" {
 }
 
 test "alignment of vectors" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     try expect(@alignOf(@Vector(2, u8)) == switch (builtin.zig_backend) {
         else => 2,
         .stage2_c, .stage2_wasm => @alignOf(u8),
@@ -1487,7 +1497,7 @@ test "alignment of vectors" {
 test "loading the second vector from a slice of vectors" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     @setRuntimeSafety(false);
     var small_bases = [2]@Vector(2, u8){
@@ -1503,7 +1513,7 @@ test "array of vectors is copied" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const Vec3 = @Vector(3, i32);
     var points = [_]Vec3{
@@ -1567,7 +1577,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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const zeros = @Vector(2, u32){ 0.0, 0.0 };
     var ones = @Vector(2, u32){ 1.0, 1.0 };
@@ -1610,7 +1620,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.cpu.arch.isSpirv()) 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
@@ -1625,6 +1635,7 @@ test "array operands to shuffle are coerced to vectors" {
 }
 
 test "load packed vector element" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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
@@ -1636,7 +1647,7 @@ test "load packed vector element" {
 }
 
 test "store packed vector element" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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
@@ -1653,7 +1664,7 @@ test "store to vector in 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_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var v = [_]@Vector(3, f32){
         .{ 1, 1, 1 },
@@ -1670,7 +1681,7 @@ test "store vector with memset" {
     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; // TODO
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var a: [5]@Vector(2, i1) = undefined;
@@ -1697,7 +1708,7 @@ test "store vector with memset" {
 }
 
 test "addition of vectors represented as strings" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
@@ -1708,7 +1719,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.cpu.arch.isSpirv()) 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
@@ -1721,6 +1732,7 @@ test "compare vectors with different element types" {
 }
 
 test "vector pointer is indexable" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1758,7 +1770,7 @@ test "bitcast to vector with different child 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_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1810,7 +1822,7 @@ test "@reduce on bool vector" {
 test "bitcast vector to array of smaller vectors" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const u8x32 = @Vector(32, u8);
     const u8x64 = @Vector(64, u8);
diff --git a/test/behavior/void.zig b/test/behavior/void.zig
index 442cce152b2bd9134007df4818b40adb3b64b5fb..98444b55cdbc8e6d3b05dacddcf5d54c36649024 100644
--- a/test/behavior/void.zig
+++ b/test/behavior/void.zig
@@ -21,7 +21,7 @@ test "compare void with void compile time known" {
 test "iterate over a void slice" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var j: usize = 0;
     for (times(10), 0..) |_, i| {
diff --git a/test/behavior/while.zig b/test/behavior/while.zig
index 695d67f02045da638eafc71d7a651d68be17538a..9bfc936061ce4c177867899130d8663ca4fd0350 100644
--- a/test/behavior/while.zig
+++ b/test/behavior/while.zig
@@ -4,6 +4,7 @@ const expect = std.testing.expect;
 const assert = std.debug.assert;
 
 test "while loop" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var i: i32 = 0;
@@ -50,6 +51,8 @@ test "while with continue expression" {
 }
 
 test "while with else" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
+
     var sum: i32 = 0;
     var i: i32 = 0;
     var got_else: i32 = 0;
@@ -104,6 +107,7 @@ fn testBreakOuter() void {
 }
 
 test "while copies its payload" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -122,7 +126,7 @@ test "while copies its payload" {
 }
 
 test "continue and break" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try runContinueAndBreakTest();
     try expect(continue_and_break_counter == 8);
@@ -142,7 +146,7 @@ fn runContinueAndBreakTest() !void {
 }
 
 test "while with optional as condition" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest;
@@ -156,7 +160,7 @@ test "while with optional as condition" {
 }
 
 test "while with optional as condition with else" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) 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_riscv64) return error.SkipZigTest;
@@ -175,7 +179,7 @@ test "while with optional as condition with else" {
 }
 
 test "while with error union condition" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -207,6 +211,7 @@ test "while on bool with else result follow break prong" {
 }
 
 test "while on optional with else result follow else prong" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -217,6 +222,7 @@ test "while on optional with else result follow else prong" {
 }
 
 test "while on optional with else result follow break prong" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -255,6 +261,7 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
 }
 
 test "while on error union with else result follow else prong" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const result = while (returnError()) |value| {
@@ -264,6 +271,7 @@ test "while on error union with else result follow else prong" {
 }
 
 test "while on error union with else result follow break prong" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const result = while (returnSuccess(10)) |value| {
@@ -288,6 +296,7 @@ test "while bool 2 break statements and an else" {
 }
 
 test "while optional 2 break statements and an else" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -306,6 +315,7 @@ test "while optional 2 break statements and an else" {
 }
 
 test "while error 2 break statements and an else" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -344,7 +354,7 @@ test "else continue outer while" {
 
 test "try terminating an infinite loop" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     // Test coverage for https://github.com/ziglang/zig/issues/13546
     const Foo = struct {
@@ -370,6 +380,7 @@ test "while loop with comptime true condition needs no else block to return valu
 }
 
 test "int returned from switch in while" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x: u32 = 3;
@@ -381,6 +392,7 @@ test "int returned from switch in while" {
 }
 
 test "breaking from a loop in an if statement" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -402,7 +414,7 @@ test "breaking from a loop in an if statement" {
 }
 
 test "labeled break from else" {
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(x: u32) !void {
diff --git a/test/behavior/widening.zig b/test/behavior/widening.zig
index 6277c3acf6790cd769ac86dc885959e8281e7a71..d905dc33b1aafe369ce1d6488b4e9a9770db9315 100644
--- a/test/behavior/widening.zig
+++ b/test/behavior/widening.zig
@@ -4,6 +4,7 @@ const mem = std.mem;
 const builtin = @import("builtin");
 
 test "integer widening" {
+    if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) 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_riscv64) return error.SkipZigTest;
@@ -28,7 +29,7 @@ test "integer widening u0 to u8" {
 
 test "implicit unsigned integer to signed integer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     var a: u8 = 250;
     var b: i16 = a;
@@ -39,7 +40,7 @@ test "implicit unsigned integer to signed integer" {
 test "float widening" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var a: f16 = 12.34;
@@ -58,7 +59,7 @@ test "float widening" {
 test "float widening f16 to f128" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var x: f16 = 12.34;
@@ -70,7 +71,7 @@ test "float widening f16 to f128" {
 test "cast small unsigned to larger signed" {
     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;
+    if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
 
     try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
     try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));
diff --git a/test/cases/compile_errors/spirv_slices.zig b/test/cases/compile_errors/spirv_slices.zig
index 73554699caf09fb3a1c7cf86fa3a19863ddd767e..3c47aa9df8ec66e54c9fada8c18ed4addd06e5ee 100644
--- a/test/cases/compile_errors/spirv_slices.zig
+++ b/test/cases/compile_errors/spirv_slices.zig
@@ -19,7 +19,5 @@ export fn b() void {
 // target=spirv32-opengl,spirv32-vulkan
 // cpu_features=baseline+variable_pointers
 //
-// :3:16: error: cannot construct slice from address space 'generic'
-// :3:16: note: only 'shared' and 'storage_buffer' address spaces support slicing on SPIR-V
-// :14:11: error: cannot construct slice from address space 'generic'
-// :14:11: note: only 'shared' and 'storage_buffer' address spaces support slicing on SPIR-V
+// :3:16: error: cannot construct slice from logical address space 'generic'
+// :14:11: error: cannot construct slice from logical address space 'generic'
diff --git a/test/cases/spirv_mergable_pointers.zig b/test/cases/spirv_mergable_pointers.zig
index e44c1b53cf7ec89926218ceb4fb16b55adfd72b8..eec8786da4c9fade417c40d9e0dd3031e36dc2ad 100644
--- a/test/cases/spirv_mergable_pointers.zig
+++ b/test/cases/spirv_mergable_pointers.zig
@@ -1,7 +1,7 @@
 export fn a() void {
-    var x: *addrspace(.global) i32 = undefined;
+    var x: *addrspace(.physical_storage_buffer) i32 = undefined;
     _ = &x;
-    var y: *addrspace(.global) i32 = undefined;
+    var y: *addrspace(.physical_storage_buffer) i32 = undefined;
     _ = &y;
     var rt_cond = false;
     _ = &rt_cond;
@@ -13,5 +13,5 @@ export fn a() void {
 // compile
 // output_mode=Obj
 // backend=selfhosted
-// target=spirv32-vulkan
+// target=spirv64-vulkan
 // emit_bin=true
diff --git a/test/src/Cases.zig b/test/src/Cases.zig
index ac367a5813f9d644617aaa0c22259307105144c3..002909d827dbff3e20ca0c939b61336ac4054a95 100644
--- a/test/src/Cases.zig
+++ b/test/src/Cases.zig
@@ -465,7 +465,7 @@ pub fn lowerToBuildSteps(
         if (options.skip_non_native and !std.zig.target.isNative(&case.target.query, &case.target.result, &b.graph.host.result))
             continue;
 
-        if (options.skip_spirv and case.target.query.cpu_arch != null and case.target.query.cpu_arch.?.isSpirV()) continue;
+        if (options.skip_spirv and case.target.query.cpu_arch != null and case.target.query.cpu_arch.?.isSpirv()) continue;
         if (options.skip_wasm and case.target.query.cpu_arch != null and case.target.query.cpu_arch.?.isWasm()) continue;
 
         if (options.skip_freebsd and case.target.query.os_tag == .freebsd) continue;
diff --git a/test/tests.zig b/test/tests.zig
index 0dffc39e323e7b5a640ad0d90edf7e6659fa313a..bf94b689ee600c4a5a898b4d854085ace37f363c 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -2568,7 +2568,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
             if (test_target.link_libc == null and !std.os.targetRequiresLibC(target)) continue;
         }
 
-        if (options.skip_spirv and target.cpu.arch.isSpirV()) continue;
+        if (options.skip_spirv and target.cpu.arch.isSpirv()) continue;
         if (options.skip_wasm and target.cpu.arch.isWasm()) continue;
 
         if (options.skip_freebsd and target.os.tag == .freebsd) continue;
diff --git a/tools/gen_spirv_spec.zig b/tools/gen_spirv_spec.zig
index 769f09936e66547da537be43125564991a803e04..4c9f4b0c9a06252c2c6fa12cd2048c96205140eb 100644
--- a/tools/gen_spirv_spec.zig
+++ b/tools/gen_spirv_spec.zig
@@ -15,6 +15,7 @@ const allowed_vendors = [_][]const u8{ "KHR", "EXT" };
 const set_names = std.StaticStringMap(struct { []const u8, []const u8 }).initComptime(.{
     .{ "opencl.std.100", .{ "OpenCL.std", "OpenClOpcode" } },
     .{ "glsl.std.450", .{ "GLSL.std.450", "GlslOpcode" } },
+    .{ "nonsemantic.shader.debuginfo.100", .{ "NonSemantic.Shader.DebugInfo.100", "ShaderDebugInfoOpCode" } },
 });
 
 const Extension = struct {