authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-10-24 22:34:19+02:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-10-24 22:34:19+02:00
logdef373ed782112e19132be11b413a6f44608bc60
treeda93262ce8c21f7a24aac7247262213609f14397
parent7ef64ccf55927f9e1c5b01687907c870095c8e45
parentb60a4af44cca7d3e935acd0b861e3b650714ebc1

Merge pull request 'llvm: pass some behavior tests (30%) for spirv target' (#37300) from alichraghi/zig:llvm-spirv into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/37300 Reviewed-by: Andrew Kelley <andrew@ziglang.org>

139 files changed, 2481 insertions(+), 1408 deletions(-)

lib/compiler/aro/aro/Attribute/Wip.zig+1-1
......@@ -1303,7 +1303,7 @@ fn applyCallingConvention(wip: *Wip) !void {
13031303 .default => unreachable,
13041304 .cdecl => !(comp.target.cpu.arch.isArm() and comp.target.os.tag != .windows) and
13051305 !comp.target.cpu.arch.isPowerPC64() and
1306 !comp.target.cpu.arch.isSpirV(),
1306 !comp.target.cpu.arch.isSpirv(),
13071307 .aarch64_sve_pcs, .aarch64_vector_pcs => comp.target.cpu.arch.isAARCH64(),
13081308 .arm_aapcs_vfp, .arm_aapcs => comp.target.cpu.arch.isArm(),
13091309 .riscv_vector_cc, .riscv_vls_cc => comp.target.cpu.arch.isRISCV(),
lib/compiler/aro/aro/Target.zig+1-1
......@@ -113,7 +113,7 @@ pub const SubArch = enum {
113113 return @backingInt(std.Target.mips.Feature.mips32r6);
114114 } else if (arch.isMIPS64()) {
115115 return @backingInt(std.Target.mips.Feature.mips64r6);
116 } else if (arch.isSpirV()) {
116 } else if (arch.isSpirv()) {
117117 const spirv = std.Target.spirv.Feature;
118118 return @backingInt(switch (sub) {
119119 .spirv_v10 => spirv.v1_0,
lib/compiler/test_runner.zig+1-1
......@@ -36,7 +36,7 @@ const need_simple = switch (builtin.zig_backend) {
3636pub fn main(init: std.process.Init.Minimal) void {
3737 @disableInstrumentation();
3838
39 if (builtin.cpu.arch.isSpirV()) {
39 if (builtin.cpu.arch.isSpirv()) {
4040 // SPIR-V needs an special test-runner
4141 return;
4242 }
lib/std/Target.zig+1-1
......@@ -2381,7 +2381,7 @@ pub fn supportsAddressSpace(
23812381 const arch = target.cpu.arch;
23822382
23832383 const is_nvptx = arch.isNvptx();
2384 const is_spirv = arch.isSpirV();
2384 const is_spirv = arch.isSpirv();
23852385 const is_gpu = is_nvptx or is_spirv or arch == .amdgcn;
23862386
23872387 return switch (address_space) {
lib/std/debug.zig+1
......@@ -500,6 +500,7 @@ const use_trap_panic = switch (builtin.zig_backend) {
500500 .stage2_spirv,
501501 .stage2_x86,
502502 => true,
503 .stage2_llvm => builtin.cpu.arch.isSpirv(),
503504 else => false,
504505};
505506
lib/std/lang.zig+5
......@@ -1363,6 +1363,11 @@ pub const panic: type = p: {
13631363 .stage2_powerpc,
13641364 .stage2_riscv64,
13651365 => std.debug.simple_panic,
1366 .stage2_spirv => std.debug.no_panic,
1367 .stage2_llvm => {
1368 if (builtin.cpu.arch.isSpirv()) break :p std.debug.no_panic;
1369 break :p std.debug.FullPanic(std.debug.defaultPanic);
1370 },
13661371 else => std.debug.FullPanic(std.debug.defaultPanic),
13671372 };
13681373};
lib/std/mem.zig+1-1
......@@ -4889,7 +4889,7 @@ pub fn doNotOptimizeAway(val: anytype) void {
48894889 // tied to IDs that can be passed to valid instructions. Some
48904890 // SPIR-V targets do not define c_long, so we just allow any sized
48914891 // integer on these targets
4892 const val_fits_in_gp_register = builtin.target.cpu.arch.isSpirV() or fits: {
4892 const val_fits_in_gp_register = builtin.target.cpu.arch.isSpirv() or fits: {
48934893 const max_gp_register_bits = @bitSizeOf(c_long);
48944894 break :fits int.bits <= max_gp_register_bits;
48954895 };
lib/std/testing.zig+1
......@@ -36,6 +36,7 @@ pub const backend_can_print = switch (builtin.zig_backend) {
3636 .stage2_riscv64,
3737 .stage2_spirv,
3838 => false,
39 .stage2_llvm => !builtin.cpu.arch.isSpirv(),
3940 else => true,
4041};
4142
lib/std/zig/llvm/Builder.zig+70-7
......@@ -212,13 +212,27 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
212212 .powerpc => subArchName(target, .powerpc, .{
213213 .{ .spe, "spe" },
214214 }),
215 .spirv32, .spirv64 => subArchName(target, .spirv, .{
216 .{ .v1_6, "1.6" },
217 .{ .v1_5, "1.5" },
218 .{ .v1_4, "1.4" },
219 .{ .v1_3, "1.3" },
220 .{ .v1_2, "1.2" },
221 .{ .v1_1, "1.1" },
215 .spirv32 => switch (target.os.tag) {
216 .vulkan, .opengl => subArchName(target, .spirv, .{
217 .{ .v1_6, "1.6" },
218 .{ .v1_5, "1.5" },
219 }),
220 else => subArchName(target, .spirv, .{
221 .{ .v1_6, "v1.6" },
222 .{ .v1_5, "v1.5" },
223 .{ .v1_4, "v1.4" },
224 .{ .v1_3, "v1.3" },
225 .{ .v1_2, "v1.2" },
226 .{ .v1_1, "v1.1" },
227 }),
228 },
229 .spirv64 => subArchName(target, .spirv, .{
230 .{ .v1_6, "v1.6" },
231 .{ .v1_5, "v1.5" },
232 .{ .v1_4, "v1.4" },
233 .{ .v1_3, "v1.3" },
234 .{ .v1_2, "v1.2" },
235 .{ .v1_1, "v1.1" },
222236 }),
223237 else => null,
224238 };
......@@ -10234,6 +10248,55 @@ pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
1023410248 return self.opaqueTypeAssumeCapacity(name);
1023510249}
1023610250
10251pub fn targetType(
10252 self: *Builder,
10253 name: String,
10254 types: []const Type,
10255 ints: []const u32,
10256) Allocator.Error!Type {
10257 try self.ensureUnusedTypeCapacity(1, Type.Target, types.len + ints.len);
10258 const Key = struct { name: String, types: []const Type, ints: []const u32 };
10259 const Adapter = struct {
10260 builder: *const Builder,
10261 pub fn hash(_: @This(), key: Key) u32 {
10262 var hasher: std.hash.Wyhash = .init(comptime std.hash.int(@backingInt(Type.Tag.target)));
10263 hasher.update(std.mem.asBytes(&key.name));
10264 hasher.update(std.mem.sliceAsBytes(key.types));
10265 hasher.update(std.mem.sliceAsBytes(key.ints));
10266 return @truncate(hasher.final());
10267 }
10268 pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
10269 const rhs_data = ctx.builder.type_items.items[rhs_index];
10270 if (rhs_data.tag != .target) return false;
10271 var extra = ctx.builder.typeExtraDataTrail(Type.Target, rhs_data.data);
10272 if (lhs_key.name != extra.data.name) return false;
10273 const rhs_types = extra.trail.next(extra.data.types_len, Type, ctx.builder);
10274 const rhs_ints = extra.trail.next(extra.data.ints_len, u32, ctx.builder);
10275 return std.mem.eql(Type, lhs_key.types, rhs_types) and
10276 std.mem.eql(u32, lhs_key.ints, rhs_ints);
10277 }
10278 };
10279 const gop = self.type_map.getOrPutAssumeCapacityAdapted(
10280 Key{ .name = name, .types = types, .ints = ints },
10281 Adapter{ .builder = self },
10282 );
10283 if (!gop.found_existing) {
10284 gop.key_ptr.* = {};
10285 gop.value_ptr.* = {};
10286 self.type_items.appendAssumeCapacity(.{
10287 .tag = .target,
10288 .data = self.addTypeExtraAssumeCapacity(Type.Target{
10289 .name = name,
10290 .types_len = @intCast(types.len),
10291 .ints_len = @intCast(ints.len),
10292 }),
10293 });
10294 self.type_extra.appendSliceAssumeCapacity(@ptrCast(types));
10295 self.type_extra.appendSliceAssumeCapacity(ints);
10296 }
10297 return @fromBackingInt(@intCast(gop.index));
10298}
10299
1023710300pub fn namedTypeSetBody(
1023810301 self: *Builder,
1023910302 named_type: Type,
src/Compilation.zig+2-1
......@@ -1300,7 +1300,7 @@ pub const cache_helpers = struct {
13001300 const tag: @typeInfo(Config.DebugFormat).@"union".tag_type.? = x;
13011301 hh.add(tag);
13021302 switch (x) {
1303 .strip, .code_view => {},
1303 .strip, .code_view, .nsdi => {},
13041304 .dwarf => |f| hh.add(f),
13051305 }
13061306 }
......@@ -6303,6 +6303,7 @@ fn addCommonCCArgs(
63036303 try argv.ensureUnusedCapacity(2);
63046304 switch (comp.config.debug_format) {
63056305 .strip => {},
6306 .nsdi => argv.appendAssumeCapacity("-g"),
63066307 .code_view => {
63076308 // -g is required here because -gcodeview doesn't trigger debug info
63086309 // generation, it only changes the type of information generated.
src/Compilation/Config.zig+4-1
......@@ -72,6 +72,8 @@ pub const DebugFormat = union(enum) {
7272 strip,
7373 dwarf: std.dwarf.Format,
7474 code_view,
75 /// Non-semantic Shader Debug Info
76 nsdi,
7577};
7678
7779pub const Options = struct {
......@@ -517,7 +519,8 @@ pub fn resolve(options: Options) ResolveError!Config {
517519 .windows, .uefi => .code_view,
518520 else => .{ .dwarf = .@"32" },
519521 },
520 .spirv, .hex, .raw, .plan9 => .strip,
522 .spirv => .nsdi,
523 .hex, .raw, .plan9 => .strip,
521524 };
522525 };
523526
src/Sema.zig+23-48
......@@ -6977,7 +6977,7 @@ fn analyzeCall(
69776977 const is_inline_call = block.isComptime() or inline_requested;
69786978
69796979 if (!is_inline_call) {
6980 if (func_val == null and !func_is_extern and !block.is_typeof and zcu.getTarget().cpu.arch.isSpirV()) {
6980 if (func_val == null and !func_is_extern and !block.is_typeof and zcu.getTarget().cpu.arch.isSpirv()) {
69816981 return sema.fail(block, func_src, "SPIR-V does not support calling function pointers", .{});
69826982 }
69836983 if (sema.func_is_naked) return sema.failWithOwnedErrorMsg(block, msg: {
......@@ -8695,19 +8695,17 @@ fn checkParamType(
86958695 if (param_is_noalias and !param_ty.isGenericPoison() and !param_ty.isPtrAtRuntime(zcu) and !param_ty.isSliceAtRuntime(zcu)) {
86968696 return sema.fail(block, param_src, "non-pointer parameter declared noalias", .{});
86978697 }
8698 switch (target.os.tag) {
8699 .vulkan, .opengl => if (cc != .@"inline" and param_ty.isPtrAtRuntime(zcu)) {
8700 switch (param_ty.ptrAddressSpace(zcu)) {
8701 .input, .output => |as| return sema.failWithOwnedErrorMsg(block, msg: {
8702 const msg = try sema.errMsg(param_src, "function parameter cannot be a pointer in '{s}' address space", .{@tagName(as)});
8703 errdefer msg.destroy(sema.gpa);
8704 try sema.errNote(param_src, msg, "mark the function as 'inline' so the parameter is substituted at call sites", .{});
8705 break :msg msg;
8706 }),
8707 else => {},
8708 }
8709 },
8710 else => {},
8698 if (cc != .@"inline" and param_ty.isPtrAtRuntime(zcu)) {
8699 const as = param_ty.ptrAddressSpace(zcu);
8700 if (target_util.addrSpaceIsLogical(target, as)) switch (as) {
8701 .input, .output => return sema.failWithOwnedErrorMsg(block, msg: {
8702 const msg = try sema.errMsg(param_src, "function parameter cannot be a pointer in '{s}' address space", .{@tagName(as)});
8703 errdefer msg.destroy(sema.gpa);
8704 try sema.errNote(param_src, msg, "mark the function as 'inline' so the parameter is substituted at call sites", .{});
8705 break :msg msg;
8706 }),
8707 else => {},
8708 };
87118709 }
87128710}
87138711
......@@ -8944,9 +8942,7 @@ fn checkMergeAllowed(sema: *Sema, block: *Block, src: LazySrcLoc, peer_ty: Type)
89448942 }
89458943
89468944 const as = peer_ty.ptrAddressSpace(zcu);
8947 if (!target_util.shouldBlockPointerOps(target, as)) {
8948 return;
8949 }
8945 if (!target_util.addrSpaceIsLogical(target, as)) return;
89508946
89518947 return sema.failWithOwnedErrorMsg(block, msg: {
89528948 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(
1553515531 }
1553615532
1553715533 const constraint = sema.code.nullTerminatedString(input.data.constraint);
15538 if (zcu.getTarget().cpu.arch.isSpirV() and std.mem.eql(u8, constraint, "c")) {
15534 if (zcu.getTarget().cpu.arch.isSpirv() and std.mem.eql(u8, constraint, "c")) {
1553915535 const val = sema.resolveValue(arg.*) orelse {
1554015536 return sema.fail(block, input_src, "assembly input with 'c' constraint must be compile-time known", .{});
1554115537 };
......@@ -20925,7 +20921,7 @@ fn zirReifySpirvType(
2092520921 } },
2092620922 };
2092720923
20928 if (!target.cpu.arch.isSpirV()) {
20924 if (!target.cpu.arch.isSpirv()) {
2092920925 return sema.fail(
2093020926 block,
2093120927 src,
......@@ -22245,7 +22241,7 @@ fn ptrCastFull(
2224522241 try sema.validateRuntimeValue(block, operand_src, operand);
2224622242 try sema.checkLogicalPtrCast(block, src, operand_ty, dest_ty);
2224722243
22248 const can_cast_to_int = !target_util.shouldBlockPointerOps(zcu.getTarget(), operand_ty.ptrAddressSpace(zcu));
22244 const can_cast_to_int = !target_util.addrSpaceIsLogical(zcu.getTarget(), operand_ty.ptrAddressSpace(zcu));
2224922245 const need_null_check = can_cast_to_int and block.wantSafety() and operand_ty.ptrAllowsZero(zcu) and !dest_ty.ptrAllowsZero(zcu);
2225022246 const need_align_check = can_cast_to_int and block.wantSafety() and dest_align.compare(.gt, src_align);
2225122247
......@@ -22791,7 +22787,7 @@ fn checkLogicalPtrOperation(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Typ
2279122787 if (zcu.intern_pool.indexToKey(ty.toIntern()) == .ptr_type) {
2279222788 const target = zcu.getTarget();
2279322789 const as = ty.ptrAddressSpace(zcu);
22794 if (target_util.shouldBlockPointerOps(target, as)) {
22790 if (target_util.addrSpaceIsLogical(target, as)) {
2279522791 return sema.failWithOwnedErrorMsg(block, msg: {
2279622792 const msg = try sema.errMsg(src, "illegal operation on logical pointer of type '{f}'", .{ty.fmt(zcu)});
2279722793 errdefer msg.destroy(sema.gpa);
......@@ -22822,11 +22818,7 @@ fn checkLogicalPtrCast(
2282222818 const dest_child: Type = .fromInterned(dest_info.child);
2282322819
2282422820 if (block.isComptime() or block.is_typeof) return;
22825 switch (zcu.getTarget().os.tag) {
22826 .vulkan, .opengl => {},
22827 else => return,
22828 }
22829 if (src_info.flags.address_space == .physical_storage_buffer) return;
22821 if (!target_util.addrSpaceIsLogical(zcu.getTarget(), src_info.flags.address_space)) return;
2283022822 if (!dest_child.hasRuntimeBits(zcu)) return;
2283122823
2283222824 var cur = src_child;
......@@ -30294,28 +30286,11 @@ fn checkSpirvSliceAllowed(
3029430286 const zcu = sema.pt.zcu;
3029530287 const target = zcu.getTarget();
3029630288
30297 if (!target.cpu.arch.isSpirV()) return;
30289 if (!target.cpu.arch.isSpirv()) return;
3029830290 if (block.isComptime()) return;
3029930291
30300 // This probably lets some invalid OpPtrAccessChains slip through, but it's better than nothing
30301 if (!target.cpu.has(.spirv, .variable_pointers) and !target.cpu.has(.spirv, .variable_pointers_storage_buffer)) {
30302 return sema.failWithOwnedErrorMsg(
30303 block,
30304 try sema.errMsg(src, "cannot construct slices without the 'variable_pointers' or 'variable_pointers_storage_buffer' features", .{}),
30305 );
30306 }
30307
30308 switch (address_space) {
30309 .shared, .storage_buffer => {},
30310 else => {
30311 return sema.failWithOwnedErrorMsg(block, msg: {
30312 const msg = try sema.errMsg(src, "cannot construct slice from address space '{t}'", .{address_space});
30313 errdefer msg.destroy(sema.gpa);
30314 try sema.errNote(src, msg, "only 'shared' and 'storage_buffer' address spaces support slicing on SPIR-V", .{});
30315 break :msg msg;
30316 });
30317 },
30318 }
30292 if (!target_util.addrSpaceIsLogical(target, address_space)) return;
30293 return sema.fail(block, src, "cannot construct slice from logical address space '{t}'", .{address_space});
3031930294}
3032030295
3032130296fn coerceArrayPtrToSlice(
......@@ -35094,7 +35069,7 @@ pub fn resolveNavPtrModifiers(
3509435069 };
3509535070 const addrspace_body = zir_decl.addrspace_body orelse {
3509635071 if (zir_decl.linkage == .@"extern" and
35097 target.cpu.arch.isSpirV() and
35072 target.cpu.arch.isSpirv() and
3509835073 nav_ty.zigTypeTag(zcu) != .@"fn")
3509935074 {
3510035075 return sema.fail(
......@@ -35115,7 +35090,7 @@ pub fn resolveNavPtrModifiers(
3511535090 break :as try sema.analyzeAsAddressSpace(block, addrspace_src, addrspace_ref, addrspace_ctx);
3511635091 };
3511735092
35118 if (target.cpu.arch.isSpirV()) {
35093 if (target.cpu.arch.isSpirv()) {
3511935094 if (zir_decl.kind == .@"var" and zir_decl.linkage != .@"extern" and !zir_decl.is_threadlocal) {
3512035095 return sema.failWithOwnedErrorMsg(block, msg: {
3512135096 const decl_src = block.nodeOffset(.zero);
src/Type.zig+1-1
......@@ -3135,7 +3135,7 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
31353135 => false,
31363136
31373137 .vector => {
3138 if (zcu.getTarget().cpu.arch.isSpirV()) return true;
3138 if (zcu.getTarget().cpu.arch.isSpirv()) return true;
31393139 return position == .param_ty or position == .ret_ty;
31403140 },
31413141
src/Zcu.zig+1-1
......@@ -4101,7 +4101,7 @@ pub fn errorSetBits(zcu: *const Zcu) u16 {
41014101 const target = zcu.getTarget();
41024102
41034103 if (zcu.error_limit == 0) return 0;
4104 if (target.cpu.arch.isSpirV()) {
4104 if (target.cpu.arch.isSpirv()) {
41054105 // As expected by https://github.com/Snektron/zig-spirv-test-executor
41064106 if (zcu.comp.config.is_test) return 32;
41074107 }
src/codegen/llvm.zig+133-6
......@@ -455,6 +455,7 @@ pub const Object = struct {
455455
456456 switch (comp.config.debug_format) {
457457 .strip => unreachable,
458 .nsdi => {},
458459 .dwarf => |f| {
459460 module_flags.appendAssumeCapacity(try o.builder.metadataTuple(&.{
460461 behavior_max,
......@@ -994,6 +995,13 @@ pub const Object = struct {
994995 }
995996
996997 try fg.wip.finish();
998
999 // We don't use `builtin.test_functions` for running the SPIR-V tests so here is
1000 // a workaround to not optimize away test functions from the final module.
1001 if (target.cpu.arch.isSpirv() and zcu.test_functions.contains(func.owner_nav)) {
1002 try o.used.append(gpa, llvm_function.ptrConst(&o.builder).global.toConst());
1003 }
1004
9971005 try o.flushTypePool(pt);
9981006 }
9991007
......@@ -1002,6 +1010,7 @@ pub const Object = struct {
10021010 const ip = &zcu.intern_pool;
10031011 const comp = zcu.comp;
10041012 const gpa = comp.gpa;
1013 const arch = comp.root_mod.resolved_target.result.cpu.arch;
10051014
10061015 const nav = ip.getNav(nav_id);
10071016 const resolved = nav.resolved.?;
......@@ -1011,6 +1020,19 @@ pub const Object = struct {
10111020 else => null,
10121021 };
10131022 const nav_ty: Type = .fromInterned(resolved.type);
1023
1024 // Workaround for SPIR-V not supporting references to global constants.
1025 // Our choices here are only between bad (defaulting constant globals
1026 // address space to .private) and ugly (this). I went with ugly since
1027 // it's scoped and doesn't break anything for other targets.
1028 if (arch.isSpirv() and resolved.@"const" and opt_extern == null and nav_ty.zigTypeTag(zcu) != .@"fn") {
1029 if (o.nav_map.get(nav_id)) |llvm_global| {
1030 const llvm_ref = try o.lowerNavRef(nav_id);
1031 try llvm_global.replace(llvm_ref.unwrap().global, &o.builder);
1032 }
1033 return;
1034 }
1035
10141036 const llvm_ty: Builder.Type = if (opt_extern != null) ty: {
10151037 // We *must* lower this declaration no matter what. If it has a type we can't actually
10161038 // represent (because it doesn't have runtime bits), we instead lower as the zero-size
......@@ -1461,6 +1483,7 @@ pub const Object = struct {
14611483 .undefined,
14621484 .null,
14631485 .enum_literal,
1486 .spirv,
14641487 => return o.builder.debugSignedType(name, 0),
14651488
14661489 .float => return o.builder.debugFloatType(name, ty.floatBits(target)),
......@@ -1822,7 +1845,13 @@ pub const Object = struct {
18221845 while (it.next()) |field_index| {
18231846 const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
18241847 if (!field_ty.hasRuntimeBits(zcu)) continue;
1825 const field_size = field_ty.abiSize(zcu);
1848 const field_size = field_size: {
1849 if (field_ty.isSpirvRuntimeArray(zcu)) {
1850 assert(field_index == it.fields_len - 1);
1851 break :field_size 0;
1852 }
1853 break :field_size field_ty.abiSize(zcu);
1854 };
18261855 const field_align = switch (ty.explicitFieldAlignment(field_index, zcu)) {
18271856 .none => field_ty.abiAlignment(zcu),
18281857 else => |a| a,
......@@ -2097,7 +2126,6 @@ pub const Object = struct {
20972126 },
20982127 .frame => @panic("TODO implement lowerDebugType for Frame types"),
20992128 .@"anyframe" => @panic("TODO implement lowerDebugType for AnyFrame types"),
2100 .spirv => unreachable,
21012129 }
21022130 }
21032131
......@@ -2855,7 +2883,8 @@ pub const Object = struct {
28552883
28562884 if (o.type_map.get(t.toIntern())) |value| return value;
28572885
2858 assert(struct_type.size > 0);
2886 // @SpirvType() can create opaque types which are zero-sized but cannot be ignored here.
2887 assert(struct_type.size > 0 or target.cpu.arch.isSpirv());
28592888
28602889 var llvm_field_types: std.ArrayList(Builder.Type) = .empty;
28612890 defer llvm_field_types.deinit(o.gpa);
......@@ -2890,7 +2919,11 @@ pub const Object = struct {
28902919
28912920 try llvm_field_types.append(o.gpa, try o.lowerType(field_ty, repr));
28922921
2893 offset += field_ty.abiSize(zcu);
2922 if (field_ty.isSpirvRuntimeArray(zcu)) {
2923 assert(field_index == it.fields_len - 1);
2924 } else {
2925 offset += field_ty.abiSize(zcu);
2926 }
28942927 }
28952928 {
28962929 const prev_offset = offset;
......@@ -3032,7 +3065,8 @@ pub const Object = struct {
30323065 );
30333066 return ty;
30343067 },
3035 .opaque_type, .spirv_type => unreachable, // no runtime bits
3068 .opaque_type => unreachable,
3069 .spirv_type => try o.lowerSpirvType(t),
30363070 .enum_type => try o.intType(t.backingIntType(zcu).intInfo(zcu).bits, repr),
30373071 .func_type => |func_type| {
30383072 assert(t.fnHasRuntimeBits(zcu));
......@@ -3063,6 +3097,74 @@ pub const Object = struct {
30633097 };
30643098 }
30653099
3100 fn lowerSpirvType(o: *Object, t: Type) Allocator.Error!Builder.Type {
3101 const zcu = o.zcu;
3102 const ip = &zcu.intern_pool;
3103 const os_tag = zcu.comp.root_mod.resolved_target.result.os.tag;
3104
3105 const spirv_ty = ip.loadSpirvType(t.toIntern());
3106 switch (spirv_ty.flags.tag) {
3107 .sampler => return o.builder.targetType(try o.builder.string("spirv.Sampler"), &.{}, &.{}),
3108 .image, .sampled_image => {
3109 const image_ty = if (spirv_ty.flags.tag == .image) spirv_ty else ip.loadSpirvType(spirv_ty.ty);
3110 const sampled_ty = sampled_ty: {
3111 if (image_ty.ty == .void_type) break :sampled_ty .void;
3112 break :sampled_ty try o.lowerType(.fromInterned(image_ty.ty), .in_memory);
3113 };
3114 const image_flags = image_ty.flags;
3115 const ints = [_]u32{
3116 switch (image_flags.dim) {
3117 .@"1d" => 0,
3118 .@"2d" => 1,
3119 .@"3d" => 2,
3120 .cube => 3,
3121 },
3122 switch (image_flags.depth) {
3123 .not_depth => 0,
3124 .depth => 1,
3125 .unknown => 2,
3126 },
3127 @intFromBool(image_flags.is_arrayed),
3128 @intFromBool(image_flags.is_multisampled),
3129 switch (image_flags.usage) {
3130 .unknown => 0,
3131 .sampled => 1,
3132 .storage => 2,
3133 },
3134 switch (image_flags.format) {
3135 .unknown => 0,
3136 .rgba32f => 1,
3137 .rgba16f => 2,
3138 .r32f => 3,
3139 .rgba8unorm => 4,
3140 .rgba8snorm => 5,
3141 .rgba32i => 21,
3142 .rgba16i => 22,
3143 .rgba8i => 23,
3144 .r32i => 24,
3145 .rgba32u => 30,
3146 .rgba16u => 31,
3147 .rgba8u => 32,
3148 .r32u => 33,
3149 },
3150 switch (image_flags.access) {
3151 .unknown => 0,
3152 .read_only => 0,
3153 .write_only => 1,
3154 .read_write => 2,
3155 },
3156 };
3157 const name = if (spirv_ty.flags.tag == .image) "spirv.Image" else "spirv.SampledImage";
3158 const ints_len: usize = if (os_tag == .opencl) 7 else 6;
3159 return o.builder.targetType(try o.builder.string(name), &.{sampled_ty}, ints[0..ints_len]);
3160 },
3161 .runtime_array => {
3162 const elem_ty = try o.lowerType(.fromInterned(spirv_ty.ty), .in_memory);
3163 return o.builder.arrayType(0, elem_ty);
3164 },
3165 }
3166 }
3167
30663168 pub const FuncInfo = struct {
30673169 cc: std.lang.CallingConvention,
30683170 noalias_bits: u32 = 0,
......@@ -3890,6 +3992,7 @@ pub const Object = struct {
38903992 const zcu = o.zcu;
38913993 const ip = &zcu.intern_pool;
38923994 const gpa = zcu.comp.gpa;
3995 const target = &zcu.comp.root_mod.resolved_target.result;
38933996
38943997 const nav = ip.getNav(nav_id);
38953998 const nav_ty: Type = .fromInterned(nav.resolved.?.type);
......@@ -3901,6 +4004,17 @@ pub const Object = struct {
39014004 return o.lowerPtrToVoid(nav_align.toLlvm(), nav.resolved.?.@"addrspace");
39024005 }
39034006
4007 // Workaround for SPIR-V not supporting references to global constants.
4008 if (target.cpu.arch.isSpirv() and nav.resolved.?.@"const" and nav.getExtern(ip) == null and
4009 nav_ty.zigTypeTag(zcu) != .@"fn" and nav.resolved.?.value != .none)
4010 {
4011 const nav_align = switch (nav.resolved.?.@"align") {
4012 .none => nav_ty.abiAlignment(zcu),
4013 else => |a| a,
4014 };
4015 return o.lowerUavRef(nav.resolved.?.value, nav_align.toLlvm(), nav.resolved.?.@"addrspace");
4016 }
4017
39044018 const gop = try o.nav_map.getOrPut(gpa, nav_id);
39054019 if (!gop.found_existing) {
39064020 errdefer assert(o.nav_map.remove(nav_id));
......@@ -3917,7 +4031,7 @@ pub const Object = struct {
39174031 // We need to make sure the global's address space is up to date, because that affects the
39184032 // type of a pointer to this global. But everything else about the global will be populated
39194033 // by `updateNav` or `updateFunc`.
3920 llvm_global.ptr(&o.builder).addr_space = toLlvmAddressSpace(nav.resolved.?.@"addrspace", zcu.getTarget());
4034 llvm_global.ptr(&o.builder).addr_space = toLlvmAddressSpace(nav.resolved.?.@"addrspace", target);
39214035 return llvm_global.toConst();
39224036 }
39234037
......@@ -4445,6 +4559,19 @@ pub fn toLlvmAddressSpace(address_space: std.lang.AddressSpace, target: *const s
44454559 .local => Builder.AddrSpace.nvptx.local,
44464560 else => unreachable,
44474561 },
4562 .spirv32, .spirv64 => switch (address_space) {
4563 .generic, .local => Builder.AddrSpace.spirv.function,
4564 .global => Builder.AddrSpace.spirv.cross_workgroup,
4565 .constant => Builder.AddrSpace.spirv.uniform_constant,
4566 .shared => Builder.AddrSpace.spirv.workgroup,
4567 .private => Builder.AddrSpace.spirv.private,
4568 .input => Builder.AddrSpace.spirv.input,
4569 .output => Builder.AddrSpace.spirv.output,
4570 .storage_buffer => Builder.AddrSpace.spirv.storage_buffer,
4571 .uniform => Builder.AddrSpace.spirv.uniform,
4572 .push_constant => Builder.AddrSpace.spirv.push_constant,
4573 else => unreachable,
4574 },
44484575 .x86, .x86_64 => switch (address_space) {
44494576 .generic => .default,
44504577 .gs => Builder.AddrSpace.x86.gs,
src/codegen/llvm/FuncGen.zig+4
......@@ -1780,6 +1780,10 @@ fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index, is_dispatch_loop: bool) Tod
17801780 // * https://github.com/llvm/llvm-project/blob/56905dab7da50bccfcceaeb496b206ff476127e1/llvm/test/MC/WebAssembly/blockaddress.ll
17811781 if (zcu.comp.getTarget().cpu.arch.isWasm()) break :jmp_table null;
17821782
1783 // Workaround for:
1784 // * https://github.com/llvm/llvm-project/blob/0cd28174a1f64e5a8df194422ebf46e88cff33ad/llvm/lib/Target/SPIRV/SPIRVStructurizer.cpp#L279
1785 if (zcu.comp.getTarget().cpu.arch.isSpirv()) break :jmp_table null;
1786
17831787 // On a 64-bit target, 1024 pointers in our jump table is about 8K of pointers. This seems just
17841788 // about acceptable - it won't fill L1d cache on most CPUs.
17851789 const max_table_len = 1024;
src/codegen/spirv/Assembler.zig+9-13
......@@ -784,21 +784,17 @@ fn parseNumber(ass: *Assembler) !void {
784784 const result = try ass.resolveRef(ass.inst.operands.items[0].ref_id);
785785 const result_id = result.resultId();
786786
787 const words = cg.module.instructions.items;
788 var offset: usize = 0;
789 while (offset < words.len) {
790 const header: spec.InstructionHeader = @bitCast(words[offset]);
791 const word_count = header.word_count;
792 defer offset += word_count;
793 if (word_count == 0) break;
794 switch (header.opcode) {
795 .OpTypeInt => if (word_count >= 4 and @as(Id, @fromBackingInt(@intCast(words[offset + 1]))) == result_id) {
796 const width: u16 = @intCast(words[offset + 2]);
797 const signedness: std.lang.Signedness = if (words[offset + 3] == 0) .unsigned else .signed;
787 var it = cg.module.iterate();
788 while (it.next()) |instruction| {
789 const words = instruction.words;
790 switch (instruction.opcode) {
791 .OpTypeInt => if (words.len >= 4 and @as(Id, @fromBackingInt(@intCast(words[1]))) == result_id) {
792 const width: u16 = @intCast(words[2]);
793 const signedness: std.lang.Signedness = if (words[3] == 0) .unsigned else .signed;
798794 return ass.parseContextDependentInt(signedness, width);
799795 },
800 .OpTypeFloat => if (word_count >= 3 and @as(Id, @fromBackingInt(@intCast(words[offset + 1]))) == result_id) {
801 const bits = words[offset + 2];
796 .OpTypeFloat => if (words.len >= 3 and @as(Id, @fromBackingInt(@intCast(words[1]))) == result_id) {
797 const bits = words[2];
802798 return switch (bits) {
803799 16 => ass.parseContextDependentFloat(16),
804800 32 => ass.parseContextDependentFloat(32),
src/codegen/spirv/CodeGen.zig+83-255
......@@ -13,7 +13,6 @@ next_result_id: Word = 1,
1313navs: std.array_hash_map.Auto(InternPool.Nav.Index, Id) = .empty,
1414externs: std.array_hash_map.Auto(InternPool.Nav.Index, Mir.Extern) = .empty,
1515entry_points: std.ArrayList(Mir.EntryPoint) = .empty,
16error_buffer: ?Id = null,
1716struct_types: std.array_hash_map.Custom(StructType, Id, StructType.HashContext, true) = .empty,
1817/// SPIR-V ids of OpVariables whose pointee is a Block struct
1918block_var_ids: std.AutoHashMapUnmanaged(Id, void) = .empty,
......@@ -202,9 +201,7 @@ pub fn generate(
202201 defer cg.deinit();
203202
204203 const return_ty_id = try cg.resolveFnReturnType(.fromInterned(fn_info.return_type));
205 const is_test = zcu.test_functions.contains(nav_index);
206204 const nav_id = try cg.resolveNav(nav_index);
207 const function_id = if (is_test) cg.allocId() else nav_id;
208205
209206 try cg.args.ensureUnusedCapacity(gpa, fn_info.param_types.len);
210207 for (fn_info.param_types.get(ip)) |param_ty_index| {
......@@ -224,7 +221,7 @@ pub fn generate(
224221 const fn_ty_id = try cg.functionType(return_ty_id, cg.args.items(.ty));
225222 try cg.module.emit(gpa, .OpFunction, .{
226223 .id_result_type = return_ty_id,
227 .id_result = function_id,
224 .id_result = nav_id,
228225 .function_control = .{},
229226 .function_type = fn_ty_id,
230227 });
......@@ -236,8 +233,7 @@ pub fn generate(
236233 }
237234 try cg.module.append(gpa, cg.prologue);
238235 try cg.module.append(gpa, cg.body);
239 if (is_test) try cg.generateTestEntryPoint(nav.fqn.toSlice(ip), nav_id, function_id);
240 try cg.debugName(function_id, nav.fqn.toSlice(ip));
236 try cg.debugName(nav_id, nav.fqn.toSlice(ip));
241237
242238 return cg.toOwnedMir();
243239}
......@@ -816,21 +812,20 @@ pub fn memberDebugName(cg: *CodeGen, target: Id, member: u32, name: []const u8)
816812pub fn storageClass(cg: *const CodeGen, as: std.lang.AddressSpace) spec.StorageClass {
817813 const target = cg.zcu.getTarget();
818814 return switch (as) {
819 .generic => .function,
820815 .global => switch (target.os.tag) {
821816 .opencl, .amdhsa => .cross_workgroup,
822 else => .storage_buffer,
817 else => unreachable,
823818 },
819 .local, .generic => .function,
824820 .push_constant => .push_constant,
825 .output => .output,
826821 .uniform => .uniform,
827822 .storage_buffer => .storage_buffer,
828823 .physical_storage_buffer => .physical_storage_buffer,
829824 .constant => .uniform_constant,
830825 .shared => .workgroup,
831 .local => .function,
832826 .private => .private,
833827 .input => .input,
828 .output => .output,
834829 .gs,
835830 .fs,
836831 .ss,
......@@ -1689,14 +1684,14 @@ fn constantPtr(cg: *CodeGen, ptr_val: Value) !Id {
16891684/// This function emits instructions on every call, and they stay in the module whether or not they
16901685/// are read, so it should only be called where the resulting type is used: a buffer struct emitted
16911686/// without `Block` fails validation even when nothing refers to it.
1692fn derivedPtrType(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
1687fn derivedPtrType(cg: *CodeGen, as: std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
16931688 return cg.ptrType(
1694 try cg.pointeeType(@"addrspace", derivation.elem_ty, false),
1695 cg.storageClass(@"addrspace"),
1689 try cg.pointeeType(as, derivation.elem_ty, false),
1690 cg.storageClass(as),
16961691 );
16971692}
16981693
1699fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
1694fn derivePtr(cg: *CodeGen, as: std.lang.AddressSpace, derivation: Value.PointerDerivation) !Id {
17001695 const gpa = cg.gpa;
17011696 const zcu = cg.zcu;
17021697 const target = zcu.getTarget();
......@@ -1704,18 +1699,16 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
17041699 switch (derivation.addr) {
17051700 .comptime_alloc, .comptime_field => unreachable,
17061701 .int => |int| {
1707 if (target.os.tag != .opencl) {
1708 if (@"addrspace" != .physical_storage_buffer) {
1709 return cg.fail(
1710 "cannot cast integer to pointer with address space '{s}'",
1711 .{@tagName(@"addrspace")},
1712 );
1713 }
1702 if (target_util.addrSpaceIsLogical(target, as)) {
1703 return cg.fail(
1704 "cannot cast integer to pointer with address space '{s}'",
1705 .{@tagName(as)},
1706 );
17141707 }
17151708 // TODO: This can probably be an OpSpecConstantOp Bitcast, but
17161709 // that is not implemented by Mesa yet. Therefore, just generate it
17171710 // as a runtime operation.
1718 const result_ty_id = try cg.derivedPtrType(@"addrspace", derivation);
1711 const result_ty_id = try cg.derivedPtrType(as, derivation);
17191712 const result_ptr_id = cg.allocId();
17201713 const value_id = try cg.constInt(.usize, int);
17211714 try cg.body.emit(gpa, .OpConvertUToPtr, .{
......@@ -1735,30 +1728,26 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
17351728
17361729 if (ip.isFunctionType(nav_ty.toIntern())) {
17371730 if (is_extern) return try cg.resolveExternFn(nav_index);
1738 return try cg.constUndef(try cg.derivedPtrType(@"addrspace", derivation));
1731 return try cg.constUndef(try cg.derivedPtrType(as, derivation));
17391732 }
17401733 if (!nav_ty.hasRuntimeBits(zcu) and nav_ty.zigTypeTag(zcu) != .spirv) {
1741 return cg.constUndef(try cg.derivedPtrType(@"addrspace", derivation));
1734 return cg.constUndef(try cg.derivedPtrType(as, derivation));
17421735 }
17431736 if (!is_extern) {
17441737 return cg.todo("pointer to constant '{f}'", .{nav.fqn.fmt(ip)});
17451738 }
17461739
1747 const as = nav.resolved.?.@"addrspace";
1748 assert(as != .generic);
1740 assert(nav.resolved.?.@"addrspace" != .generic);
17491741
17501742 const var_id = try cg.resolveNav(nav_index);
17511743 if (cg.needsLayout(as, nav_ty)) {
17521744 try cg.block_var_ids.put(gpa, var_id, {});
17531745 }
1754 switch (target.os.tag) {
1755 .vulkan, .opengl => return var_id,
1756 else => {},
1757 }
1746 if (target_util.addrSpaceIsLogical(target, as)) return var_id;
17581747
17591748 const nav_ty_id = try cg.resolveType(nav_ty, .indirect);
17601749 const decl_ptr_ty_id = try cg.ptrType(nav_ty_id, cg.storageClass(as));
1761 const result_ty_id = try cg.derivedPtrType(@"addrspace", derivation);
1750 const result_ty_id = try cg.derivedPtrType(as, derivation);
17621751 if (decl_ptr_ty_id == result_ty_id) return var_id;
17631752
17641753 const casted_ptr_id = cg.allocId();
......@@ -1780,10 +1769,10 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
17801769 }
17811770
17821771 if (!uav_ty.hasRuntimeBits(zcu) and uav_ty.zigTypeTag(zcu) != .spirv) {
1783 return cg.constUndef(try cg.derivedPtrType(@"addrspace", derivation));
1772 return cg.constUndef(try cg.derivedPtrType(as, derivation));
17841773 }
17851774
1786 if (cg.storageClass(@"addrspace") != .function) {
1775 if (cg.storageClass(as) != .function) {
17871776 return cg.todo("pointer to an anonymous constant of type '{f}'", .{uav_ty.fmt(zcu)});
17881777 }
17891778
......@@ -1796,11 +1785,11 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
17961785 .eu_payload => @panic("TODO"),
17971786 .opt_payload => @panic("TODO"),
17981787 .field => |derived| return cg.structFieldPtr(
1799 @"addrspace",
1800 try cg.derivedPtrType(@"addrspace", derivation),
1788 as,
1789 try cg.derivedPtrType(as, derivation),
18011790 derivation.elem_ty,
18021791 derived.parent.elem_ty,
1803 try cg.derivePtr(@"addrspace", derived.parent.*),
1792 try cg.derivePtr(as, derived.parent.*),
18041793 derived.field_index,
18051794 ),
18061795 .elem => |derived| return cg.ptrElemPtr(
......@@ -1808,13 +1797,13 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
18081797 .one => .single_array_ptr,
18091798 .many => .many_ptr,
18101799 },
1811 @"addrspace",
1800 as,
18121801 derivation.elem_ty,
1813 try cg.derivePtr(@"addrspace", derived.parent.*),
1802 try cg.derivePtr(as, derived.parent.*),
18141803 try cg.constInt(.usize, derived.elem_index),
18151804 ),
18161805 .offset_and_cast => |derived| {
1817 const parent_ptr_id = try cg.derivePtr(@"addrspace", derived.parent.*);
1806 const parent_ptr_id = try cg.derivePtr(as, derived.parent.*);
18181807
18191808 if (derived.byte_offset == 0) {
18201809 var depth: u32 = 0;
......@@ -1849,13 +1838,13 @@ fn derivePtr(cg: *CodeGen, @"addrspace": std.lang.AddressSpace, derivation: Valu
18491838 const zero = try cg.constInt(.u32, 0);
18501839 const ids = try cg.id_scratch.addManyAsSlice(gpa, depth);
18511840 @memset(ids, zero);
1852 return cg.accessChainId(try cg.derivedPtrType(@"addrspace", derivation), parent_ptr_id, ids);
1841 return cg.accessChainId(try cg.derivedPtrType(as, derivation), parent_ptr_id, ids);
18531842 } else {
18541843 return parent_ptr_id;
18551844 }
18561845 }
1857 if (target.os.tag == .opencl) {
1858 const result_ty_id = try cg.derivedPtrType(@"addrspace", derivation);
1846 if (!target_util.addrSpaceIsLogical(target, as)) {
1847 const result_ty_id = try cg.derivedPtrType(as, derivation);
18591848 const result_ptr_id = cg.allocId();
18601849 try cg.body.emit(gpa, .OpBitcast, .{
18611850 .id_result_type = result_ty_id,
......@@ -3788,149 +3777,6 @@ fn buildWideMul(
37883777}
37893778
37903779/// The SPIR-V backend is not yet advanced enough to support the std testing infrastructure.
3791/// In order to be able to run tests, we "temporarily" lower test kernels into separate entry-
3792/// points. The test executor will then be able to invoke these to run the tests.
3793/// Note that tests are lowered according to std.lang.TestFn, which is `fn () anyerror!void`.
3794/// (anyerror!void has the same layout as anyerror).
3795/// Each test declaration generates a function like.
3796/// %anyerror = OpTypeInt 0 16
3797/// %p_invocation_globals_struct_ty = ...
3798/// %p_anyerror = OpTypePointer CrossWorkgroup %anyerror
3799/// %K = OpTypeFunction %void %p_invocation_globals_struct_ty %p_anyerror
3800///
3801/// %test = OpFunction %void %K
3802/// %p_invocation_globals = OpFunctionParameter p_invocation_globals_struct_ty
3803/// %p_err = OpFunctionParameter %p_anyerror
3804/// %lbl = OpLabel
3805/// %result = OpFunctionCall %anyerror %func %p_invocation_globals
3806/// OpStore %p_err %result
3807/// OpFunctionEnd
3808/// TODO is to also write out the error as a function call parameter, and to somehow fetch
3809/// the name of an error in the text executor.
3810fn generateTestEntryPoint(
3811 cg: *CodeGen,
3812 name: []const u8,
3813 kernel_id: Id,
3814 test_id: Id,
3815) !void {
3816 const gpa = cg.gpa;
3817 const zcu = cg.zcu;
3818 const target = cg.zcu.getTarget();
3819
3820 const anyerror_ty_id = try cg.resolveType(.anyerror, .direct);
3821 const ptr_anyerror_ty = try cg.pt.ptrType(.{
3822 .child = .anyerror_type,
3823 .flags = .{ .address_space = .global },
3824 });
3825 const ptr_anyerror_ty_id = try cg.resolveType(ptr_anyerror_ty, .direct);
3826
3827 var section: Section = .empty;
3828 defer section.deinit(gpa);
3829
3830 const p_error_id = cg.allocId();
3831 switch (target.os.tag) {
3832 .opencl, .amdhsa => {
3833 const void_ty_id = try cg.resolveType(.void, .direct);
3834 const kernel_proto_ty_id = try cg.functionType(void_ty_id, &.{ptr_anyerror_ty_id});
3835
3836 try section.emit(gpa, .OpFunction, .{
3837 .id_result_type = try cg.resolveType(.void, .direct),
3838 .id_result = kernel_id,
3839 .function_control = .{},
3840 .function_type = kernel_proto_ty_id,
3841 });
3842
3843 try section.emit(gpa, .OpFunctionParameter, .{
3844 .id_result_type = ptr_anyerror_ty_id,
3845 .id_result = p_error_id,
3846 });
3847
3848 try section.emit(gpa, .OpLabel, .{
3849 .id_result = cg.allocId(),
3850 });
3851 },
3852 .vulkan, .opengl => {
3853 if (cg.error_buffer == null) {
3854 const buffer_struct_ty_id = cg.allocId();
3855 try cg.module.emit(gpa, .OpTypeStruct, .{
3856 .id_result = buffer_struct_ty_id,
3857 .id_ref = &.{anyerror_ty_id},
3858 });
3859 try cg.memberDebugName(buffer_struct_ty_id, 0, "error_out");
3860 try cg.decorate(buffer_struct_ty_id, .block);
3861 try cg.decorateMember(buffer_struct_ty_id, 0, .{ .offset = .{ .byte_offset = 0 } });
3862
3863 const ptr_buffer_struct_ty_id = cg.allocId();
3864 try cg.module.emit(gpa, .OpTypePointer, .{
3865 .id_result = ptr_buffer_struct_ty_id,
3866 .storage_class = cg.storageClass(.global),
3867 .type = buffer_struct_ty_id,
3868 });
3869
3870 const error_buffer_id = cg.allocId();
3871 cg.error_buffer = error_buffer_id;
3872 try cg.module.emit(gpa, .OpVariable, .{
3873 .id_result_type = ptr_buffer_struct_ty_id,
3874 .id_result = error_buffer_id,
3875 .storage_class = cg.storageClass(.global),
3876 });
3877 try cg.decorate(error_buffer_id, .{ .descriptor_set = .{ .descriptor_set = 0 } });
3878 try cg.decorate(error_buffer_id, .{ .binding = .{ .binding_point = 0 } });
3879 }
3880
3881 const void_ty_id = try cg.resolveType(.void, .direct);
3882 const kernel_proto_ty_id = try cg.functionType(void_ty_id, &.{});
3883 try section.emit(gpa, .OpFunction, .{
3884 .id_result_type = try cg.resolveType(.void, .direct),
3885 .id_result = kernel_id,
3886 .function_control = .{},
3887 .function_type = kernel_proto_ty_id,
3888 });
3889 try section.emit(gpa, .OpLabel, .{
3890 .id_result = cg.allocId(),
3891 });
3892
3893 const buffer_id = cg.error_buffer.?;
3894 const zero_id = try cg.constInt(.u32, 0);
3895 try section.emit(gpa, .OpInBoundsAccessChain, .{
3896 .id_result_type = ptr_anyerror_ty_id,
3897 .id_result = p_error_id,
3898 .base = buffer_id,
3899 .indexes = &.{zero_id},
3900 });
3901 },
3902 else => unreachable,
3903 }
3904
3905 const error_id = cg.allocId();
3906 try section.emit(gpa, .OpFunctionCall, .{
3907 .id_result_type = anyerror_ty_id,
3908 .id_result = error_id,
3909 .function = test_id,
3910 });
3911 // Note: Convert to direct not required.
3912 try section.emit(gpa, .OpStore, .{
3913 .pointer = p_error_id,
3914 .object = error_id,
3915 .memory_access = .{
3916 .aligned = .{ .literal_integer = @intCast(Type.abiAlignment(.anyerror, zcu).toByteUnits().?) },
3917 },
3918 });
3919 try section.emit(gpa, .OpReturn, {});
3920 try section.emit(gpa, .OpFunctionEnd, {});
3921 try cg.module.append(gpa, section);
3922
3923 // Just generate a quick other name because the intel runtime crashes when the entry-
3924 // point name is the same as a different OpName.
3925 const test_name = try std.fmt.allocPrint(gpa, "test {s}", .{name});
3926 errdefer gpa.free(test_name);
3927 try cg.entry_points.append(gpa, .{
3928 .id = kernel_id,
3929 .name = test_name,
3930 .cc = .{ .spirv_kernel = .{ .x = 1, .y = 1, .z = 1 } },
3931 });
3932}
3933
39343780fn intFromBool(cg: *CodeGen, value: Temporary, result_ty: Type) !Temporary {
39353781 const zero_id = try cg.constInt(result_ty, 0);
39363782 const one_id = try cg.constInt(result_ty, 1);
......@@ -5464,6 +5310,7 @@ fn accessChain(
54645310
54655311fn ptrAccessChain(
54665312 cg: *CodeGen,
5313 as: std.lang.AddressSpace,
54675314 result_ty_id: Id,
54685315 base: Id,
54695316 element: Id,
......@@ -5491,8 +5338,7 @@ fn ptrAccessChain(
54915338 });
54925339 },
54935340 .vulkan, .opengl => {
5494 assert(target.cpu.has(.spirv, .variable_pointers) or
5495 target.cpu.has(.spirv, .variable_pointers_storage_buffer));
5341 assert(!target_util.addrSpaceIsLogical(target, as));
54965342 try cg.body.emit(gpa, .OpPtrAccessChain, .{
54975343 .id_result_type = result_ty_id,
54985344 .id_result = result_id,
......@@ -5513,11 +5359,11 @@ fn ptrAdd(cg: *CodeGen, result_ty: Type, ptr_ty: Type, ptr_id: Id, offset_id: Id
55135359 const result_ty_id = try cg.ptrType(child_ty_id, cg.storageClass(as));
55145360 return switch (ptr_ty.ptrSize(zcu)) {
55155361 .one => cg.accessChainId(result_ty_id, ptr_id, &.{offset_id}),
5516 .c, .many => cg.ptrAccessChain(result_ty_id, ptr_id, offset_id, &.{}),
5362 .c, .many => cg.ptrAccessChain(as, result_ty_id, ptr_id, offset_id, &.{}),
55175363 .slice => blk: {
55185364 // TODO: This is probably incorrect. A slice should be returned here, though this is what llvm does.
55195365 const slice_ptr_id = try cg.extractField(result_ty, ptr_id, 0);
5520 break :blk cg.ptrAccessChain(result_ty_id, slice_ptr_id, offset_id, &.{});
5366 break :blk cg.ptrAccessChain(as, result_ty_id, slice_ptr_id, offset_id, &.{});
55215367 },
55225368 };
55235369}
......@@ -5770,8 +5616,8 @@ fn bitCast(
57705616 const target = zcu.getTarget();
57715617
57725618 if (src_ty.toIntern() == dst_ty.toIntern()) return src_id;
5773 if (src_ty.isPtrAtRuntime(zcu) and dst_ty.isPtrAtRuntime(zcu)) switch (target.os.tag) {
5774 .vulkan, .opengl => if (src_ty.ptrAddressSpace(zcu) != .physical_storage_buffer) {
5619 if (src_ty.isPtrAtRuntime(zcu) and dst_ty.isPtrAtRuntime(zcu)) {
5620 if (target_util.addrSpaceIsLogical(target, src_ty.ptrAddressSpace(zcu))) {
57755621 const src_child = src_ty.childType(zcu);
57765622 const dst_child = dst_ty.childType(zcu);
57775623 if (!dst_child.hasRuntimeBits(zcu)) return src_id;
......@@ -5797,9 +5643,8 @@ fn bitCast(
57975643 }
57985644 const dst_ty_id = try cg.resolveType(dst_ty, .direct);
57995645 return try cg.accessChain(dst_ty_id, src_id, indices.items);
5800 },
5801 else => {},
5802 };
5646 }
5647 }
58035648
58045649 const dst_ty_id = try cg.resolveType(dst_ty, .direct);
58055650 const result_id = blk: {
......@@ -5836,13 +5681,11 @@ fn bitCast(
58365681 }
58375682
58385683 if (src_ty.zigTypeTag(zcu) == .int and dst_ty.isPtrAtRuntime(zcu)) {
5839 if (target.os.tag != .opencl) {
5840 if (dst_ty.ptrAddressSpace(zcu) != .physical_storage_buffer) {
5841 return cg.fail(
5842 "cannot cast integer to pointer with address space '{s}'",
5843 .{@tagName(dst_ty.ptrAddressSpace(zcu))},
5844 );
5845 }
5684 if (target_util.addrSpaceIsLogical(target, dst_ty.ptrAddressSpace(zcu))) {
5685 return cg.fail(
5686 "cannot cast integer to pointer with address space '{s}'",
5687 .{@tagName(dst_ty.ptrAddressSpace(zcu))},
5688 );
58465689 }
58475690
58485691 const result_id = cg.allocId();
......@@ -5869,16 +5712,13 @@ fn bitCast(
58695712 break :blk result_id;
58705713 }
58715714
5872 switch (target.os.tag) {
5873 .vulkan, .opengl => {
5874 // Logical addressing forbids OpBitcast on pointers. Allocate
5875 // the temp with dst_ty so the load reads through a slot of the right type.
5876 const dst_ty_indirect_id = try cg.resolveType(dst_ty, .indirect);
5877 const tmp_id = try cg.alloc(dst_ty_indirect_id, null);
5878 try cg.store(dst_ty, tmp_id, src_id, .{});
5879 break :blk try cg.load(dst_ty, tmp_id, .{});
5880 },
5881 else => {},
5715 if (target_util.addrSpaceIsLogical(target, .local)) {
5716 // Logical addressing forbids OpBitcast on pointers. Allocate
5717 // the temp with dst_ty so the load reads through a slot of the right type.
5718 const dst_ty_indirect_id = try cg.resolveType(dst_ty, .indirect);
5719 const tmp_id = try cg.alloc(dst_ty_indirect_id, null);
5720 try cg.store(dst_ty, tmp_id, src_id, .{});
5721 break :blk try cg.load(dst_ty, tmp_id, .{});
58825722 }
58835723
58845724 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 {
64636303 const ptr_ty_id = try cg.resolveType(ptr_ty, .direct);
64646304
64656305 const slice_ptr = try cg.extractField(ptr_ty, slice_id, 0);
6466 return try cg.ptrAccessChain(ptr_ty_id, slice_ptr, index_id, &.{});
6306 return try cg.ptrAccessChain(ptr_ty.ptrAddressSpace(zcu), ptr_ty_id, slice_ptr, index_id, &.{});
64676307}
64686308
64696309fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
......@@ -6479,22 +6319,22 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
64796319 const ptr_ty_id = try cg.resolveType(ptr_ty, .direct);
64806320
64816321 const slice_ptr = try cg.extractField(ptr_ty, slice_id, 0);
6482 const elem_ptr = try cg.ptrAccessChain(ptr_ty_id, slice_ptr, index_id, &.{});
6322 const elem_ptr = try cg.ptrAccessChain(ptr_ty.ptrAddressSpace(zcu), ptr_ty_id, slice_ptr, index_id, &.{});
64836323 return try cg.load(slice_ty.childType(zcu), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(zcu) });
64846324}
64856325
64866326fn ptrElemPtr(
64876327 cg: *CodeGen,
64886328 mode: enum { single_array_ptr, many_ptr },
6489 @"addrspace": std.lang.AddressSpace,
6329 as: std.lang.AddressSpace,
64906330 elem_ty: Type,
64916331 ptr_id: Id,
64926332 index_id: Id,
64936333) !Id {
64946334 // Construct new pointer type for the resulting pointer
64956335 const elem_is_block = cg.block_var_ids.contains(ptr_id);
6496 const elem_ty_id = try cg.pointeeType(@"addrspace", elem_ty, elem_is_block);
6497 const elem_ptr_ty_id = try cg.ptrType(elem_ty_id, cg.storageClass(@"addrspace"));
6336 const elem_ty_id = try cg.pointeeType(as, elem_ty, elem_is_block);
6337 const elem_ptr_ty_id = try cg.ptrType(elem_ty_id, cg.storageClass(as));
64986338 switch (mode) {
64996339 .single_array_ptr => {
65006340 // Pointer-to-array. In this case, the resulting pointer is not of the same type
......@@ -6503,7 +6343,7 @@ fn ptrElemPtr(
65036343 },
65046344 .many_ptr => {
65056345 // Resulting pointer type is the same as the ptr_ty, so use ptrAccessChain
6506 return cg.ptrAccessChain(elem_ptr_ty_id, ptr_id, index_id, &.{});
6346 return cg.ptrAccessChain(as, elem_ptr_ty_id, ptr_id, index_id, &.{});
65076347 },
65086348 }
65096349}
......@@ -6821,14 +6661,11 @@ fn airAggFieldVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
68216661 return try cg.load(field_ty, pl_ptr_id, .{});
68226662 }
68236663
6824 switch (zcu.getTarget().os.tag) {
6825 .vulkan, .opengl => {
6826 // Logical addressing forbids OpBitcast on pointers. Load the
6827 // payload as its type and bitcast the value instead.
6828 const payload_id = try cg.load(layout.payload_ty, pl_ptr_id, .{});
6829 return try cg.bitCast(field_ty, layout.payload_ty, payload_id);
6830 },
6831 else => {},
6664 if (target_util.addrSpaceIsLogical(zcu.getTarget(), .local)) {
6665 // Logical addressing forbids OpBitcast on pointers. Load the
6666 // payload as its type and bitcast the value instead.
6667 const payload_id = try cg.load(layout.payload_ty, pl_ptr_id, .{});
6668 return try cg.bitCast(field_ty, layout.payload_ty, payload_id);
68326669 }
68336670
68346671 const field_ty_id = try cg.resolveType(field_ty, .indirect);
......@@ -6871,13 +6708,11 @@ fn airFieldParentPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
68716708 break :base_ptr_int try result.materialize(cg);
68726709 };
68736710
6874 if (target.os.tag != .opencl) {
6875 if (field_ptr_ty.ptrAddressSpace(zcu) != .physical_storage_buffer) {
6876 return cg.fail(
6877 "cannot cast integer to pointer with address space '{s}'",
6878 .{@tagName(field_ptr_ty.ptrAddressSpace(zcu))},
6879 );
6880 }
6711 if (target_util.addrSpaceIsLogical(target, field_ptr_ty.ptrAddressSpace(zcu))) {
6712 return cg.fail(
6713 "cannot cast integer to pointer with address space '{s}'",
6714 .{@tagName(field_ptr_ty.ptrAddressSpace(zcu))},
6715 );
68816716 }
68826717
68836718 const base_ptr = cg.allocId();
......@@ -6892,7 +6727,7 @@ fn airFieldParentPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
68926727
68936728fn structFieldPtr(
68946729 cg: *CodeGen,
6895 @"addrspace": std.lang.AddressSpace,
6730 as: std.lang.AddressSpace,
68966731 result_ptr_ty_id: Id,
68976732 field_ty: Type,
68986733 object_ty: Type,
......@@ -6926,21 +6761,18 @@ fn structFieldPtr(
69266761 return try cg.constUndef(result_ptr_ty_id);
69276762 }
69286763
6929 const storage_class = cg.storageClass(@"addrspace");
6764 const storage_class = cg.storageClass(as);
69306765 if (field_ty.toIntern() == layout.payload_ty.toIntern()) {
69316766 if (object_ty.containerLayout(zcu) == .@"packed") return object_ptr;
69326767 return try cg.accessChain(result_ptr_ty_id, object_ptr, &.{layout.payload_index});
69336768 }
69346769
6935 switch (zcu.getTarget().os.tag) {
6936 .vulkan, .opengl => {
6937 // Logical addressing forbids OpBitcast on pointers. If the field
6938 // type is structurally identical to the payload type (dedup will
6939 // unify them) the access chain typed as the field type is valid.
6940 if (object_ty.containerLayout(zcu) == .@"packed") return object_ptr;
6941 return try cg.accessChain(result_ptr_ty_id, object_ptr, &.{layout.payload_index});
6942 },
6943 else => {},
6770 if (target_util.addrSpaceIsLogical(zcu.getTarget(), as)) {
6771 // Logical addressing forbids OpBitcast on pointers. If the field
6772 // type is structurally identical to the payload type (dedup will
6773 // unify them) the access chain typed as the field type is valid.
6774 if (object_ty.containerLayout(zcu) == .@"packed") return object_ptr;
6775 return try cg.accessChain(result_ptr_ty_id, object_ptr, &.{layout.payload_index});
69446776 }
69456777
69466778 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 {
70396871 const ptr_ty = cg.typeOfIndex(inst);
70406872 const child_ty = ptr_ty.childType(zcu);
70416873
7042 switch (target.os.tag) {
7043 .vulkan, .opengl => {
7044 if (child_ty.zigTypeTag(zcu) == .pointer and !child_ty.isSlice(zcu)) {
7045 const as = child_ty.ptrAddressSpace(zcu);
7046 if (cg.storageClass(as) == .function) {
7047 const result_id = cg.allocId();
7048 try cg.tracked_allocas.put(cg.gpa, result_id, null);
7049 return result_id;
7050 }
7051 }
7052 },
7053 else => {},
6874 if (child_ty.zigTypeTag(zcu) == .pointer and !child_ty.isSlice(zcu)) {
6875 const as = child_ty.ptrAddressSpace(zcu);
6876 if (target_util.addrSpaceIsLogical(target, as) and cg.storageClass(as) == .function) {
6877 const result_id = cg.allocId();
6878 try cg.tracked_allocas.put(cg.gpa, result_id, null);
6879 return result_id;
6880 }
70546881 }
70556882
70566883 const child_ty_id = try cg.resolveType(child_ty, .indirect);
......@@ -8790,6 +8617,7 @@ const log = std.log.scoped(.codegen);
87908617const builtin = @import("builtin");
87918618const link = @import("../../link.zig");
87928619const codegen = @import("../../codegen.zig");
8620const target_util = @import("../../target.zig");
87938621const Zcu = @import("../../Zcu.zig");
87948622const Type = @import("../../Type.zig");
87958623const Value = @import("../../Value.zig");
src/codegen/spirv/Section.zig+46-7
......@@ -14,6 +14,38 @@ ids: std.bit_set.Dynamic,
1414
1515pub const empty: Section = .{ .instructions = .empty, .ids = .{} };
1616
17pub const InstructionIterator = struct {
18 words: []const Word,
19 offset: usize = 0,
20
21 pub const Instruction = struct {
22 opcode: Opcode,
23 words: []const Word,
24 start: usize,
25 end: usize,
26 result_id: Id,
27 };
28
29 pub fn next(it: *InstructionIterator) ?Instruction {
30 if (it.offset >= it.words.len) return null;
31 const start = it.offset;
32 const header: InstructionHeader = @bitCast(it.words[start]);
33 const words = it.words[start..][0..header.word_count];
34 it.offset += words.len;
35 return .{
36 .opcode = header.opcode,
37 .words = words,
38 .start = start,
39 .end = it.offset,
40 .result_id = if (header.opcode.resultIndex()) |i| @fromBackingInt(words[i]) else .none,
41 };
42 }
43};
44
45pub fn iterate(section: *const Section) InstructionIterator {
46 return .{ .words = section.instructions.items };
47}
48
1749pub const Error = error{
1850 OutOfMemory,
1951 UnknownOpcode,
......@@ -31,7 +63,7 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
3163 const type_widths = try gpa.alloc(u16, id_bound);
3264 defer gpa.free(type_widths);
3365 @memset(type_widths, 0);
34 var instruction_sets: std.array_hash_map.Auto(Word, spec.InstructionSet) = .empty;
66 var instruction_sets: std.array_hash_map.Auto(Word, ?spec.InstructionSet) = .empty;
3567 defer instruction_sets.deinit(gpa);
3668 var results: std.bit_set.Dynamic = try .initEmpty(gpa, id_bound);
3769 defer results.deinit(gpa);
......@@ -48,18 +80,18 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
4880 return error.UnknownOpcode;
4981 const end = offset + len;
5082 var index = offset + 1;
51 const list: []const spec.Operand = switch (op) {
52 .OpFunction => list: {
83 const list: []const spec.Operand = list: switch (op) {
84 .OpFunction => {
5385 if (in_function) return error.NestedFunction;
5486 in_function = true;
5587 break :list op.operands();
5688 },
57 .OpFunctionEnd => list: {
89 .OpFunctionEnd => {
5890 if (!in_function) return error.InvalidInstruction;
5991 in_function = false;
6092 break :list op.operands();
6193 },
62 .OpSpecConstantOp => list: {
94 .OpSpecConstantOp => {
6395 const prefix = op.operands()[0..2];
6496 index = try section.parseOperands(type_widths, offset, end, prefix, index);
6597 if (index >= end) return error.InvalidInstruction;
......@@ -68,9 +100,14 @@ pub fn fromWords(gpa: Allocator, words: []const Word, id_bound: Word) Error!Sect
68100 index += 1;
69101 break :list inner.operands()[2..];
70102 },
71 .OpExtInst => list: {
103 .OpExtInst => {
72104 if (len < 5) return error.InvalidInstruction;
73 const set = instruction_sets.get(inst[3]) orelse return error.InvalidInstruction;
105 const maybe_set = instruction_sets.get(inst[3]) orelse return error.InvalidInstruction;
106 const set = maybe_set orelse {
107 const prefix = op.operands()[0..4];
108 index = try section.parseOperands(type_widths, offset, end, prefix, index);
109 break :list &.{.{ .kind = .id_ref, .quantifier = .variadic }};
110 };
74111 const prefix = op.operands()[0..4];
75112 index = try section.parseOperands(type_widths, offset, end, prefix, index);
76113 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
93130 const set_name = std.mem.sliceTo(std.mem.sliceAsBytes(inst[2..]), 0);
94131 if (std.meta.stringToEnum(spec.InstructionSet, set_name)) |set| {
95132 if (set != .core) try instruction_sets.put(gpa, inst[1], set);
133 } else if (std.mem.startsWith(u8, set_name, "NonSemantic.")) {
134 try instruction_sets.put(gpa, inst[1], null);
96135 }
97136 },
98137 else => if (op.resultIndex() == 2) {
src/codegen/spirv/spec.zig+248
......@@ -190,6 +190,13 @@ pub const OperandKind = enum {
190190 pair_id_ref_literal_integer,
191191 pair_id_ref_id_ref,
192192 tensor_operands,
193 non_semantic_shader_debug_info_100_debug_info_flags,
194 non_semantic_shader_debug_info_100_build_identifier_flags,
195 non_semantic_shader_debug_info_100_debug_base_type_attribute_encoding,
196 non_semantic_shader_debug_info_100_debug_composite_type,
197 non_semantic_shader_debug_info_100_debug_type_qualifier,
198 non_semantic_shader_debug_info_100_debug_operation,
199 non_semantic_shader_debug_info_100_debug_imported_entity,
193200
194201 pub fn category(operand_kind: OperandKind) OperandCategory {
195202 return switch (operand_kind) {
......@@ -265,6 +272,13 @@ pub const OperandKind = enum {
265272 .pair_id_ref_literal_integer => .composite,
266273 .pair_id_ref_id_ref => .composite,
267274 .tensor_operands => .bit_enum,
275 .non_semantic_shader_debug_info_100_debug_info_flags => .bit_enum,
276 .non_semantic_shader_debug_info_100_build_identifier_flags => .bit_enum,
277 .non_semantic_shader_debug_info_100_debug_base_type_attribute_encoding => .value_enum,
278 .non_semantic_shader_debug_info_100_debug_composite_type => .value_enum,
279 .non_semantic_shader_debug_info_100_debug_type_qualifier => .value_enum,
280 .non_semantic_shader_debug_info_100_debug_operation => .value_enum,
281 .non_semantic_shader_debug_info_100_debug_imported_entity => .value_enum,
268282 };
269283 }
270284 pub fn enumerants(operand_kind: OperandKind) []const Enumerant {
......@@ -1112,6 +1126,67 @@ pub const OperandKind = enum {
11121126 .pair_id_ref_literal_integer => unreachable,
11131127 .pair_id_ref_id_ref => unreachable,
11141128 .tensor_operands => &.{},
1129 .non_semantic_shader_debug_info_100_debug_info_flags => &.{
1130 .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &.{} },
1131 .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &.{} },
1132 .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &.{} },
1133 .{ .name = "FlagIsLocal", .value = 0x04, .parameters = &.{} },
1134 .{ .name = "FlagIsDefinition", .value = 0x08, .parameters = &.{} },
1135 .{ .name = "FlagFwdDecl", .value = 0x10, .parameters = &.{} },
1136 .{ .name = "FlagArtificial", .value = 0x20, .parameters = &.{} },
1137 .{ .name = "FlagExplicit", .value = 0x40, .parameters = &.{} },
1138 .{ .name = "FlagPrototyped", .value = 0x80, .parameters = &.{} },
1139 .{ .name = "FlagObjectPointer", .value = 0x100, .parameters = &.{} },
1140 .{ .name = "FlagStaticMember", .value = 0x200, .parameters = &.{} },
1141 .{ .name = "FlagIndirectVariable", .value = 0x400, .parameters = &.{} },
1142 .{ .name = "FlagLValueReference", .value = 0x800, .parameters = &.{} },
1143 .{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &.{} },
1144 .{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &.{} },
1145 .{ .name = "FlagIsEnumClass", .value = 0x4000, .parameters = &.{} },
1146 .{ .name = "FlagTypePassByValue", .value = 0x8000, .parameters = &.{} },
1147 .{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &.{} },
1148 .{ .name = "FlagUnknownPhysicalLayout", .value = 0x20000, .parameters = &.{} },
1149 },
1150 .non_semantic_shader_debug_info_100_build_identifier_flags => &.{
1151 .{ .name = "IdentifierPossibleDuplicates", .value = 0x01, .parameters = &.{} },
1152 },
1153 .non_semantic_shader_debug_info_100_debug_base_type_attribute_encoding => &.{
1154 .{ .name = "Unspecified", .value = 0, .parameters = &.{} },
1155 .{ .name = "Address", .value = 1, .parameters = &.{} },
1156 .{ .name = "Boolean", .value = 2, .parameters = &.{} },
1157 .{ .name = "Float", .value = 3, .parameters = &.{} },
1158 .{ .name = "Signed", .value = 4, .parameters = &.{} },
1159 .{ .name = "SignedChar", .value = 5, .parameters = &.{} },
1160 .{ .name = "Unsigned", .value = 6, .parameters = &.{} },
1161 .{ .name = "UnsignedChar", .value = 7, .parameters = &.{} },
1162 },
1163 .non_semantic_shader_debug_info_100_debug_composite_type => &.{
1164 .{ .name = "Class", .value = 0, .parameters = &.{} },
1165 .{ .name = "Structure", .value = 1, .parameters = &.{} },
1166 .{ .name = "Union", .value = 2, .parameters = &.{} },
1167 },
1168 .non_semantic_shader_debug_info_100_debug_type_qualifier => &.{
1169 .{ .name = "ConstType", .value = 0, .parameters = &.{} },
1170 .{ .name = "VolatileType", .value = 1, .parameters = &.{} },
1171 .{ .name = "RestrictType", .value = 2, .parameters = &.{} },
1172 .{ .name = "AtomicType", .value = 3, .parameters = &.{} },
1173 },
1174 .non_semantic_shader_debug_info_100_debug_operation => &.{
1175 .{ .name = "Deref", .value = 0, .parameters = &.{} },
1176 .{ .name = "Plus", .value = 1, .parameters = &.{} },
1177 .{ .name = "Minus", .value = 2, .parameters = &.{} },
1178 .{ .name = "PlusUconst", .value = 3, .parameters = &.{.{ .kind = .id_ref }} },
1179 .{ .name = "BitPiece", .value = 4, .parameters = &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } } },
1180 .{ .name = "Swap", .value = 5, .parameters = &.{} },
1181 .{ .name = "Xderef", .value = 6, .parameters = &.{} },
1182 .{ .name = "StackValue", .value = 7, .parameters = &.{} },
1183 .{ .name = "Constu", .value = 8, .parameters = &.{.{ .kind = .id_ref }} },
1184 .{ .name = "Fragment", .value = 9, .parameters = &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } } },
1185 },
1186 .non_semantic_shader_debug_info_100_debug_imported_entity => &.{
1187 .{ .name = "ImportedModule", .value = 0, .parameters = &.{} },
1188 .{ .name = "ImportedDeclaration", .value = 1, .parameters = &.{} },
1189 },
11151190 };
11161191 }
11171192
......@@ -3256,6 +3331,102 @@ pub const GlslOpcode = enum(u16) {
32563331 };
32573332 }
32583333};
3334
3335pub const ShaderDebugInfoOpCode = enum(u16) {
3336 DebugInfoNone = 0,
3337 DebugCompilationUnit = 1,
3338 DebugTypeBasic = 2,
3339 DebugTypePointer = 3,
3340 DebugTypeQualifier = 4,
3341 DebugTypeArray = 5,
3342 DebugTypeVector = 6,
3343 DebugTypedef = 7,
3344 DebugTypeFunction = 8,
3345 DebugTypeEnum = 9,
3346 DebugTypeComposite = 10,
3347 DebugTypeMember = 11,
3348 DebugTypeInheritance = 12,
3349 DebugTypePtrToMember = 13,
3350 DebugTypeTemplate = 14,
3351 DebugTypeTemplateParameter = 15,
3352 DebugTypeTemplateTemplateParameter = 16,
3353 DebugTypeTemplateParameterPack = 17,
3354 DebugGlobalVariable = 18,
3355 DebugFunctionDeclaration = 19,
3356 DebugFunction = 20,
3357 DebugLexicalBlock = 21,
3358 DebugLexicalBlockDiscriminator = 22,
3359 DebugScope = 23,
3360 DebugNoScope = 24,
3361 DebugInlinedAt = 25,
3362 DebugLocalVariable = 26,
3363 DebugInlinedVariable = 27,
3364 DebugDeclare = 28,
3365 DebugValue = 29,
3366 DebugOperation = 30,
3367 DebugExpression = 31,
3368 DebugMacroDef = 32,
3369 DebugMacroUndef = 33,
3370 DebugImportedEntity = 34,
3371 DebugSource = 35,
3372 DebugFunctionDefinition = 101,
3373 DebugSourceContinued = 102,
3374 DebugLine = 103,
3375 DebugNoLine = 104,
3376 DebugBuildIdentifier = 105,
3377 DebugStoragePath = 106,
3378 DebugEntryPoint = 107,
3379 DebugTypeMatrix = 108,
3380
3381 pub fn operands(opcode: ShaderDebugInfoOpCode) []const Operand {
3382 return switch (opcode) {
3383 .DebugInfoNone => &.{},
3384 .DebugCompilationUnit => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3385 .DebugTypeBasic => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3386 .DebugTypePointer => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3387 .DebugTypeQualifier => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3388 .DebugTypeArray => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3389 .DebugTypeVector => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3390 .DebugTypedef => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3391 .DebugTypeFunction => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3392 .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 } },
3393 .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 } },
3394 .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 } },
3395 .DebugTypeInheritance => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3396 .DebugTypePtrToMember => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3397 .DebugTypeTemplate => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3398 .DebugTypeTemplateParameter => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3399 .DebugTypeTemplateTemplateParameter => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3400 .DebugTypeTemplateParameterPack => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3401 .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 } },
3402 .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 } },
3403 .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 } },
3404 .DebugLexicalBlock => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
3405 .DebugLexicalBlockDiscriminator => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3406 .DebugScope => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
3407 .DebugNoScope => &.{},
3408 .DebugInlinedAt => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
3409 .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 } },
3410 .DebugInlinedVariable => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3411 .DebugDeclare => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3412 .DebugValue => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3413 .DebugOperation => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .variadic } },
3414 .DebugExpression => &.{.{ .kind = .id_ref, .quantifier = .variadic }},
3415 .DebugMacroDef => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
3416 .DebugMacroUndef => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3417 .DebugImportedEntity => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3418 .DebugSource => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref, .quantifier = .optional } },
3419 .DebugFunctionDefinition => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3420 .DebugSourceContinued => &.{.{ .kind = .id_ref }},
3421 .DebugLine => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3422 .DebugNoLine => &.{},
3423 .DebugBuildIdentifier => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3424 .DebugStoragePath => &.{.{ .kind = .id_ref }},
3425 .DebugEntryPoint => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3426 .DebugTypeMatrix => &.{ .{ .kind = .id_ref }, .{ .kind = .id_ref }, .{ .kind = .id_ref } },
3427 };
3428 }
3429};
32593430pub const ImageOperands = packed struct(Word) {
32603431 bias: bool = false,
32613432 lod: bool = false,
......@@ -4460,16 +4631,93 @@ pub const ComponentType = enum(u32) {
44604631pub const TensorOperands = packed struct(Word) {
44614632 _reserved_bits_0_to_31: u32 = 0,
44624633};
4634pub const @"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" = packed struct(Word) {
4635 flag_is_protected: bool = false,
4636 flag_is_private: bool = false,
4637 flag_is_local: bool = false,
4638 flag_is_definition: bool = false,
4639 flag_fwd_decl: bool = false,
4640 flag_artificial: bool = false,
4641 flag_explicit: bool = false,
4642 flag_prototyped: bool = false,
4643 flag_object_pointer: bool = false,
4644 flag_static_member: bool = false,
4645 flag_indirect_variable: bool = false,
4646 flag_l_value_reference: bool = false,
4647 flag_r_value_reference: bool = false,
4648 flag_is_optimized: bool = false,
4649 flag_is_enum_class: bool = false,
4650 flag_type_pass_by_value: bool = false,
4651 flag_type_pass_by_reference: bool = false,
4652 flag_unknown_physical_layout: bool = false,
4653 _reserved_bits_18_to_31: u14 = 0,
4654};
4655pub const @"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" = packed struct(Word) {
4656 identifier_possible_duplicates: bool = false,
4657 _reserved_bits_1_to_31: u31 = 0,
4658};
4659pub const @"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) {
4660 unspecified = 0,
4661 address = 1,
4662 boolean = 2,
4663 float = 3,
4664 signed = 4,
4665 signed_char = 5,
4666 unsigned = 6,
4667 unsigned_char = 7,
4668};
4669pub const @"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" = enum(u32) {
4670 class = 0,
4671 structure = 1,
4672 @"union" = 2,
4673};
4674pub const @"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" = enum(u32) {
4675 const_type = 0,
4676 volatile_type = 1,
4677 restrict_type = 2,
4678 atomic_type = 3,
4679};
4680pub const @"NonSemantic.Shader.DebugInfo.100.DebugOperation" = enum(u32) {
4681 deref = 0,
4682 plus = 1,
4683 minus = 2,
4684 plus_uconst = 3,
4685 bit_piece = 4,
4686 swap = 5,
4687 xderef = 6,
4688 stack_value = 7,
4689 constu = 8,
4690 fragment = 9,
4691
4692 pub const Extended = union(@"NonSemantic.Shader.DebugInfo.100.DebugOperation") {
4693 deref,
4694 plus,
4695 minus,
4696 plus_uconst: struct { id_ref: Id },
4697 bit_piece: struct { id_ref_0: Id, id_ref_1: Id },
4698 swap,
4699 xderef,
4700 stack_value,
4701 constu: struct { id_ref: Id },
4702 fragment: struct { id_ref_0: Id, id_ref_1: Id },
4703 };
4704};
4705pub const @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" = enum(u32) {
4706 imported_module = 0,
4707 imported_declaration = 1,
4708};
44634709pub const InstructionSet = enum {
44644710 core,
44654711 @"OpenCL.std",
44664712 @"GLSL.std.450",
4713 @"NonSemantic.Shader.DebugInfo.100",
44674714
44684715 pub fn operands(inst_set: InstructionSet, opcode: Word) ?[]const Operand {
44694716 return switch (inst_set) {
44704717 .core => if (std.enums.fromInt(Opcode, opcode)) |op| op.operands() else null,
44714718 .@"OpenCL.std" => if (std.enums.fromInt(OpenClOpcode, opcode)) |op| op.operands() else null,
44724719 .@"GLSL.std.450" => if (std.enums.fromInt(GlslOpcode, opcode)) |op| op.operands() else null,
4720 .@"NonSemantic.Shader.DebugInfo.100" => if (std.enums.fromInt(ShaderDebugInfoOpCode, opcode)) |op| op.operands() else null,
44734721 };
44744722 }
44754723};
src/link/Elf/ZigObject.zig+1-1
......@@ -224,7 +224,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
224224 try dwarf.initMetadata();
225225 self.dwarf = dwarf;
226226 },
227 .code_view => unreachable,
227 .code_view, .nsdi => unreachable,
228228 }
229229}
230230
src/link/Elf2.zig+8-8
......@@ -5146,7 +5146,7 @@ fn create(
51465146 .dwarf = .init(&elf.base, switch (comp.config.debug_format) {
51475147 .strip => .@"32", // for .eh_frame
51485148 .dwarf => |v| v,
5149 .code_view => unreachable,
5149 .code_view, .nsdi => unreachable,
51505150 }),
51515151 .dwarf_shared = comptime .initFill(.{
51525152 .first_target_reloc = .none,
......@@ -5261,7 +5261,7 @@ fn initHeaders(
52615261 const have_debug_frame = machine == .X86_64 and switch (comp.config.debug_format) {
52625262 .strip => false,
52635263 .dwarf => !comp.config.any_unwind_tables,
5264 .code_view => unreachable,
5264 .code_view, .nsdi => unreachable,
52655265 };
52665266 const addr_align: Alignment = switch (class) {
52675267 .NONE, _ => unreachable,
......@@ -5322,7 +5322,7 @@ fn initHeaders(
53225322 shnum += 1; // .debug_str
53235323 shnum += 1; // .debug_str_offsets
53245324 },
5325 .code_view => unreachable,
5325 .code_view, .nsdi => unreachable,
53265326 }
53275327 if (@"type" != .REL) {
53285328 shnum += 1; // .got
......@@ -6548,7 +6548,7 @@ fn initHeaders(
65486548 .node_align = elf.mf.flags.block_size,
65496549 });
65506550 },
6551 .code_view => unreachable,
6551 .code_view, .nsdi => unreachable,
65526552 }
65536553
65546554 // If we have an entry point symbol, create the undefined reference now.
......@@ -10400,7 +10400,7 @@ fn updateContainerTypeInner(
1040010400 try elf.dwarf.const_pool.updateContainerType(pt, .{ .elf2 = elf }, ty, success);
1040110401 try elf.dwarf.const_pool.flushPending(pt, .{ .elf2 = elf });
1040210402 },
10403 .code_view => unreachable,
10403 .code_view, .nsdi => unreachable,
1040410404 }
1040510405 if (!success) return;
1040610406 var lazy_it = elf.lazy.iterator();
......@@ -10426,7 +10426,7 @@ pub fn addConst(
1042610426 try elf.dwarf_consts.ensureUnusedCapacity(gpa, 1);
1042710427 try elf.dwarf.addConst(cpi, val, &addConstNode);
1042810428 },
10429 .code_view => unreachable,
10429 .code_view, .nsdi => unreachable,
1043010430 }
1043110431}
1043210432fn addConstNode(
......@@ -10502,7 +10502,7 @@ fn updateConstInner(
1050210502 }
1050310503 try elf.genPending(pt);
1050410504 },
10505 .code_view => unreachable,
10505 .code_view, .nsdi => unreachable,
1050610506 }
1050710507}
1050810508
......@@ -11259,7 +11259,7 @@ fn genPending(elf: *Elf, pt: Zcu.PerThread) link.Error!void {
1125911259 elf.resetNodeRelocs(debug_info_ni);
1126011260 try elf.dwarf.genDecl(pt, &di_nw, pending.instance);
1126111261 },
11262 .code_view => unreachable,
11262 .code_view, .nsdi => unreachable,
1126311263 }
1126411264 try elf.genPendingDebug(gpa);
1126511265 assert(elf.pending_uavs.items.len == 0); // no UAVs added by lazy code/data or by debug info
src/link/MachO/ZigObject.zig+1-1
......@@ -62,7 +62,7 @@ pub fn init(self: *ZigObject, macho_file: *MachO) !void {
6262 self.debug_info_header_dirty = true;
6363 self.debug_line_header_dirty = true;
6464 },
65 .code_view => unreachable,
65 .code_view, .nsdi => unreachable,
6666 }
6767}
6868
src/link/Spirv.zig+2-1
......@@ -218,11 +218,12 @@ pub fn flush(
218218 .linker = linker,
219219 .arena = arena,
220220 .id_bound = 1,
221 .nonsemantic_info = false,
221222 .navs = .empty,
222223 .symbols = .empty,
223224 .interned = .empty,
224225 .variables = .empty,
225 .function_references = .empty,
226 .fn_refs = .empty,
226227 .entry_points = .empty,
227228 .deps = .empty,
228229 .scratch = .empty,
src/link/Spirv/Flush.zig+141-100
......@@ -2,6 +2,7 @@ const std = @import("std");
22const Allocator = std.mem.Allocator;
33const Path = std.Build.Cache.Path;
44const assert = std.debug.assert;
5const stringToEnum = std.meta.stringToEnum;
56const InternPool = @import("../../InternPool.zig");
67const link = @import("../../link.zig");
78const Type = @import("../../Type.zig");
......@@ -17,11 +18,12 @@ const Flush = @This();
1718linker: *Linker,
1819arena: Allocator,
1920id_bound: Word,
21nonsemantic_info: bool,
2022navs: std.array_hash_map.Auto(InternPool.Nav.Index, Id),
2123symbols: std.array_hash_map.String(Symbol),
2224interned: std.array_hash_map.String(Id),
2325variables: std.array_hash_map.Auto(Id, spec.StorageClass),
24function_references: std.array_hash_map.Auto(Id, []const Id),
26fn_refs: std.array_hash_map.Auto(Id, []const Id),
2527entry_points: std.ArrayList(Mir.EntryPoint),
2628deps: std.ArrayList(Id),
2729scratch: Section,
......@@ -42,7 +44,7 @@ const Symbol = struct {
4244};
4345
4446const Annotation = struct {
45 target: Word,
47 target_id: Word,
4648 class: spec.Class,
4749 start: usize,
4850 end: usize,
......@@ -193,7 +195,6 @@ pub fn emitModule(flush: *Flush, out: *Section) link.Error!void {
193195 }) |feature| {
194196 if (target.cpu.has(.spirv, feature)) version.minor += 1;
195197 }
196
197198 const zig_packed_version = (zig_version.major << 12) | (zig_version.minor << 7) | zig_version.patch;
198199 const header: spec.Header = .{
199200 .magic = spec.magic_number,
......@@ -202,6 +203,7 @@ pub fn emitModule(flush: *Flush, out: *Section) link.Error!void {
202203 .id_bound = flush.id_bound,
203204 .schema = 0,
204205 };
206
205207 try out.writeWords(gpa, @ptrCast(@alignCast(&header)));
206208 try flush.emitCapabilities(out);
207209 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 {
224226 const gpa = comp.gpa;
225227 const arena = flush.arena;
226228 const diags = &comp.link_diags;
227
229 const target = &comp.root_mod.resolved_target.result;
228230 const ids = try gpa.alloc(Id, mir.id_bound);
229231 defer gpa.free(ids);
230232 ids[0] = .none;
......@@ -255,25 +257,22 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
255257 try imports.put(gpa, @backingInt(ext.id), @intCast(gop.index));
256258 }
257259
258 const words = mir.module.instructions.items;
259 var offset: usize = 0;
260 while (offset < words.len) {
261 const start = offset;
262 const header: spec.InstructionHeader = @bitCast(words[start]);
263 const inst = words[start..][0..header.word_count];
264 offset += inst.len;
265
266 if (header.opcode == .OpDecorate) {
267 const target = inst[1];
268 const decoration: spec.Decoration = @fromBackingInt(inst[2]);
260 var it = mir.module.iterate();
261 while (it.next()) |inst| {
262 const opcode = inst.opcode;
263 const words = inst.words;
264
265 if (opcode == .OpDecorate) {
266 const target_id = words[1];
267 const decoration: spec.Decoration = @fromBackingInt(words[2]);
269268 if (decoration == .linkage_attributes) {
270 const parameters = inst[3..];
269 const parameters = words[3..];
271270 const name_words = parameters[0 .. parameters.len - 1];
272271 const name = std.mem.sliceTo(std.mem.sliceAsBytes(name_words), 0);
273272 const linkage: spec.LinkageType = @fromBackingInt(parameters[parameters.len - 1]);
274273 const gop = try flush.symbols.getOrPut(arena, name);
275274 if (!gop.found_existing) gop.value_ptr.* = .{
276 .id = ids[target],
275 .id = ids[target_id],
277276 .defined = false,
278277 .declaration = &.{},
279278 };
......@@ -285,130 +284,171 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
285284 }
286285 gop.value_ptr.defined = true;
287286 },
288 .import => try imports.put(gpa, target, @intCast(gop.index)),
287 .import => try imports.put(gpa, target_id, @intCast(gop.index)),
289288 .link_once_odr => {
290289 return diags.failParse(path.?, "unsupported linkage '{t}'", .{linkage});
291290 },
292291 }
293292
294 ids[target] = gop.value_ptr.id;
293 ids[target_id] = gop.value_ptr.id;
295294 continue;
296295 }
297296 }
298297
299 const class = header.opcode.class();
300 const target: Word = switch (header.opcode) {
301 .OpName, .OpMemberName => inst[1],
298 const class = opcode.class();
299 const target_id: Word = switch (opcode) {
300 .OpName, .OpMemberName => words[1],
302301 .OpDecorationGroup, .OpGroupDecorate, .OpGroupMemberDecorate => {
303302 return diags.failParse(path.?, "decoration groups are not supported", .{});
304303 },
305 else => if (class == .annotation) inst[1] else continue,
304 else => if (class == .annotation) words[1] else continue,
306305 };
307306 try annotations.append(gpa, .{
308 .target = target,
307 .target_id = target_id,
309308 .class = class,
310 .start = start,
311 .end = offset,
309 .start = inst.start,
310 .end = inst.end,
312311 });
313312 }
314313
314 var result_ids: std.ArrayList(Word) = .empty;
315 defer result_ids.deinit(gpa);
316
315317 const starts = try gpa.alloc(u32, mir.id_bound + 1);
316318 defer gpa.free(starts);
317319 @memset(starts, 0);
318320
319 for (annotations.items) |annotation| starts[annotation.target + 1] += 1;
321 for (annotations.items) |annotation| starts[annotation.target_id + 1] += 1;
320322 for (1..starts.len) |i| starts[i] += starts[i - 1];
321323
322 const cursors = try gpa.dupe(u32, starts);
323 defer gpa.free(cursors);
324 const by_target = try gpa.alloc(u32, annotations.items.len);
325 defer gpa.free(by_target);
326 for (annotations.items, 0..) |annotation, i| {
327 by_target[cursors[annotation.target]] = @intCast(i);
328 cursors[annotation.target] += 1;
324 const grouped_indices = try gpa.alloc(u32, annotations.items.len);
325 defer gpa.free(grouped_indices);
326 {
327 const next_slot = try gpa.dupe(u32, starts);
328 defer gpa.free(next_slot);
329 for (annotations.items, 0..) |annotation, i| {
330 grouped_indices[next_slot[annotation.target_id]] = @intCast(i);
331 next_slot[annotation.target_id] += 1;
332 }
329333 }
330334
331 var results: std.ArrayList(Word) = .empty;
332 defer results.deinit(gpa);
333
334 offset = 0;
335 while (offset < words.len) {
336 const start = offset;
337 const header: spec.InstructionHeader = @bitCast(words[start]);
338 const inst = words[start..][0..header.word_count];
339 offset += inst.len;
335 it = mir.module.iterate();
336 while (it.next()) |inst| {
337 const start = inst.start;
338 var end = inst.end;
339 const opcode = inst.opcode;
340 const words = inst.words;
340341 input.mark += 1;
341342 flush.deps.clearRetainingCapacity();
342343
343 const result_index = header.opcode.resultIndex() orelse {
344 switch (header.opcode) {
345 .OpEntryPoint => {
346 try input.copy(flush, &flush.object_entry_points, start, offset, null);
347 },
348 .OpExecutionMode, .OpExecutionModeId => {
349 try input.copy(flush, &flush.object_execution_modes, start, offset, null);
350 },
351 .OpTypeForwardPointer => {
352 forward_pointers.set(inst[1]);
353 try input.copy(flush, &flush.globals, start, offset, null);
354 },
355 else => {},
356 }
357 continue;
344 const result_index = opcode.resultIndex() orelse switch (opcode) {
345 .OpCapability => {
346 const capability = std.enums.fromInt(spec.Capability, words[1]) orelse {
347 return diags.failParse(path.?, "unknown capability '{d}'", .{words[1]});
348 };
349
350 // TODO: this isn't a full validation. we probably have to automate this
351 // based on some generated info from SPIRV-Headers/SPIRV-Registry
352 const allowed = switch (capability) {
353 .linkage => true,
354 .shader => target.os.tag == .vulkan or target.os.tag == .opengl,
355 .kernel, .addresses => target.os.tag == .opencl,
356 .physical_storage_buffer_addresses => target.os.tag == .vulkan and target.cpu.arch == .spirv64,
357 else => if (stringToEnum(std.Target.spirv.Feature, @tagName(capability))) |f| target.cpu.has(.spirv, f) else false,
358 };
359 if (!allowed) return diags.failParse(
360 path.?,
361 "SPIR-V capability '{t}' is not enabled by the target feature set",
362 .{capability},
363 );
364 continue;
365 },
366 .OpExtension => {
367 const name = std.mem.sliceTo(std.mem.sliceAsBytes(words[1..]), 0);
368 if (std.mem.eql(u8, name, "SPV_KHR_non_semantic_info")) {
369 flush.nonsemantic_info = true;
370 continue;
371 }
372
373 const allowed = allowed: {
374 if (stringToEnum(std.Target.spirv.Feature, name)) |f| {
375 break :allowed target.cpu.has(.spirv, f);
376 }
377 break :allowed true;
378 };
379 if (!allowed) return diags.failParse(
380 path.?,
381 "SPIR-V extension '{s}' is not enabled by the target feature set",
382 .{name},
383 );
384 continue;
385 },
386 .OpEntryPoint => {
387 try input.copy(flush, &flush.object_entry_points, start, end, null);
388 continue;
389 },
390 .OpExecutionMode, .OpExecutionModeId => {
391 try input.copy(flush, &flush.object_execution_modes, start, end, null);
392 continue;
393 },
394 .OpTypeForwardPointer => {
395 forward_pointers.set(words[1]);
396 try input.copy(flush, &flush.globals, start, end, null);
397 continue;
398 },
399 else => continue,
358400 };
359 const result = inst[result_index];
360 results.clearRetainingCapacity();
361 try results.append(gpa, result);
401
402 const result_id = words[result_index];
403 result_ids.clearRetainingCapacity();
404 try result_ids.append(gpa, result_id);
362405
363406 var has_body = false;
364 if (header.opcode == .OpFunction) {
365 while (true) {
366 const body: spec.InstructionHeader = @bitCast(words[offset]);
407 if (opcode == .OpFunction) {
408 while (it.next()) |body| {
409 end = body.end;
367410 if (body.opcode == .OpLabel) has_body = true;
368 if (body.opcode.resultIndex()) |index| {
369 try results.append(gpa, words[offset + index]);
370 }
371 offset += body.word_count;
411 if (body.result_id != .none) try result_ids.append(gpa, @backingInt(body.result_id));
372412 if (body.opcode == .OpFunctionEnd) break;
373413 }
374414 }
375415
376 for (results.items) |own| input.marks[own] = input.mark;
416 for (result_ids.items) |own| input.marks[own] = input.mark;
377417
378 if (imports.get(result)) |symbol_index| {
418 if (imports.get(result_id)) |symbol_index| {
379419 flush.scratch.reset();
380 try input.copy(flush, &flush.scratch, start, offset, null);
420 try input.copy(flush, &flush.scratch, start, end, null);
381421 const declaration = try arena.dupe(Word, flush.scratch.instructions.items);
382422 flush.symbols.values()[symbol_index].declaration = declaration;
383423 continue;
384424 }
385425
386 switch (header.opcode) {
426 switch (opcode) {
387427 .OpFunction => if (!has_body) return diags.failParse(path.?, "function declaration without linkage", .{}),
388 .OpVariable => try flush.variables.put(arena, ids[result], @fromBackingInt(inst[3])),
389 else => if (!forward_pointers.isSet(result)) {
428 .OpVariable => try flush.variables.put(arena, ids[result_id], @fromBackingInt(words[3])),
429 else => if (!forward_pointers.isSet(result_id)) {
390430 flush.scratch.reset();
391 try input.copy(flush, &flush.scratch, start, offset, start + result_index);
392 for (by_target[starts[result]..starts[result + 1]]) |index| {
431 try input.copy(flush, &flush.scratch, start, end, start + result_index);
432 for (grouped_indices[starts[result_id]..starts[result_id + 1]]) |index| {
393433 const annotation = annotations.items[index];
394434 if (annotation.class != .annotation) continue;
395 const target = annotation.start + 1;
396 try input.copy(flush, &flush.scratch, annotation.start, annotation.end, target);
435 const target_id = annotation.start + 1;
436 try input.copy(flush, &flush.scratch, annotation.start, annotation.end, target_id);
397437 }
398438
399439 const key = std.mem.sliceAsBytes(flush.scratch.instructions.items);
400440 const gop = try flush.interned.getOrPut(arena, key);
401441 if (gop.found_existing) {
402 ids[result] = gop.value_ptr.*;
442 ids[result_id] = gop.value_ptr.*;
403443 continue;
404444 }
405445 gop.key_ptr.* = try arena.dupe(u8, key);
406 gop.value_ptr.* = ids[result];
446 gop.value_ptr.* = ids[result_id];
407447 },
408448 }
409449
410 for (results.items) |target| {
411 for (by_target[starts[target]..starts[target + 1]]) |index| {
450 for (result_ids.items) |target_id| {
451 for (grouped_indices[starts[target_id]..starts[target_id + 1]]) |index| {
412452 const annotation = annotations.items[index];
413453 const section = switch (annotation.class) {
414454 .debug => &flush.names,
......@@ -419,16 +459,16 @@ fn load(flush: *Flush, mir: *const Mir, path: ?Path) link.Error!void {
419459 }
420460 }
421461
422 const section = switch (header.opcode) {
462 const section = switch (opcode) {
423463 .OpFunction => &flush.functions,
424464 .OpExtInstImport => &flush.extended_instruction_sets,
425465 .OpString => &flush.debug_strings,
426466 else => &flush.globals,
427467 };
428 try input.copy(flush, section, start, offset, null);
429 if (header.opcode == .OpFunction) {
468 try input.copy(flush, section, start, end, null);
469 if (opcode == .OpFunction) {
430470 const references = try arena.dupe(Id, flush.deps.items);
431 try flush.function_references.put(arena, ids[result], references);
471 try flush.fn_refs.put(arena, ids[result_id], references);
432472 }
433473 }
434474
......@@ -468,25 +508,26 @@ fn emitCapabilities(flush: *Flush, out: *Section) link.Error!void {
468508 try out.emit(gpa, .OpCapability, .{ .capability = .linkage });
469509 }
470510
471 inline for (@typeInfo(spec.Capability).@"enum".field_names) |name| {
472 if (@hasField(std.Target.spirv.Feature, name)) {
473 const feature = @field(std.Target.spirv.Feature, name);
474 if (target.cpu.has(.spirv, feature)) {
475 try out.emit(gpa, .OpCapability, .{ .capability = @field(spec.Capability, name) });
476 }
477 }
511 for (std.enums.values(spec.Capability)) |capability| {
512 const feature = stringToEnum(std.Target.spirv.Feature, @tagName(capability)) orelse continue;
513 if (!target.cpu.has(.spirv, feature)) continue;
514 try out.emit(gpa, .OpCapability, .{ .capability = capability });
478515 }
479516
480517 if (target.cpu.arch == .spirv64 and target.os.tag == .vulkan) {
481518 try out.emit(gpa, .OpExtension, .{ .name = "SPV_KHR_physical_storage_buffer" });
482519 }
483520
484 inline for (@typeInfo(spec.Extension).@"enum".field_names) |name| {
485 if (comptime std.mem.startsWith(u8, name, "v1_")) continue;
486 if (@hasField(std.Target.spirv.Feature, name)) {
487 const feature = @field(std.Target.spirv.Feature, name);
488 if (target.cpu.has(.spirv, feature)) try out.emit(gpa, .OpExtension, .{ .name = name });
489 }
521 for (std.enums.values(spec.Extension)) |extension| {
522 const name = @tagName(extension);
523 if (std.mem.startsWith(u8, name, "v1_")) continue;
524 const feature = stringToEnum(std.Target.spirv.Feature, name) orelse continue;
525 if (!target.cpu.has(.spirv, feature)) continue;
526 try out.emit(gpa, .OpExtension, .{ .name = name });
527 }
528
529 if (flush.nonsemantic_info) {
530 try out.emit(gpa, .OpExtension, .{ .name = "SPV_KHR_non_semantic_info" });
490531 }
491532}
492533
......@@ -547,7 +588,7 @@ fn emitEntryPoints(flush: *Flush, out: *Section) link.Error!void {
547588 if (storage_class == .function) continue;
548589 if (!v1_4 and storage_class != .input and storage_class != .output) continue;
549590 try interface.append(arena, id);
550 } else if (flush.function_references.get(id)) |references| {
591 } else if (flush.fn_refs.get(id)) |references| {
551592 try pending.appendSlice(arena, references);
552593 }
553594 }
src/main.zig+29
......@@ -3582,6 +3582,35 @@ fn buildOutputType(
35823582 @import("codegen/llvm/bindings.zig").ParseCommandLineOptions(argv.len, &argv);
35833583 }
35843584
3585 if (build_options.have_llvm and create_module.resolved_options.use_llvm and target.cpu.arch.isSpirv()) {
3586 // LLVM has no way to set this non-globally other
3587 // than SPIRVTranslate() but it cannot emits assembly.
3588 var extensions: std.ArrayList(u8) = .empty;
3589 defer extensions.deinit(gpa);
3590 try extensions.appendSlice(gpa, "--spirv-ext=");
3591
3592 var has_extension = false;
3593 if (!root_mod.strip) {
3594 try extensions.appendSlice(gpa, "+SPV_KHR_non_semantic_info");
3595 has_extension = true;
3596 }
3597
3598 for (std.enums.values(std.Target.spirv.Feature)) |feature| {
3599 const name = @tagName(feature);
3600 if (!mem.startsWith(u8, name, "SPV_")) continue;
3601 if (!target.cpu.has(.spirv, feature)) continue;
3602 if (mem.eql(u8, name, "SPV_KHR_variable_pointers") and target.cpu.has(.spirv, .v1_3)) continue;
3603
3604 if (has_extension) try extensions.append(gpa, ',');
3605 try extensions.append(gpa, '+');
3606 try extensions.appendSlice(gpa, name);
3607 has_extension = true;
3608 }
3609
3610 const argv = [_][*:0]const u8{ "zig (LLVM option parsing)", try extensions.toOwnedSliceSentinel(gpa, 0) };
3611 @import("codegen/llvm/bindings.zig").ParseCommandLineOptions(argv.len, &argv);
3612 }
3613
35853614 const clang_passthrough_mode = switch (arg_mode) {
35863615 .cc, .cpp, .translate_c => true,
35873616 else => false,
src/target.zig+23-33
......@@ -310,7 +310,7 @@ pub fn hasNewLinker(ofmt: std.Target.ObjectFormat) bool {
310310/// than or equal to the number of behavior tests as the respective LLVM backend.
311311pub fn selfHostedBackendIsAsRobustAsLlvm(target: *const std.Target) bool {
312312 if (comptime builtin.cpu.arch.endian() == .big) return false; // https://github.com/ziglang/zig/issues/25961
313 if (target.cpu.arch.isSpirV()) return true;
313 if (target.cpu.arch.isSpirv()) return true;
314314 if (target.cpu.arch == .x86_64 and target.ptrBitWidth() == 64) {
315315 if (target.os.tag == .illumos) {
316316 // https://github.com/ziglang/zig/issues/25699
......@@ -635,38 +635,28 @@ pub fn addrSpaceCastIsValid(
635635 }
636636}
637637
638/// Returns whether pointer operations (arithmetic, indexing, etc.) should be blocked
639/// for the given address space on the target architecture.
640///
641/// Under SPIR-V with Vulkan
642/// (a) all physical pointers (.physical_storage_buffer, .global) always support pointer operations,
643/// (b) by default logical pointers (.constant, .input, .output, etc.) never support operations
644/// (c) some logical pointers (.storage_buffer, .shared) do support operations when
645/// the VariablePointers capability is enabled (which enables OpPtrAccessChain).
646pub fn shouldBlockPointerOps(target: *const std.Target, as: AddressSpace) bool {
647 if (target.os.tag != .vulkan and target.os.tag != .opengl) return false;
648
649 return switch (as) {
650 // TODO: Vulkan doesn't support pointers in the generic address space, we
651 // should remove this case but this requires a change in defaultAddressSpace().
652 .generic => true,
653 // For now, all global pointers are represented using StorageBuffer or CrossWorkgroup,
654 // so these are real pointers.
655 // Physical pointers always support operations
656 .global, .physical_storage_buffer => false,
657 // Logical pointers that support operations with VariablePointers capability
658 .shared => !target.cpu.features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)),
659 .storage_buffer => !target.cpu.features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)),
660 // Logical pointers that never support operations
661 .constant,
662 .local,
663 .private,
664 .input,
665 .output,
666 .uniform,
667 .push_constant,
668 => true,
669 else => unreachable,
638/// Returns true if the given address space memory model is logical (i.e. arithmetic pointer
639/// operations are illegal).
640pub fn addrSpaceIsLogical(target: *const std.Target, as: AddressSpace) bool {
641 const features = &target.cpu.features;
642 return switch (target.os.tag) {
643 .vulkan, .opengl => switch (as) {
644 .generic,
645 .constant,
646 .local,
647 .private,
648 .input,
649 .output,
650 .uniform,
651 .push_constant,
652 => true,
653 .shared => !features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)),
654 .storage_buffer => !features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)) and
655 !features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers_storage_buffer)),
656 .physical_storage_buffer => false,
657 else => unreachable,
658 },
659 else => false,
670660 };
671661}
672662
test/behavior.zig+5-5
......@@ -115,21 +115,21 @@ test {
115115 _ = @import("behavior/wasm.zig");
116116 }
117117
118 if (builtin.zig_backend == .stage2_spirv) {
118 if (builtin.cpu.arch.isSpirv()) {
119119 _ = @import("behavior/spirv.zig");
120120 }
121121
122 if (builtin.zig_backend != .stage2_spirv and builtin.os.tag != .wasi) {
122 if (!builtin.cpu.arch.isSpirv() and builtin.os.tag != .wasi) {
123123 _ = @import("behavior/asm.zig");
124124 }
125125
126126 if (builtin.zig_backend != .stage2_arm and
127 builtin.zig_backend != .stage2_spirv)
127 !builtin.cpu.arch.isSpirv())
128128 {
129129 _ = @import("behavior/export_keyword.zig");
130130 }
131131
132 if (builtin.zig_backend != .stage2_spirv and !builtin.cpu.arch.isWasm()) {
132 if (!builtin.cpu.arch.isSpirv() and !builtin.cpu.arch.isWasm()) {
133133 // Due to lack of import/export of global support
134134 // (https://github.com/ziglang/zig/issues/4866), these tests correctly
135135 // cause linker errors, since a data symbol cannot be exported when
......@@ -143,7 +143,7 @@ test {
143143// This bug only repros in the root file
144144test "dereference @embedFile() of a file full of zero bytes" {
145145 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
146 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
147147
148148 const contents = @embedFile("behavior/zero.bin").*;
149149 try @import("std").testing.expect(contents.len == 456);
test/behavior/abs.zig+13-7
......@@ -4,6 +4,7 @@ const assert = std.debug.assert;
44const expect = std.testing.expect;
55
66test "@abs integers" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -49,6 +50,7 @@ fn testAbsIntegers() !void {
4950}
5051
5152test "@abs signed C ABI integers" {
53 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
5254 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
5355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5456 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -60,7 +62,7 @@ test "@abs signed C ABI integers" {
6062 try testOne(c_short, c_ushort);
6163 try testOne(c_int, c_uint);
6264 try testOne(c_long, c_ulong);
63 if (!builtin.cpu.arch.isSpirV()) try testOne(c_longlong, c_ulonglong);
65 if (!builtin.cpu.arch.isSpirv()) try testOne(c_longlong, c_ulonglong);
6466 }
6567 fn testOne(comptime Signed: type, comptime Unsigned: type) !void {
6668 var negative_one: Signed = undefined;
......@@ -76,6 +78,7 @@ test "@abs signed C ABI integers" {
7678}
7779
7880test "@abs unsigned integers" {
81 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7982 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8083 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8184
......@@ -115,6 +118,7 @@ fn testAbsUnsignedIntegers() !void {
115118}
116119
117120test "@abs unsigned C ABI integers" {
121 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
118122 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
119123 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
120124 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -125,7 +129,7 @@ test "@abs unsigned C ABI integers" {
125129 try testOne(c_ushort);
126130 try testOne(c_uint);
127131 try testOne(c_ulong);
128 if (!builtin.cpu.arch.isSpirV()) try testOne(c_ulonglong);
132 if (!builtin.cpu.arch.isSpirv()) try testOne(c_ulonglong);
129133 }
130134 fn testOne(comptime Unsigned: type) !void {
131135 var one: Unsigned = undefined;
......@@ -141,6 +145,7 @@ test "@abs unsigned C ABI integers" {
141145}
142146
143147test "@abs big int <= 128 bits" {
148 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
144149 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
145150 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146151 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
......@@ -203,6 +208,7 @@ fn testAbsUnsignedBigInt() !void {
203208test "@abs floats" {
204209 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
205210 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
211 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
206212
207213 try comptime testAbsFloats(f16);
208214 if (builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f16);
......@@ -211,9 +217,9 @@ test "@abs floats" {
211217 try comptime testAbsFloats(f64);
212218 try testAbsFloats(f64);
213219 try comptime testAbsFloats(f80);
214 if (builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
220 if (!builtin.cpu.arch.isSpirv() and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
215221 try comptime testAbsFloats(f128);
216 if (builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
222 if (!builtin.cpu.arch.isSpirv() and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
217223}
218224
219225fn testAbsFloats(comptime T: type) !void {
......@@ -258,7 +264,7 @@ test "@abs int vectors" {
258264 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
259265 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260266 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
261 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
267 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
262268
263269 try comptime testAbsIntVectors(1);
264270 try testAbsIntVectors(1);
......@@ -324,7 +330,7 @@ test "@abs unsigned int vectors" {
324330 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
325331 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
326332 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
327 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
333 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
328334
329335 try comptime testAbsUnsignedIntVectors(1);
330336 try testAbsUnsignedIntVectors(1);
......@@ -381,7 +387,7 @@ test "@abs float vectors" {
381387 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
382388 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
383389 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
384 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
390 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
385391 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
386392
387393 @setEvalBranchQuota(2000);
test/behavior/addrspace_and_linksection.zig+3-3
......@@ -12,7 +12,7 @@ const var_linksection = linksections.?[1];
1212const fn_linksection = linksections.?[2];
1313
1414test "addrspace on container-level const" {
15 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
15 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1616
1717 const S = struct {
1818 const a: u32 addrspace(.generic) = 123;
......@@ -49,7 +49,7 @@ test "addrspace and linksection on container-level const" {
4949}
5050
5151test "addrspace on container-level var" {
52 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
52 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5353
5454 const S = struct {
5555 var a: u32 addrspace(.generic) = 123;
......@@ -83,7 +83,7 @@ test "addrspace and linksection on container-level var" {
8383}
8484
8585test "addrspace on fn" {
86 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
86 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8787
8888 const S = struct {
8989 fn f() addrspace(.generic) u32 {
test/behavior/align.zig+27-23
......@@ -7,7 +7,7 @@ const assert = std.debug.assert;
77var foo: u8 align(4) = 100;
88
99test "global variable alignment" {
10 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1111
1212 comptime assert(@typeInfo(@TypeOf(&foo)).pointer.attrs.@"align" == 4);
1313 comptime assert(@TypeOf(&foo) == *align(4) u8);
......@@ -18,7 +18,7 @@ test "global variable alignment" {
1818}
1919
2020test "large abi alignment of global" {
21 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2222
2323 const S = struct {
2424 var global: @This() = undefined;
......@@ -30,7 +30,7 @@ test "large abi alignment of global" {
3030
3131test "large alignment of local constant" {
3232 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
33 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
33 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
3434 if (builtin.zig_backend == .stage2_c and builtin.target.abi == .msvc) return error.SkipZigTest;
3535
3636 if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) {
......@@ -44,7 +44,7 @@ test "large alignment of local constant" {
4444
4545test "slicing array of length 1 can not assume runtime index is always zero" {
4646 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
47 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
4848
4949 var runtime_index: usize = 1;
5050 _ = &runtime_index;
......@@ -55,7 +55,7 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
5555}
5656
5757test "implicitly-aligned pointer is coercible to equivalent explicitly-aligned pointer" {
58 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5959
6060 const A = *u32;
6161 const B = *align(@alignOf(u32)) u32;
......@@ -89,6 +89,8 @@ test "implicitly-aligned pointer is coercible to equivalent explicitly-aligned p
8989}
9090
9191test "implicitly decreasing pointer alignment" {
92 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
93
9294 const a: u32 align(4) = 3;
9395 const b: u32 align(8) = 4;
9496 try expect(addUnaligned(&a, &b) == 7);
......@@ -240,7 +242,7 @@ test "alignment and size of structs with 128-bit fields" {
240242
241243test "implicitly decreasing slice alignment" {
242244 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
245 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
244246 const a: u32 align(4) = 3;
245247 const b: u32 align(8) = 4;
246248 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 {
251253
252254test "specifying alignment allows pointer cast" {
253255 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
254 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
256 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
255257
256258 try testBytesAlign(0x33);
257259}
......@@ -264,7 +266,7 @@ fn testBytesAlign(b: u8) !void {
264266test "@alignCast slices" {
265267 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
266268 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
267 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
269 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
268270
269271 var array align(4) = [_]u32{ 1, 1 };
270272 const slice = array[0..];
......@@ -279,6 +281,7 @@ fn sliceExpects4(slice: []align(4) u32) void {
279281}
280282
281283test "return error union with 128-bit integer" {
284 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
282285 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
283286 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
284287 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -292,7 +295,7 @@ test "page aligned array on stack" {
292295 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
293296 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
294297 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
298 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
296299 // Large alignment value to make it hard to accidentally pass.
297300 var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
298301 var number1: u8 align(16) = 42;
......@@ -310,7 +313,7 @@ test "page aligned array on stack" {
310313test "function alignment" {
311314 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
312315 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
316 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
314317
315318 // function alignment greater than 1 is a compile error on wasm
316319 if (native_arch.isWasm()) return error.SkipZigTest;
......@@ -339,7 +342,7 @@ test "function alignment" {
339342test "implicitly decreasing fn alignment" {
340343 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
341344 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
342 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
345 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
343346
344347 // function alignment greater than 1 is a compile error on wasm
345348 if (native_arch.isWasm()) return error.SkipZigTest;
......@@ -362,7 +365,7 @@ fn alignedBig() align(16) i32 {
362365test "@alignCast functions" {
363366 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
364367 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
365 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
368 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
366369
367370 // function alignment greater than 1 is a compile error on wasm
368371 if (native_arch.isWasm()) return error.SkipZigTest;
......@@ -381,7 +384,7 @@ fn simple4() align(4) i32 {
381384
382385test "runtime-known array index has best alignment possible" {
383386 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
384 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
387 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
385388
386389 // take full advantage of over-alignment
387390 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 {
430433}
431434
432435test "alignment of function with c calling convention" {
433 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
436 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
434437
435438 const a = @alignOf(@TypeOf(nothing));
436439
......@@ -449,6 +452,7 @@ const DefaultAligned = struct {
449452};
450453
451454test "read 128-bit field from default aligned struct in stack memory" {
455 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
452456 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
453457 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
454458 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -467,7 +471,7 @@ var default_aligned_global = DefaultAligned{
467471};
468472
469473test "read 128-bit field from default aligned struct in global memory" {
470 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
474 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
471475 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
472476 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
473477 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" {
478482test "struct field explicit alignment" {
479483 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
480484 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
481 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
485 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
482486 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
483487
484488 const S = struct {
......@@ -498,7 +502,7 @@ test "struct field explicit alignment" {
498502test "align(N) on functions" {
499503 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
500504 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
505 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
502506
503507 if (builtin.zig_backend == .stage2_c) {
504508 // https://github.com/ziglang/zig/issues/16845
......@@ -536,7 +540,7 @@ test "comptime alloc alignment" {
536540
537541test "@alignCast null" {
538542 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
539 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
543 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
540544
541545 var ptr: ?*anyopaque = null;
542546 _ = &ptr;
......@@ -552,7 +556,7 @@ test "alignment of slice element" {
552556test "sub-aligned pointer field access" {
553557 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
554558 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
555 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
559 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
556560
557561 // Originally reported at https://github.com/ziglang/zig/issues/14904
558562
......@@ -570,7 +574,7 @@ test "sub-aligned pointer field access" {
570574}
571575
572576test "alignment of zero-bit types is respected" {
573 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
577 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
574578 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
575579
576580 const S = struct { arr: [0]usize = .{} };
......@@ -602,7 +606,7 @@ test "zero-bit fields in extern struct pad fields appropriately" {
602606 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
603607 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
604608 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
605 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
609 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
606610
607611 const S = extern struct {
608612 x: u8,
......@@ -626,7 +630,7 @@ test "zero-bit fields in extern struct pad fields appropriately" {
626630}
627631
628632test "function pointer @intFromPtr/@ptrFromInt roundtrip" {
629 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
633 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
630634
631635 // This only succeeds on Thumb if we handle the Thumb bit correctly; if not, the `@ptrFromInt`
632636 // will incorrectly trip an alignment safety check.
......@@ -646,7 +650,7 @@ test "function pointer align mask" {
646650}
647651
648652test "align expression is implicitly comptime" {
649 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
653 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
650654
651655 const S = struct {
652656 fn alignment() usize {
test/behavior/alignof.zig+2-1
......@@ -19,6 +19,7 @@ test "@alignOf(T) before referencing T" {
1919}
2020
2121test "comparison of @alignOf(T) against zero" {
22 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2223 const T = struct { x: u32 };
2324 try expect(!(@alignOf(T) == 0));
2425 try expect(@alignOf(T) != 0);
......@@ -29,7 +30,7 @@ test "comparison of @alignOf(T) against zero" {
2930}
3031
3132test "correct alignment for elements and slices of aligned array" {
32 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
33 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3334
3435 var buf: [1024]u8 align(64) = undefined;
3536 var start: usize = 1;
test/behavior/array.zig+52-36
......@@ -7,7 +7,7 @@ const expect = testing.expect;
77const expectEqual = testing.expectEqual;
88
99test "array to slice" {
10 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1111
1212 const a: u32 align(4) = 3;
1313 const b: u32 align(8) = 4;
......@@ -21,7 +21,7 @@ test "array to slice" {
2121}
2222
2323test "arrays" {
24 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
24 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2525 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2626 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2727
......@@ -51,7 +51,7 @@ fn getArrayLen(a: []const u32) usize {
5151test "runtime array concat with comptime slice" {
5252 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5353 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
54 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
54 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5555 var a: [1]u8 = .{1};
5656 const b = (comptime @as([]const u8, &.{0})) ++ &a;
5757 const c = &a ++ (comptime @as([]const u8, &.{0}));
......@@ -61,7 +61,7 @@ test "runtime array concat with comptime slice" {
6161
6262test "array concat with undefined" {
6363 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
64 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
64 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6565
6666 const S = struct {
6767 fn doTheTest() !void {
......@@ -83,7 +83,7 @@ test "array concat with undefined" {
8383}
8484
8585test "array concat with tuple" {
86 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
86 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8787 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8888 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8989
......@@ -99,7 +99,7 @@ test "array concat with tuple" {
9999}
100100
101101test "array concat with undefined tuple" {
102 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
102 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
103103
104104 {
105105 const array: [2]u64 = .{ 1, 2 };
......@@ -117,7 +117,7 @@ test "array concat with undefined tuple" {
117117}
118118
119119test "array init with concat" {
120 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
120 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
121121
122122 const a = 'a';
123123 var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };
......@@ -152,6 +152,7 @@ const ArrayDotLenConstExpr = struct {
152152const some_array = [_]u8{ 0, 1, 2, 3 };
153153
154154test "array literal with specified size" {
155 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
155156 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
156157 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
157158
......@@ -162,6 +163,7 @@ test "array literal with specified size" {
162163}
163164
164165test "array len field" {
166 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
165167 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
166168
167169 var arr = [4]u8{ 0, 0, 0, 0 };
......@@ -174,7 +176,7 @@ test "array len field" {
174176}
175177
176178test "array with sentinels" {
177 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
179 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
178180 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
179181
180182 const S = struct {
......@@ -211,7 +213,7 @@ test "void arrays" {
211213}
212214
213215test "nested arrays of strings" {
214 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
216 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
215217 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
216218 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
217219
......@@ -226,6 +228,7 @@ test "nested arrays of strings" {
226228}
227229
228230test "nested arrays of integers" {
231 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
229232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
230233
231234 const array_of_numbers = [_][2]u8{
......@@ -240,6 +243,7 @@ test "nested arrays of integers" {
240243}
241244
242245test "implicit comptime in array type size" {
246 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
243247 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
244248
245249 var arr: [plusOne(10)]bool = undefined;
......@@ -253,7 +257,7 @@ fn plusOne(x: u32) u32 {
253257
254258test "single-item pointer to array indexing and slicing" {
255259 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
256 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
260 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
257261
258262 try testSingleItemPtrArrayIndexSlice();
259263 try comptime testSingleItemPtrArrayIndexSlice();
......@@ -279,7 +283,7 @@ fn doSomeMangling(array: *[4]u8) void {
279283
280284test "implicit cast zero sized array ptr to slice" {
281285 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
282 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
286 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
283287
284288 {
285289 var b = "".*;
......@@ -294,6 +298,7 @@ test "implicit cast zero sized array ptr to slice" {
294298}
295299
296300test "anonymous list literal syntax" {
301 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
297302 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
298303 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
299304
......@@ -315,7 +320,7 @@ var s_array: [8]Sub = undefined;
315320const Sub = struct { b: u8 };
316321const Str = struct { a: []Sub };
317322test "set global var array via slice embedded in struct" {
318 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
323 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
319324 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
320325
321326 var s = Str{ .a = s_array[0..] };
......@@ -330,7 +335,7 @@ test "set global var array via slice embedded in struct" {
330335}
331336
332337test "implicit cast single-item pointer" {
333 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
338 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
334339 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
335340
336341 try testImplicitCastSingleItemPtr();
......@@ -359,7 +364,7 @@ test "comptime evaluating function that takes array by value" {
359364}
360365
361366test "runtime initialize array elem and then implicit cast to slice" {
362 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
367 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
363368 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
364369
365370 var two: i32 = 2;
......@@ -369,7 +374,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
369374}
370375
371376test "array literal as argument to function" {
372 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
377 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
373378 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
374379
375380 const S = struct {
......@@ -396,7 +401,7 @@ test "array literal as argument to function" {
396401}
397402
398403test "double nested array to const slice cast in array literal" {
399 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
404 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
400405 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
401406 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
402407
......@@ -457,6 +462,7 @@ test "double nested array to const slice cast in array literal" {
457462}
458463
459464test "anonymous literal in array" {
465 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
460466 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
461467 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
462468
......@@ -482,6 +488,7 @@ test "anonymous literal in array" {
482488}
483489
484490test "access the null element of a null terminated array" {
491 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
485492 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
486493
487494 const S = struct {
......@@ -499,6 +506,7 @@ test "access the null element of a null terminated array" {
499506}
500507
501508test "type deduction for array subscript expression" {
509 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
502510 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
503511 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
504512
......@@ -517,7 +525,7 @@ test "type deduction for array subscript expression" {
517525}
518526
519527test "sentinel element count towards the ABI size calculation" {
520 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
528 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
521529 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
522530 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
523531
......@@ -542,7 +550,7 @@ test "sentinel element count towards the ABI size calculation" {
542550
543551test "type coercion of anon struct literal to array" {
544552 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
545 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
553 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
546554 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
547555 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
548556
......@@ -582,7 +590,7 @@ test "array with comptime-only element type" {
582590}
583591
584592test "tuple to array handles sentinel" {
585 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
593 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
586594 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
587595 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
588596
......@@ -612,7 +620,7 @@ test "array-like to array handles sentinel" {
612620}
613621
614622test "array init of container level array variable" {
615 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
623 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
616624 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
617625 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
618626
......@@ -635,7 +643,7 @@ test "array init of container level array variable" {
635643}
636644
637645test "runtime initialized sentinel-terminated array literal" {
638 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
646 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
639647
640648 var c: u16 = 300;
641649 _ = &c;
......@@ -646,6 +654,7 @@ test "runtime initialized sentinel-terminated array literal" {
646654}
647655
648656test "array of array agregate init" {
657 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
649658 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
650659 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
651660
......@@ -656,7 +665,7 @@ test "array of array agregate init" {
656665}
657666
658667test "pointer to array has ptr field" {
659 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
668 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
660669
661670 const S = struct {
662671 fn doTheTest(p: *const [5]u32) !void {
......@@ -692,6 +701,7 @@ test "discarded array init preserves result location" {
692701}
693702
694703test "array init with no result location has result type" {
704 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
695705 const x = .{ .foo = [2]u16{
696706 @intCast(10),
697707 @intCast(20),
......@@ -705,7 +715,7 @@ test "array init with no result location has result type" {
705715test "slicing array of zero-sized values" {
706716 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
707717 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
708 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
718 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
709719
710720 var arr: [32]u0 = undefined;
711721 for (arr[0..]) |*zero|
......@@ -715,6 +725,7 @@ test "slicing array of zero-sized values" {
715725}
716726
717727test "array init with no result pointer sets field result types" {
728 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
718729 const S = struct {
719730 // A function parameter has a result type, but no result pointer.
720731 fn f(arr: [1]u32) u32 {
......@@ -729,7 +740,7 @@ test "array init with no result pointer sets field result types" {
729740}
730741
731742test "runtime side-effects in comptime-known array init" {
732 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
743 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
733744
734745 var side_effects: u4 = 0;
735746 const init = [4]u4{
......@@ -755,7 +766,7 @@ test "runtime side-effects in comptime-known array init" {
755766}
756767
757768test "slice initialized through reference to anonymous array init provides result types" {
758 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
769 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
759770
760771 var my_u32: u32 = 123;
761772 var my_u64: u64 = 456;
......@@ -770,7 +781,7 @@ test "slice initialized through reference to anonymous array init provides resul
770781}
771782
772783test "sentinel-terminated slice initialized through reference to anonymous array init provides result types" {
773 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
784 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
774785
775786 var my_u32: u32 = 123;
776787 var my_u64: u64 = 456;
......@@ -785,7 +796,7 @@ test "sentinel-terminated slice initialized through reference to anonymous array
785796}
786797
787798test "many-item pointer initialized through reference to anonymous array init provides result types" {
788 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
799 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
789800 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
790801
791802 var my_u32: u32 = 123;
......@@ -804,7 +815,7 @@ test "many-item pointer initialized through reference to anonymous array init pr
804815}
805816
806817test "many-item sentinel-terminated pointer initialized through reference to anonymous array init provides result types" {
807 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
818 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
808819 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
809820
810821 var my_u32: u32 = 123;
......@@ -824,7 +835,7 @@ test "many-item sentinel-terminated pointer initialized through reference to ano
824835}
825836
826837test "pointer to array initialized through reference to anonymous array init provides result types" {
827 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
838 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
828839
829840 var my_u32: u32 = 123;
830841 var my_u64: u64 = 456;
......@@ -839,7 +850,7 @@ test "pointer to array initialized through reference to anonymous array init pro
839850}
840851
841852test "pointer to sentinel-terminated array initialized through reference to anonymous array init provides result types" {
842 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
853 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
843854
844855 var my_u32: u32 = 123;
845856 var my_u64: u64 = 456;
......@@ -854,6 +865,7 @@ test "pointer to sentinel-terminated array initialized through reference to anon
854865}
855866
856867test "tuple initialized through reference to anonymous array init provides result types" {
868 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
857869 const Tuple = struct { u64, *const u32 };
858870 const foo: *const Tuple = &.{
859871 @intCast(12345),
......@@ -864,6 +876,7 @@ test "tuple initialized through reference to anonymous array init provides resul
864876}
865877
866878test "copied array element doesn't alias source" {
879 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
867880 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
868881 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
869882
......@@ -878,7 +891,7 @@ test "copied array element doesn't alias source" {
878891
879892test "array initialized with string literal" {
880893 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
881 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
894 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
882895
883896 const S = struct {
884897 a: u32,
......@@ -898,7 +911,7 @@ test "array initialized with string literal" {
898911}
899912
900913test "array initialized with array with sentinel" {
901 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
914 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
902915 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
903916
904917 const S = struct {
......@@ -919,6 +932,7 @@ test "array initialized with array with sentinel" {
919932}
920933
921934test "store array of array of structs at comptime" {
935 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
922936 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
923937 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
924938
......@@ -944,7 +958,7 @@ test "store array of array of structs at comptime" {
944958
945959test "accessing multidimensional global array at comptime" {
946960 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
947 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
961 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
948962
949963 const S = struct {
950964 const array = [_][]const []const u8{
......@@ -958,6 +972,7 @@ test "accessing multidimensional global array at comptime" {
958972}
959973
960974test "union that needs padding bytes inside an array" {
975 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
961976 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
962977 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
963978 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -981,7 +996,7 @@ test "union that needs padding bytes inside an array" {
981996}
982997
983998test "runtime index of array of zero-bit values" {
984 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
999 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9851000
9861001 var runtime: struct { array: [1]void, index: usize } = undefined;
9871002 runtime = .{ .array = .{{}}, .index = 0 };
......@@ -1035,7 +1050,7 @@ test "initialize pointer to anyopaque with reference to empty array initializer"
10351050}
10361051
10371052test "sentinel of runtime-known array initialization is populated" {
1038 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1053 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10391054
10401055 var rt: u32 = undefined;
10411056 rt = 42;
......@@ -1048,6 +1063,7 @@ test "sentinel of runtime-known array initialization is populated" {
10481063}
10491064
10501065test "resist alias of explicit copy of array passed as arg" {
1066 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10511067 const S = struct {
10521068 const Thing = [1]u32;
10531069
......@@ -1069,7 +1085,7 @@ test "resist alias of explicit copy of array passed as arg" {
10691085}
10701086
10711087test "access element through reference" {
1072 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1088 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10731089
10741090 const S = struct {
10751091 fn doTheTest(x: u8) !void {
test/behavior/asm.zig+3-3
......@@ -18,7 +18,7 @@ comptime {
1818 \\.type this_is_my_alias, @function;
1919 \\.set this_is_my_alias, derp;
2020 );
21 } else if (builtin.zig_backend == .stage2_spirv) {
21 } else if (builtin.cpu.arch.isSpirv()) {
2222 asm (
2323 \\%a = OpString "hello there"
2424 );
......@@ -43,7 +43,7 @@ test "output constraint modifiers" {
4343 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
4444 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4545 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
46 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
46 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4747 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
4848
4949 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" {
6565 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
6666 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6767 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
68 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6969 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7070
7171 if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
test/behavior/atomics.zig+11-11
......@@ -14,7 +14,7 @@ test "cmpxchg" {
1414 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1616 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
17 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1818
1919 try testCmpxchg();
2020 try comptime testCmpxchg();
......@@ -41,7 +41,7 @@ test "atomicrmw and atomicload" {
4141 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4242 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4343 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
44 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4545 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
4646
4747 var data: u8 = 200;
......@@ -70,7 +70,7 @@ test "cmpxchg with ptr" {
7070 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7171 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7272 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
73 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
73 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7474 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7575
7676 var data1: i32 = 1234;
......@@ -96,7 +96,7 @@ test "cmpxchg with ignored result" {
9696 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9797 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9898 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
99 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
99 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
100100
101101 var x: i32 = 1234;
102102
......@@ -141,7 +141,7 @@ test "cmpxchg on a global variable" {
141141 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
142142 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
143143 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
144 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
144 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
145145
146146 _ = @cmpxchgStrong(u32, &a_global_variable, 1234, 42, .acquire, .monotonic);
147147 try expect(a_global_variable == 42);
......@@ -151,7 +151,7 @@ test "atomic load and rmw with enum" {
151151 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
152152 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
153153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
154 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
154 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
155155 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
156156
157157 const Value = enum(u8) { a, b, c };
......@@ -169,7 +169,7 @@ test "atomic store" {
169169 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
170170 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171171 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
172 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
172 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
173173
174174 try comptime testAtomicStore();
175175 try testAtomicStore();
......@@ -188,7 +188,7 @@ test "atomicrmw with floats" {
188188 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
189189 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
190190 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
191 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
191 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
192192 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
193193
194194 try testAtomicRmwFloat();
......@@ -214,7 +214,7 @@ test "atomicrmw with ints" {
214214 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
215215 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
216216 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
217 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
217 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
218218 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
219219
220220 try testAtomicRmwInts();
......@@ -357,7 +357,7 @@ test "atomics with different types" {
357357 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
358358 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
359359 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
360 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
360 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
361361 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
362362
363363 try testAtomicsWithType(bool, true, false);
......@@ -411,7 +411,7 @@ fn testAtomicsWithPackedStruct(comptime T: type, a: T, b: T) !void {
411411test "return @atomicStore, using it as a void value" {
412412 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
413413 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
414 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
414 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
415415
416416 const S = struct {
417417 const A = struct {
test/behavior/backing_int.zig+11-3
......@@ -46,6 +46,8 @@ const E5 = enum(u0) {
4646};
4747
4848test "@backingInt with enums" {
49 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
50
4951 const static = struct {
5052 fn doTheTest(v1: E1, v2: E2, v3: E3, v4: E4, v5: E5) !void {
5153 const b1 = @backingInt(v1);
......@@ -74,6 +76,8 @@ test "@backingInt with enums" {
7476}
7577
7678test "@fromBackingInt with enums" {
79 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
80
7781 const static = struct {
7882 fn doTheTest(
7983 b1: @typeInfo(E1).@"enum".tag_type,
......@@ -137,7 +141,7 @@ const T5 = union(E5) {
137141};
138142
139143test "@backingInt with tagged unions" {
140 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
144 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
141145
142146 const static = struct {
143147 fn doTheTest(v1: T1, v2: T2, v4: T4, v5: T5) !void {
......@@ -208,6 +212,8 @@ const S5 = packed struct(u0) {
208212};
209213
210214test "@backingInt with packed structs" {
215 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
216
211217 const static = struct {
212218 fn doTheTest(v1: S1, v2: S2, v3: S3, v4: S4, v5: S5) !void {
213219 const b1 = @backingInt(v1);
......@@ -236,6 +242,8 @@ test "@backingInt with packed structs" {
236242}
237243
238244test "@fromBackingInt with packed structs" {
245 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
246
239247 const static = struct {
240248 fn doTheTest(
241249 b1: @typeInfo(S1).@"struct".backing_integer.?,
......@@ -313,7 +321,7 @@ const U5 = packed union(u0) {
313321};
314322
315323test "@backingInt with packed unions" {
316 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
324 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
317325
318326 const static = struct {
319327 fn doTheTest(v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) !void {
......@@ -343,7 +351,7 @@ test "@backingInt with packed unions" {
343351}
344352
345353test "@fromBackingInt with packed unions" {
346 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
354 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
347355
348356 const static = struct {
349357 fn doTheTest(
test/behavior/basic.zig+70-32
......@@ -24,6 +24,7 @@ fn testTruncate(x: u32) u8 {
2424}
2525
2626test "truncate to non-power-of-two integers" {
27 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2728 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2829
2930 try testTrunc(u32, u1, 0b10101, 0b1);
......@@ -38,6 +39,7 @@ test "truncate to non-power-of-two integers" {
3839}
3940
4041test "truncate to non-power-of-two integers from 128-bit" {
42 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4143 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4244 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4345
......@@ -60,7 +62,7 @@ const g1: i32 = 1233 + 1;
6062var g2: i32 = 0;
6163
6264test "global variables" {
63 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
65 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6466 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6567
6668 try expect(g2 == 0);
......@@ -80,6 +82,8 @@ test "type equality" {
8082}
8183
8284test "pointer dereferencing" {
85 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
86
8387 var x = @as(i32, 3);
8488 const y = &x;
8589
......@@ -137,6 +141,8 @@ test "function branch hints" {
137141}
138142
139143test "if branch hints" {
144 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
145
140146 var t: bool = undefined;
141147 t = true;
142148 if (t) {
......@@ -147,6 +153,8 @@ test "if branch hints" {
147153}
148154
149155test "switch branch hints" {
156 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
157
150158 var t: bool = undefined;
151159 t = true;
152160 switch (t) {
......@@ -160,6 +168,8 @@ test "switch branch hints" {
160168}
161169
162170test "orelse branch hints" {
171 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
172
163173 var x: ?u32 = undefined;
164174 x = 123;
165175 const val = x orelse val: {
......@@ -170,6 +180,8 @@ test "orelse branch hints" {
170180}
171181
172182test "catch branch hints" {
183 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
184
173185 var x: error{Bad}!u32 = undefined;
174186 x = 123;
175187 const val = x catch val: {
......@@ -180,6 +192,8 @@ test "catch branch hints" {
180192}
181193
182194test "and/or branch hints" {
195 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
196
183197 var t: bool = undefined;
184198 t = true;
185199 try expect(t or b: {
......@@ -207,14 +221,14 @@ fn first4KeysOfHomeRow() []const u8 {
207221}
208222
209223test "return string from function" {
210 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
224 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
211225 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
212226
213227 try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
214228}
215229
216230test "hex escape" {
217 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
231 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
218232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
219233
220234 try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
......@@ -222,7 +236,7 @@ test "hex escape" {
222236
223237test "multiline string" {
224238 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
225 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
239 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
226240
227241 const s1 =
228242 \\one
......@@ -235,7 +249,7 @@ test "multiline string" {
235249
236250test "multiline string comments at start" {
237251 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
238 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
252 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
239253
240254 const s1 =
241255 //\\one
......@@ -248,7 +262,7 @@ test "multiline string comments at start" {
248262
249263test "multiline string comments at end" {
250264 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
251 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
265 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
252266
253267 const s1 =
254268 \\one
......@@ -261,7 +275,7 @@ test "multiline string comments at end" {
261275
262276test "multiline string comments in middle" {
263277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
264 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
278 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
265279
266280 const s1 =
267281 \\one
......@@ -274,7 +288,7 @@ test "multiline string comments in middle" {
274288
275289test "multiline string comments at multiple places" {
276290 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
277 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
291 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
278292
279293 const s1 =
280294 \\one
......@@ -288,7 +302,7 @@ test "multiline string comments at multiple places" {
288302}
289303
290304test "string concatenation simple" {
291 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
305 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
292306
293307 try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
294308}
......@@ -302,6 +316,7 @@ test "compile time global reinterpret" {
302316}
303317
304318test "cast undefined" {
319 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
305320 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
306321
307322 const array: [100]u8 = undefined;
......@@ -372,7 +387,8 @@ fn fB() []const u8 {
372387
373388test "call function pointer in struct" {
374389 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
375 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
390 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
391
376392 try expect(mem.eql(u8, f3(true), "a"));
377393 try expect(mem.eql(u8, f3(false), "b"));
378394}
......@@ -394,6 +410,7 @@ const FnPtrWrapper = struct {
394410};
395411
396412test "const ptr from var variable" {
413 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
397414 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
398415
399416 var x: u64 = undefined;
......@@ -412,7 +429,7 @@ fn copy(src: *const u64, dst: *u64) void {
412429test "call result of if else expression" {
413430 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
414431 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
415 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
432 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
416433
417434 try expect(mem.eql(u8, f2(true), "a"));
418435 try expect(mem.eql(u8, f2(false), "b"));
......@@ -423,7 +440,7 @@ fn f2(x: bool) []const u8 {
423440
424441const OpaqueA = opaque {};
425442test "variable is allowed to be a pointer to an opaque type" {
426 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
443 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
427444
428445 var x: i32 = 1234;
429446 _ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));
......@@ -446,7 +463,7 @@ fn testTakeAddressOfParameter(f: f32) !void {
446463}
447464
448465test "pointer to void return type" {
449 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
466 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
450467
451468 try testPointerToVoidReturnType();
452469}
......@@ -462,7 +479,7 @@ fn testPointerToVoidReturnType2() *const void {
462479test "array 2D const double ptr" {
463480 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
464481 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
465 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
482 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
466483
467484 const rect_2d_vertexes = [_][1]f32{
468485 [_]f32{1.0},
......@@ -474,7 +491,7 @@ test "array 2D const double ptr" {
474491test "array 2D const double ptr with offset" {
475492 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
476493 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
477 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
494 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
478495
479496 const rect_2d_vertexes = [_][2]f32{
480497 [_]f32{ 3.0, 4.239 },
......@@ -486,7 +503,7 @@ test "array 2D const double ptr with offset" {
486503test "array 3D const double ptr with offset" {
487504 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
488505 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
489 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
506 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
490507
491508 const rect_3d_vertexes = [_][2][2]f32{
492509 [_][2]f32{
......@@ -519,6 +536,7 @@ fn nine() u8 {
519536}
520537
521538test "struct inside function" {
539 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
522540 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
523541
524542 try testStructInFn();
......@@ -541,7 +559,7 @@ fn testStructInFn() !void {
541559
542560test "fn call returning scalar optional in equality expression" {
543561 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
544 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
562 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
545563
546564 try expect(getNull() == null);
547565}
......@@ -553,7 +571,7 @@ fn getNull() ?*i32 {
553571test "global variable assignment with optional unwrapping with var initialized to undefined" {
554572 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
555573 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
556 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
574 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
557575
558576 const S = struct {
559577 var data: i32 = 1234;
......@@ -570,6 +588,7 @@ test "global variable assignment with optional unwrapping with var initialized t
570588var global_foo: *i32 = undefined;
571589
572590test "peer result location with typed parent, runtime condition, comptime prongs" {
591 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
573592 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
574593
575594 const S = struct {
......@@ -610,6 +629,8 @@ fn ZA() type {
610629}
611630
612631test "use of declaration with same name as primitive" {
632 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
633
613634 const S = struct {
614635 const @"u8" = u16;
615636 const alias = @"u8";
......@@ -636,12 +657,14 @@ fn emptyFn() void {}
636657
637658const addr1 = @as(*const u8, @ptrCast(&emptyFn));
638659test "comptime cast fn to ptr" {
660 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
661
639662 const addr2 = @as(*const u8, @ptrCast(&emptyFn));
640663 comptime assert(addr1 == addr2);
641664}
642665
643666test "equality compare fn ptrs" {
644 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // Uses function pointers
667 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Uses function pointers
645668
646669 var a = &emptyFn;
647670 _ = &a;
......@@ -649,7 +672,7 @@ test "equality compare fn ptrs" {
649672}
650673
651674test "self reference through fn ptr field" {
652 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
675 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
653676
654677 const S = struct {
655678 const A = struct {
......@@ -668,7 +691,7 @@ test "self reference through fn ptr field" {
668691
669692test "global variable initialized to global variable array element" {
670693 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
671 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
694 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
672695
673696 try expect(global_ptr == &gdt[0]);
674697}
......@@ -682,7 +705,7 @@ var gdt = [_]GDTEntry{
682705var global_ptr = &gdt[0];
683706
684707test "global constant is loaded with a runtime-known index" {
685 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
708 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
686709 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
687710
688711 const S = struct {
......@@ -701,7 +724,7 @@ test "global constant is loaded with a runtime-known index" {
701724}
702725
703726test "multiline string literal is null terminated" {
704 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
727 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
705728
706729 const s1 =
707730 \\one
......@@ -715,7 +738,7 @@ test "multiline string literal is null terminated" {
715738test "string escapes" {
716739 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
717740 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
718 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
741 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
719742
720743 try expectEqualStrings("\"", "\x22");
721744 try expectEqualStrings("\'", "\x27");
......@@ -733,7 +756,7 @@ test "explicit cast optional pointers" {
733756}
734757
735758test "pointer comparison" {
736 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
759 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
737760
738761 const a = @as([]const u8, "a");
739762 const b = &a;
......@@ -744,6 +767,7 @@ fn ptrEql(a: *const []const u8, b: *const []const u8) bool {
744767}
745768
746769test "string concatenation" {
770 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
747771 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
748772 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
749773
......@@ -766,6 +790,7 @@ test "string concatenation" {
766790}
767791
768792test "result location is optional inside error union" {
793 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
769794 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
770795 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
771796
......@@ -782,7 +807,7 @@ fn maybe(x: bool) anyerror!?u32 {
782807
783808test "auto created variables have correct alignment" {
784809 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
785 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
810 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
786811
787812 const S = struct {
788813 fn foo(str: [*]const u8) u32 {
......@@ -799,7 +824,7 @@ test "auto created variables have correct alignment" {
799824test "extern variable with non-pointer opaque type" {
800825 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
801826 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
802 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
827 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
803828
804829 @export(&var_to_export, .{ .name = "opaque_extern_var" });
805830 try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42);
......@@ -840,6 +865,7 @@ test "if expression type coercion" {
840865}
841866
842867test "discarding the result of various expressions" {
868 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
843869 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
844870 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
845871
......@@ -912,6 +938,7 @@ test "labeled block with runtime branch forwards its result location type to bre
912938}
913939
914940test "try in labeled block doesn't cast to wrong type" {
941 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
915942 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
916943
917944 const S = struct {
......@@ -936,6 +963,7 @@ test "vector initialized with array init syntax has proper type" {
936963}
937964
938965test "weird array and tuple initializations" {
966 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
939967 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
940968 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
941969
......@@ -1054,6 +1082,7 @@ comptime {
10541082}
10551083
10561084test "switch inside @as gets correct type" {
1085 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10571086 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10581087
10591088 var a: u32 = 0;
......@@ -1078,7 +1107,7 @@ test "inline call of function with a switch inside the return statement" {
10781107}
10791108
10801109test "pointer to zero sized global is mutable" {
1081 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1110 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10821111
10831112 const S = struct {
10841113 const Thing = struct {};
......@@ -1100,6 +1129,7 @@ test "returning an opaque type from a function" {
11001129}
11011130
11021131test "orelse coercion as function argument" {
1132 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11031133 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11041134
11051135 const Loc = struct { start: i32 = -1 };
......@@ -1118,7 +1148,7 @@ test "orelse coercion as function argument" {
11181148}
11191149
11201150test "runtime-known globals initialized with undefined" {
1121 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1151 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11221152
11231153 const S = struct {
11241154 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" {
11371167 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11381168 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
11391169 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1140 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1170 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11411171 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11421172 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
11431173
......@@ -1211,6 +1241,8 @@ fn testUnsignedCmp(comptime T: type) !void {
12111241}
12121242
12131243test "integer compare <= 64 bits" {
1244 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1245
12141246 inline for (.{ u8, u16, u32, u64, usize, u10, u20, u30, u60 }) |T| {
12151247 try testUnsignedCmp(T);
12161248 try comptime testUnsignedCmp(T);
......@@ -1222,6 +1254,7 @@ test "integer compare <= 64 bits" {
12221254}
12231255
12241256test "integer compare <= 128 bits" {
1257 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12251258 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12261259
12271260 inline for (.{ u65, u96, u127, u128 }) |T| {
......@@ -1235,6 +1268,7 @@ test "integer compare <= 128 bits" {
12351268}
12361269
12371270test "integer compare > 128 bits" {
1271 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12381272 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12391273
12401274 inline for (.{ u129, u255, u512, u800 }) |T| {
......@@ -1248,6 +1282,7 @@ test "integer compare > 128 bits" {
12481282}
12491283
12501284test "reference to inferred local variable works as expected" {
1285 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12511286 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12521287
12531288 const Crasher = struct {
......@@ -1332,7 +1367,7 @@ test "const inferred array of slices" {
13321367
13331368test "var inferred array of slices" {
13341369 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1335 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1370 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13361371
13371372 const T = struct { v: bool };
13381373
......@@ -1355,6 +1390,7 @@ test "copy array of self-referential struct" {
13551390}
13561391
13571392test "break out of block based on comptime known values" {
1393 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13581394 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
13591395 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13601396
......@@ -1392,7 +1428,7 @@ test "allocation and looping over 3-byte integer" {
13921428 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13931429 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13941430 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1395 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1431 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13961432 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13971433
13981434 try expect(@sizeOf(u24) == 4);
......@@ -1419,6 +1455,8 @@ test "allocation and looping over 3-byte integer" {
14191455}
14201456
14211457test "loading array from struct is not optimized away" {
1458 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1459
14221460 const S = struct {
14231461 arr: [1]u32 = .{0},
14241462 fn doTheTest(self: *@This()) !void {
test/behavior/bit_shifting.zig+3-3
......@@ -65,7 +65,7 @@ test "sharded table" {
6565 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6666 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6767 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
68 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6969
7070 // realistic 16-way sharding
7171 try testShardedTable(u32, 4, 8);
......@@ -115,7 +115,7 @@ test "Saturating Shift Left where lhs is of a computed type" {
115115 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
116116 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
117117 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
118 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
118 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
119119 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
120120
121121 const S = struct {
......@@ -148,7 +148,7 @@ test "Saturating Shift Left where lhs is of a computed type" {
148148test "Saturating Shift Left" {
149149 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
150150 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
151 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
151 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
152152 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
153153
154154 const S = struct {
test/behavior/bitcast.zig+19-12
......@@ -9,6 +9,7 @@ const minInt = std.math.minInt;
99const native_endian = builtin.target.cpu.arch.endian();
1010
1111test "@bitCast iX -> uX (32, 64)" {
12 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1213 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1314
1415 const bit_values = [_]usize{ 32, 64 };
......@@ -20,6 +21,7 @@ test "@bitCast iX -> uX (32, 64)" {
2021}
2122
2223test "@bitCast iX -> uX (8, 16, 128)" {
24 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2325 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2426 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2527 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -32,6 +34,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
3234}
3335
3436test "@bitCast iX -> uX exotic integers" {
37 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3538 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3639 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3740 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -98,7 +101,7 @@ test "bitcast literal [4]u8 param to u32" {
98101}
99102
100103test "bitcast generates a temporary value" {
101 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
104 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
102105
103106 var y: u16 = 0x55AA;
104107 _ = &y;
......@@ -107,6 +110,7 @@ test "bitcast generates a temporary value" {
107110}
108111
109112test "@bitCast packed structs at runtime and comptime" {
113 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
110114 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
111115 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
112116 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -134,6 +138,7 @@ test "@bitCast packed structs at runtime and comptime" {
134138}
135139
136140test "bitcast packed struct to integer and back" {
141 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
137142 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
138143 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
139144 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -157,6 +162,7 @@ test "bitcast packed struct to integer and back" {
157162}
158163
159164test "implicit cast to error union by returning" {
165 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
160166 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161167 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162168
......@@ -211,7 +217,7 @@ test "@bitCast packed struct of floats" {
211217 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
212218 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
213219 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
214 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
220 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
215221 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
216222
217223 const Foo = packed struct {
......@@ -247,7 +253,7 @@ test "comptime @bitCast packed struct to int and back" {
247253 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
248254 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
249255 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
250 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
256 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
251257 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
252258
253259 const S = packed struct {
......@@ -280,7 +286,7 @@ test "comptime @bitCast packed struct to int and back" {
280286test "bitcast vector to integer and back" {
281287 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
282288 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
283 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
289 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
284290 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
285291
286292 var vec: @Vector(16, bool) = @splat(true);
......@@ -312,6 +318,7 @@ test "bitcast vector to integer and back" {
312318}
313319
314320test "bitcast vector elementwise" {
321 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
315322 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
316323 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
317324 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -355,7 +362,7 @@ fn bitCastWrapper128(x: f128) u128 {
355362}
356363test "bitcast nan float does not modify signaling bit" {
357364 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
358 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
365 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
359366 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
360367 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
361368 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
......@@ -409,7 +416,7 @@ test "bitcast nan float does not modify signaling bit" {
409416test "@bitCast of packed struct of bools all true" {
410417 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
411418 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
412 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
419 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
413420 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
414421
415422 const P = packed struct {
......@@ -429,7 +436,7 @@ test "@bitCast of packed struct of bools all true" {
429436test "@bitCast of packed struct of bools all false" {
430437 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
431438 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
432 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
439 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
433440
434441 const P = packed struct {
435442 b0: bool,
......@@ -478,7 +485,7 @@ test "@bitCast of packed struct with void field and multiple integers" {
478485}
479486
480487test "@bitCast vector to array with different element size" {
481 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
488 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
482489
483490 const static = struct {
484491 fn doTheTest(v: @Vector(4, u5)) !void {
......@@ -503,7 +510,7 @@ test "@bitCast vector to array with different element size" {
503510}
504511
505512test "@bitCast packed struct to array of bits" {
506 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
513 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
507514
508515 const S = packed struct(u16) {
509516 foo: u5,
......@@ -551,7 +558,7 @@ test "@bitCast packed struct to array of bits" {
551558}
552559
553560test "@bitCast nested arrays of vectors" {
554 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
561 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
555562
556563 const Src = [2][2]@Vector(4, u5);
557564 const Dest = [5]@Vector(2, u8);
......@@ -588,7 +595,7 @@ test "@bitCast nested arrays of vectors" {
588595}
589596
590597test "@bitCast nested arrays of bool to scalar" {
591 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
598 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
592599
593600 const static = struct {
594601 fn doTheTest(src: [4][4]bool) !void {
......@@ -607,7 +614,7 @@ test "@bitCast nested arrays of bool to scalar" {
607614}
608615
609616test "@bitCast deeply nested arrays to scalar" {
610 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
617 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
611618
612619 const static = struct {
613620 fn doTheTest(src: [2][1][3][5]u4) !void {
test/behavior/bitreverse.zig+4-4
......@@ -11,7 +11,7 @@ test "@bitReverse" {
1111 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1212 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1313 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
14 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1515 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1616
1717 try comptime testBitReverse();
......@@ -124,7 +124,7 @@ test "bitReverse vectors u8" {
124124 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
125125 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
126126 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
127 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
128128 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
129129
130130 try comptime vector8();
......@@ -143,7 +143,7 @@ test "bitReverse vectors u16" {
143143 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
144144 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
145145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
146 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
147147 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
148148
149149 try comptime vector16();
......@@ -162,7 +162,7 @@ test "bitReverse vectors u24" {
162162 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
163163 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
164164 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
165 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
165 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
166166 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
167167
168168 try comptime vector24();
test/behavior/bool.zig+5
......@@ -9,6 +9,7 @@ test "bool literals" {
99}
1010
1111test "cast bool to int" {
12 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1213 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1314
1415 const t = true;
......@@ -48,6 +49,8 @@ test "compile time bool not" {
4849}
4950
5051test "short circuit" {
52 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
53
5154 try testShortCircuit(false, true);
5255 try comptime testShortCircuit(false, true);
5356}
......@@ -92,6 +95,8 @@ fn testShortCircuit(f: bool, t: bool) !void {
9295}
9396
9497test "or with noreturn operand" {
98 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
99
95100 const S = struct {
96101 fn foo(a: u32, b: u32) bool {
97102 return a == 5 or b == 2 or @panic("oh no");
test/behavior/builtin_functions_returning_void_or_noreturn.zig+1-1
......@@ -8,7 +8,7 @@ var x: u8 = 1;
88test {
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1212
1313 var val: u8 = undefined;
1414 try testing.expectEqual({}, @atomicStore(u8, &val, 0, .unordered));
test/behavior/byteswap.zig+5-5
......@@ -6,7 +6,7 @@ test "@byteSwap integers" {
66 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
77 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
88 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1010
1111 const ByteSwapIntTest = struct {
1212 fn run() !void {
......@@ -41,7 +41,7 @@ test "@byteSwap exotic integers" {
4141 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4242 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
4343 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
44 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
44 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4545
4646 const ByteSwapIntTest = struct {
4747 fn run() !void {
......@@ -84,7 +84,7 @@ test "@byteSwap vectors u8" {
8484 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8585 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8686 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
87 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8888 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8989
9090 try comptime vector8();
......@@ -103,7 +103,7 @@ test "@byteSwap vectors u16" {
103103 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
104104 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
105105 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
106 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
107107 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
108108
109109 try comptime vector16();
......@@ -122,7 +122,7 @@ test "@byteSwap vectors u24" {
122122 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
123123 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
124124 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
125 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
125 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
126126 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
127127
128128 try comptime vector24();
test/behavior/byval_arg_var.zig+1-1
......@@ -5,7 +5,7 @@ var result: []const u8 = "wrong";
55
66test "pass string literal byvalue to a generic var param" {
77 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
8 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
99
1010 start();
1111 blowUpStack(10);
test/behavior/call.zig+21-13
......@@ -23,7 +23,7 @@ test "basic invocations" {
2323 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2424 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2525 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
26 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2727
2828 if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support tail call modifiers
2929
......@@ -61,7 +61,7 @@ test "basic invocations" {
6161test "tuple parameters" {
6262 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6363 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
64 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
64 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6565
6666 const add = struct {
6767 fn add(a: i32, b: i32) i32 {
......@@ -92,6 +92,7 @@ test "tuple parameters" {
9292}
9393
9494test "result location of function call argument through runtime condition and struct init" {
95 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9596 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9697 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9798
......@@ -112,6 +113,7 @@ test "result location of function call argument through runtime condition and st
112113}
113114
114115test "function call with 40 arguments" {
116 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
115117 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
116118 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117119 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -273,7 +275,7 @@ test "forced tail call" {
273275 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
274276 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
275277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
276 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
278 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
277279 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
278280
279281 if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
......@@ -308,7 +310,7 @@ test "inline call preserves tail call" {
308310 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
309311 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
310312 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
311 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
313 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
312314 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
313315
314316 if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
......@@ -341,7 +343,7 @@ test "inline call preserves tail call" {
341343
342344test "inline call doesn't re-evaluate non generic struct" {
343345 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
344 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
346 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
345347
346348 const S = struct {
347349 fn foo(f: struct { a: u8, b: u8 }) !void {
......@@ -355,6 +357,8 @@ test "inline call doesn't re-evaluate non generic struct" {
355357}
356358
357359test "Enum constructed by @Enum passed as generic argument" {
360 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
361
358362 const S = struct {
359363 const E = std.meta.FieldEnum(struct {
360364 prev_pos: bool,
......@@ -407,7 +411,7 @@ test "recursive inline call with comptime known argument" {
407411
408412test "inline while with @call" {
409413 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
410 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
414 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
411415
412416 const S = struct {
413417 fn inc(a: *u32) void {
......@@ -423,6 +427,8 @@ test "inline while with @call" {
423427}
424428
425429test "method call as parameter type" {
430 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
431
426432 const S = struct {
427433 fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
428434 return y;
......@@ -436,6 +442,7 @@ test "method call as parameter type" {
436442}
437443
438444test "non-anytype generic parameters provide result type" {
445 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
439446 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
440447 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
441448
......@@ -464,6 +471,7 @@ test "non-anytype generic parameters provide result type" {
464471}
465472
466473test "argument to generic function has correct result type" {
474 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
467475 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
468476 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
469477
......@@ -491,7 +499,7 @@ test "argument to generic function has correct result type" {
491499}
492500
493501test "call inline fn through pointer" {
494 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
502 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
495503
496504 const S = struct {
497505 inline fn foo(x: u8) !void {
......@@ -517,7 +525,7 @@ test "call function in comptime field" {
517525test "call function pointer in comptime field" {
518526 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
519527 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
520 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
528 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
521529
522530 const Auto = struct {
523531 auto: [max_len]u8 = undefined,
......@@ -538,7 +546,7 @@ test "call function pointer in comptime field" {
538546}
539547
540548test "generic function pointer can be called" {
541 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
549 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
542550
543551 const S = struct {
544552 var ok = false;
......@@ -615,7 +623,7 @@ test "call with union with zero sized field is not memorized incorrectly" {
615623test "function call with cast to anyopaque pointer" {
616624 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
617625 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
618 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
626 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
619627
620628 const Foo = struct {
621629 y: u8,
......@@ -633,7 +641,7 @@ test "arguments pointed to on stack into tailcall" {
633641 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
634642 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
635643 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
636 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
644 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
637645 if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support always tail calls
638646
639647 switch (builtin.cpu.arch) {
......@@ -707,7 +715,7 @@ test "tail call function pointer" {
707715 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
708716 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
709717 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
710 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
718 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
711719 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
712720
713721 if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
......@@ -737,7 +745,7 @@ test "tail call function pointer" {
737745test "tail call with potentially extended types" {
738746 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
739747 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
740 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
748 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
741749
742750 if (builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) {
743751 if (builtin.cpu.arch.isMIPS() or builtin.cpu.arch.isPowerPC() or builtin.cpu.arch.isWasm()) {
test/behavior/cast.zig+129-97
......@@ -21,6 +21,7 @@ test "integer literal to pointer cast" {
2121}
2222
2323test "peer type resolution: ?T and T" {
24 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2425 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2526 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2627
......@@ -67,6 +68,7 @@ test "implicit cast comptime_int to comptime_float" {
6768}
6869
6970test "comptime_int @floatFromInt" {
71 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7072 {
7173 const result = @as(f16, @floatFromInt(1234));
7274 try expect(@TypeOf(result) == f16);
......@@ -97,6 +99,7 @@ test "comptime_int @floatFromInt" {
9799}
98100
99101test "@floatFromInt" {
102 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
100103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
101104 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
102105 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 {
126129}
127130
128131test "@intFromFloat > 128 bits" {
129 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
132 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
130133 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
131134 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
132135
......@@ -151,7 +154,7 @@ fn testFloatFromInt(comptime I: type, i: I, comptime F: type, expected: F) !void
151154}
152155
153156test "@floatFromInt > 128 bits" {
154 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
157 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
155158 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
156159 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
157160
......@@ -174,7 +177,7 @@ test "@floatFromInt > 128 bits" {
174177test "@floatFromInt(f80)" {
175178 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
176179 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
177 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
180 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
178181 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
179182 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
180183
......@@ -212,7 +215,7 @@ test "@floatFromInt(f80)" {
212215}
213216
214217test "type coercion from int to float" {
215 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
218 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
216219
217220 const check = struct {
218221 // Check that an integer value can be coerced to a float type and
......@@ -273,6 +276,7 @@ test "type coercion from int to float" {
273276}
274277
275278test "@intFromFloat" {
279 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
276280 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
277281 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
278282
......@@ -299,10 +303,11 @@ fn testIntFromFloats() !void {
299303
300304 try expectRoundCast(f32, -128.2, i8, -128);
301305 try expectCeilCast(f32, -128.2, i8, -128);
302 try expectTruncCast(f32, -128.2, i8, -128);
303306}
304307
305308test "rounding builtins with anytype and context propagation" {
309 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
310
306311 const S = struct {
307312 const x: i32 = 10;
308313 fn check(expected: anytype, actual: anytype) !void {
......@@ -338,7 +343,8 @@ fn expectTruncCast(comptime F: type, f: F, comptime I: type, i: I) !void {
338343
339344test "implicitly cast indirect pointer to maybe-indirect pointer" {
340345 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
341 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
346 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
347
342348 const S = struct {
343349 const Self = @This();
344350 x: u8,
......@@ -372,6 +378,8 @@ test "@intCast comptime_int" {
372378}
373379
374380test "@floatCast comptime_int and comptime_float" {
381 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
382
375383 {
376384 const result = @as(f16, @floatCast(1234));
377385 try expect(@TypeOf(result) == f16);
......@@ -416,7 +424,7 @@ fn MakeType(comptime T: type) type {
416424
417425test "implicit cast from *[N]T to [*c]T" {
418426 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
419 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
427 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
420428
421429 var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
422430 var y: [*c]u16 = &x;
......@@ -451,6 +459,7 @@ test "@intCast to u0 and use the result" {
451459}
452460
453461test "peer result null and comptime_int" {
462 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
454463 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
455464 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
456465
......@@ -477,7 +486,7 @@ test "peer result null and comptime_int" {
477486test "*const ?[*]const T to [*c]const [*c]const T" {
478487 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
479488 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
480 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
489 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
481490
482491 var array = [_]u8{ 'o', 'k' };
483492 const opt_array_ptr: ?[*]const u8 = &array;
......@@ -489,7 +498,7 @@ test "*const ?[*]const T to [*c]const [*c]const T" {
489498
490499test "array coercion to undefined at runtime" {
491500 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
492 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
501 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
493502
494503 @setRuntimeSafety(true);
495504
......@@ -516,6 +525,7 @@ fn implicitIntLitToOptional() void {
516525}
517526
518527test "return u8 coercing into ?u32 return type" {
528 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
519529 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
520530 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
521531
......@@ -537,6 +547,7 @@ test "cast from ?[*]T to ??[*]T" {
537547}
538548
539549test "peer type unsigned int to signed" {
550 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
540551 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
541552
542553 var w: u31 = 5;
......@@ -550,7 +561,7 @@ test "peer type unsigned int to signed" {
550561
551562test "expected [*c]const u8, found [*:0]const u8" {
552563 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
553 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
564 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
554565
555566 var a: [*:0]const u8 = "hello";
556567 _ = &a;
......@@ -562,7 +573,7 @@ test "expected [*c]const u8, found [*:0]const u8" {
562573test "explicit cast from integer to error type" {
563574 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
564575 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
565 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
576 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
566577 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
567578
568579 try testCastIntToErr(error.ItBroke);
......@@ -577,7 +588,7 @@ fn testCastIntToErr(err: anyerror) !void {
577588test "peer resolve array and const slice" {
578589 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
579590 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
580 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
591 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
581592
582593 try testPeerResolveArrayConstSlice(true);
583594 try comptime testPeerResolveArrayConstSlice(true);
......@@ -590,7 +601,7 @@ fn testPeerResolveArrayConstSlice(b: bool) !void {
590601}
591602
592603test "implicitly cast from T to anyerror!?T" {
593 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
604 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
594605 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
595606 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596607
......@@ -616,7 +627,7 @@ fn castToOptionalTypeError(z: i32) !void {
616627}
617628
618629test "implicitly cast from [0]T to anyerror![]T" {
619 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
630 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
620631 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
621632
622633 try testCastZeroArrayToErrSliceMut();
......@@ -634,7 +645,7 @@ fn gimmeErrOrSlice() anyerror![]u8 {
634645test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
635646 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
636647 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
637 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
648 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
638649
639650 const S = struct {
640651 fn doTheTest() anyerror!void {
......@@ -665,7 +676,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
665676
666677test "implicit cast from *const [N]T to []const T" {
667678 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
668 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
679 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
669680
670681 try testCastConstArrayRefToConstSlice();
671682 try comptime testCastConstArrayRefToConstSlice();
......@@ -690,7 +701,7 @@ fn testCastConstArrayRefToConstSlice() !void {
690701
691702test "peer type resolution: error and [N]T" {
692703 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
693 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
704 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
694705
695706 try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
696707 comptime assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
......@@ -714,7 +725,7 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
714725
715726test "single-item pointer of array to slice to unknown length pointer" {
716727 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
717 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
728 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
718729
719730 try testCastPtrOfArrayToSliceAndPtr();
720731 try comptime testCastPtrOfArrayToSliceAndPtr();
......@@ -743,7 +754,7 @@ fn testCastPtrOfArrayToSliceAndPtr() !void {
743754
744755test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
745756 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
746 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
757 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
747758
748759 const window_name = [1][*]const u8{"window name"};
749760 const x: [*]const ?[*]const u8 = &window_name;
......@@ -755,7 +766,7 @@ test "@intCast on vector" {
755766 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
756767 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
757768 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
758 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
769 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
759770 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
760771
761772 const S = struct {
......@@ -1027,7 +1038,7 @@ test "peer cast: error set any anyerror" {
10271038test "peer type resolution: error set supersets" {
10281039 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10291040 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1030 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1041 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10311042
10321043 const a: error{ One, Two } = undefined;
10331044 const b: error{One} = undefined;
......@@ -1056,7 +1067,7 @@ test "peer type resolution: error set supersets" {
10561067test "peer type resolution: disjoint error sets" {
10571068 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10581069 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1059 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1070 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10601071
10611072 const a: error{ One, Two } = undefined;
10621073 const b: error{Three} = undefined;
......@@ -1085,7 +1096,7 @@ test "peer type resolution: disjoint error sets" {
10851096test "peer type resolution: error union and error set" {
10861097 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10871098 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1088 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1099 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10891100
10901101 const a: error{Three} = undefined;
10911102 const b: error{ One, Two }!u32 = undefined;
......@@ -1118,7 +1129,7 @@ test "peer type resolution: error union and error set" {
11181129test "peer type resolution: error union after non-error" {
11191130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11201131 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1121 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1132 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11221133
11231134 const a: u32 = undefined;
11241135 const b: error{ One, Two }!u32 = undefined;
......@@ -1151,7 +1162,7 @@ test "peer type resolution: error union after non-error" {
11511162test "peer cast *[0]T to E![]const T" {
11521163 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11531164 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1154 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1165 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11551166
11561167 var buffer: [5]u8 = "abcde".*;
11571168 const buf: anyerror![]const u8 = buffer[0..];
......@@ -1166,7 +1177,7 @@ test "peer cast *[0]T to E![]const T" {
11661177test "peer cast *[0]T to []const T" {
11671178 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11681179 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1169 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1180 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11701181
11711182 var buffer: [5]u8 = "abcde".*;
11721183 const buf: []const u8 = buffer[0..];
......@@ -1177,6 +1188,7 @@ test "peer cast *[0]T to []const T" {
11771188}
11781189
11791190test "peer cast *[N]T to [*]T" {
1191 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11801192 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11811193
11821194 var array = [4:99]i32{ 1, 2, 3, 4 };
......@@ -1189,7 +1201,7 @@ test "peer cast *[N]T to [*]T" {
11891201test "peer resolution of string literals" {
11901202 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11911203 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1192 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1204 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11931205
11941206 const S = struct {
11951207 const E = enum { a, b, c, d };
......@@ -1210,7 +1222,7 @@ test "peer resolution of string literals" {
12101222
12111223test "peer cast [:x]T to []T" {
12121224 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1213 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1225 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12141226
12151227 const S = struct {
12161228 fn doTheTest() !void {
......@@ -1226,7 +1238,7 @@ test "peer cast [:x]T to []T" {
12261238
12271239test "peer cast [N:x]T to [N]T" {
12281240 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1229 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1241 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12301242
12311243 const S = struct {
12321244 fn doTheTest() !void {
......@@ -1242,7 +1254,7 @@ test "peer cast [N:x]T to [N]T" {
12421254
12431255test "peer cast *[N:x]T to *[N]T" {
12441256 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1245 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1257 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12461258
12471259 const S = struct {
12481260 fn doTheTest() !void {
......@@ -1258,7 +1270,7 @@ test "peer cast *[N:x]T to *[N]T" {
12581270test "peer cast [*:x]T to [*]T" {
12591271 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12601272 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1261 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1273 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12621274
12631275 const S = struct {
12641276 fn doTheTest() !void {
......@@ -1278,7 +1290,7 @@ test "peer cast [*:x]T to [*]T" {
12781290test "peer cast [:x]T to [*:x]T" {
12791291 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12801292 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1281 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1293 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12821294
12831295 const S = struct {
12841296 fn doTheTest() !void {
......@@ -1298,7 +1310,7 @@ test "peer cast [:x]T to [*:x]T" {
12981310
12991311test "peer type resolution implicit cast to return type" {
13001312 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1301 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1313 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13021314
13031315 const S = struct {
13041316 fn doTheTest() !void {
......@@ -1318,7 +1330,7 @@ test "peer type resolution implicit cast to return type" {
13181330
13191331test "peer type resolution implicit cast to variable type" {
13201332 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1321 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1333 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13221334
13231335 const S = struct {
13241336 fn doTheTest() !void {
......@@ -1343,7 +1355,7 @@ test "variable initialization uses result locations properly with regards to the
13431355
13441356test "cast between C pointer with different but compatible types" {
13451357 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1346 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1358 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13471359
13481360 const S = struct {
13491361 fn foo(arg: [*]c_ushort) u16 {
......@@ -1360,7 +1372,7 @@ test "cast between C pointer with different but compatible types" {
13601372
13611373test "peer type resolve string lit with sentinel-terminated mutable slice" {
13621374 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1363 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1375 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13641376
13651377 var array: [4:0]u8 = undefined;
13661378 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" {
13701382}
13711383
13721384test "peer type resolve array pointers, one of them const" {
1385 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1386
13731387 var array1: [4]u8 = undefined;
13741388 const array2: [5]u8 = undefined;
13751389 comptime assert(@TypeOf(&array1, &array2) == []const u8);
......@@ -1377,6 +1391,8 @@ test "peer type resolve array pointers, one of them const" {
13771391}
13781392
13791393test "peer type resolve array pointer and unknown pointer" {
1394 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1395
13801396 const const_array: [4]u8 = undefined;
13811397 var array: [4]u8 = undefined;
13821398 var const_ptr: [*]const u8 = undefined;
......@@ -1397,6 +1413,8 @@ test "peer type resolve array pointer and unknown pointer" {
13971413}
13981414
13991415test "comptime float casts" {
1416 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1417
14001418 const a = @as(comptime_float, @floatFromInt(1));
14011419 try expect(a == 1);
14021420 try expect(@TypeOf(a) == comptime_float);
......@@ -1431,7 +1449,7 @@ test "pointer reinterpret const float to int" {
14311449test "implicit cast from [*]T to ?*anyopaque" {
14321450 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14331451 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1434 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1452 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14351453
14361454 var a = [_]u8{ 3, 2, 1 };
14371455 var runtime_zero: usize = 0;
......@@ -1448,7 +1466,7 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
14481466}
14491467
14501468test "compile time int to ptr of function" {
1451 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1469 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14521470
14531471 try foobar(FUNCTION_CONSTANT);
14541472}
......@@ -1463,7 +1481,7 @@ fn foobar(func: PFN_void) !void {
14631481}
14641482
14651483test "cast function with an opaque parameter" {
1466 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1484 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14671485
14681486 const Container = struct {
14691487 const Ctx = opaque {};
......@@ -1490,7 +1508,7 @@ test "cast function with an opaque parameter" {
14901508test "implicit ptr to *anyopaque" {
14911509 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14921510 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1493 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1511 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14941512
14951513 var a: u32 = 1;
14961514 const ptr: *align(@alignOf(u32)) anyopaque = &a;
......@@ -1503,7 +1521,7 @@ test "implicit ptr to *anyopaque" {
15031521
15041522test "return null from fn () anyerror!?&T" {
15051523 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1506 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1524 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15071525
15081526 const a = returnNullFromOptionalTypeErrorRef();
15091527 const b = returnNullLitFromOptionalTypeErrorRef();
......@@ -1520,7 +1538,7 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
15201538test "peer type resolution: [0]u8 and []const u8" {
15211539 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15221540 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1523 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1541 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15241542
15251543 try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
15261544 try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
......@@ -1540,7 +1558,7 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
15401558test "implicitly cast from [N]T to ?[]const T" {
15411559 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15421560 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1543 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1561 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15441562
15451563 try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
15461564 comptime assert(mem.eql(u8, castToOptionalSlice().?, "hi"));
......@@ -1553,7 +1571,7 @@ fn castToOptionalSlice() ?[]const u8 {
15531571test "cast u128 to f128 and back" {
15541572 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15551573 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1556 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1574 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15571575 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
15581576
15591577 try comptime testCast128();
......@@ -1576,7 +1594,7 @@ test "implicit cast from *[N]T to ?[*]T" {
15761594 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15771595 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15781596 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1579 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1597 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15801598
15811599 var x: ?[*]u16 = null;
15821600 var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
......@@ -1591,7 +1609,7 @@ test "implicit cast from *[N]T to ?[*]T" {
15911609test "implicit cast from *T to ?*anyopaque" {
15921610 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15931611 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1594 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1612 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15951613
15961614 var a: u8 = 1;
15971615 incrementVoidPtrValue(&a);
......@@ -1603,7 +1621,7 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
16031621}
16041622
16051623test "implicit cast *[0]T to E![]const u8" {
1606 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1624 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16071625 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16081626
16091627 var x = @as(anyerror![]const u8, &[0]u8{});
......@@ -1613,13 +1631,13 @@ test "implicit cast *[0]T to E![]const u8" {
16131631
16141632var global_array: [4]u8 = undefined;
16151633test "cast from array reference to fn: comptime fn ptr" {
1616 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1634 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16171635
16181636 const f = @as(*align(1) const fn () callconv(.c) void, @ptrCast(&global_array));
16191637 try expect(@intFromPtr(f) == @intFromPtr(&global_array));
16201638}
16211639test "cast from array reference to fn: runtime fn ptr" {
1622 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1640 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16231641
16241642 var f = @as(*align(1) const fn () callconv(.c) void, @ptrCast(&global_array));
16251643 _ = &f;
......@@ -1629,7 +1647,7 @@ test "cast from array reference to fn: runtime fn ptr" {
16291647test "*const [N]null u8 to ?[]const u8" {
16301648 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16311649 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1632 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1650 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16331651
16341652 const S = struct {
16351653 fn doTheTest() !void {
......@@ -1646,7 +1664,7 @@ test "*const [N]null u8 to ?[]const u8" {
16461664test "comptime @ptrCast to optional slice" {
16471665 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16481666 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1649 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1667 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16501668
16511669 const result: ?[]const u8 = comptime blk: {
16521670 const slice: []const u8 = "123";
......@@ -1679,7 +1697,7 @@ var global_struct: struct { f0: usize } = undefined;
16791697test "assignment to optional pointer result loc" {
16801698 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16811699 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1682 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1700 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16831701
16841702 var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
16851703 _ = &foo;
......@@ -1687,7 +1705,7 @@ test "assignment to optional pointer result loc" {
16871705}
16881706
16891707test "cast between *[N]void and []void" {
1690 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1708 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16911709
16921710 var a: [4]void = undefined;
16931711 const b: []void = &a;
......@@ -1696,7 +1714,7 @@ test "cast between *[N]void and []void" {
16961714
16971715test "peer resolve arrays of different size to const slice" {
16981716 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1699 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1717 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17001718
17011719 try expect(mem.eql(u8, boolToStr(true), "true"));
17021720 try expect(mem.eql(u8, boolToStr(false), "false"));
......@@ -1710,7 +1728,7 @@ fn boolToStr(b: bool) []const u8 {
17101728test "cast f16 to wider types" {
17111729 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17121730 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1713 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1731 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17141732 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
17151733
17161734 const S = struct {
......@@ -1729,7 +1747,7 @@ test "cast f16 to wider types" {
17291747test "cast f128 to narrower types" {
17301748 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17311749 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1732 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1750 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17331751 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
17341752
17351753 const S = struct {
......@@ -1748,7 +1766,7 @@ test "cast f128 to narrower types" {
17481766test "peer type resolution: unreachable, null, slice" {
17491767 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17501768 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1751 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1769 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17521770
17531771 const S = struct {
17541772 fn doTheTest(num: usize, word: []const u8) !void {
......@@ -1787,7 +1805,7 @@ test "cast i8 fn call peers to i32 result" {
17871805test "cast compatible optional types" {
17881806 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17891807 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1790 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1808 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17911809
17921810 var a: ?[:0]const u8 = null;
17931811 _ = &a;
......@@ -1797,7 +1815,7 @@ test "cast compatible optional types" {
17971815
17981816test "coerce undefined single-item pointer of array to error union of slice" {
17991817 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1800 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1818 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18011819
18021820 const a = @as([*]u8, undefined)[0..0];
18031821 var b: error{a}![]const u8 = a;
......@@ -1807,7 +1825,7 @@ test "coerce undefined single-item pointer of array to error union of slice" {
18071825}
18081826
18091827test "pointer to empty struct literal to mutable slice" {
1810 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1828 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18111829 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18121830
18131831 var x: []i32 = &.{};
......@@ -1818,7 +1836,7 @@ test "pointer to empty struct literal to mutable slice" {
18181836test "coerce between pointers of compatible differently-named floats" {
18191837 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18201838 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1821 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1839 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18221840 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
18231841
18241842 const F = switch (@typeInfo(c_longdouble).float.bits) {
......@@ -1878,6 +1896,8 @@ test "cast typed undefined to int" {
18781896// }
18791897
18801898test "bitcast packed struct with u0" {
1899 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1900
18811901 const S = packed struct(u2) { a: u0, b: u2 };
18821902 const s = @as(S, @bitCast(@as(u2, 2)));
18831903 try expect(s.a == 0);
......@@ -1888,7 +1908,7 @@ test "bitcast packed struct with u0" {
18881908
18891909test "optional pointer coerced to optional allowzero pointer" {
18901910 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1891 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1911 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18921912
18931913 var p: ?*u32 = undefined;
18941914 var q: ?*allowzero u32 = undefined;
......@@ -1905,7 +1925,7 @@ test "optional slice coerced to allowzero many pointer" {
19051925}
19061926
19071927test "optional slice passed as parameter coerced to allowzero many pointer" {
1908 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1928 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19091929
19101930 const ns = struct {
19111931 const Color = struct {
......@@ -1926,7 +1946,7 @@ test "optional slice passed as parameter coerced to allowzero many pointer" {
19261946}
19271947
19281948test "single item pointer to pointer to array to slice" {
1929 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1949 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19301950
19311951 var x: i32 = 1234;
19321952 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" {
19361956
19371957test "peer type resolution forms error union" {
19381958 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1939 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1959 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19401960
19411961 var foo: i32 = 123;
19421962 _ = &foo;
......@@ -1971,7 +1991,7 @@ test "@volatileCast without a result location" {
19711991}
19721992
19731993test "coercion from single-item pointer to @as to slice" {
1974 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1994 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19751995
19761996 var x: u32 = 1;
19771997
......@@ -1984,7 +2004,7 @@ test "coercion from single-item pointer to @as to slice" {
19842004test "peer type resolution: const sentinel slice and mutable non-sentinel slice" {
19852005 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19862006 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1987 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2007 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19882008
19892009 const S = struct {
19902010 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"
20112031}
20122032
20132033test "peer type resolution: float and comptime-known fixed-width integer" {
2034 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
20142035 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20152036 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20162037
......@@ -2032,7 +2053,7 @@ test "peer type resolution: float and comptime-known fixed-width integer" {
20322053}
20332054
20342055test "peer type resolution: float and runtime-known fixed-width integer" {
2035 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2056 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
20362057 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20372058 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20382059
......@@ -2077,7 +2098,7 @@ test "peer type resolution: same array type with sentinel" {
20772098 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20782099 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20792100 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2080 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2101 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
20812102
20822103 var a: [2:0]u32 = .{ 0, 1 };
20832104 var b: [2:0]u32 = .{ 2, 3 };
......@@ -2099,7 +2120,7 @@ test "peer type resolution: same array type with sentinel" {
20992120test "peer type resolution: array with sentinel and array without sentinel" {
21002121 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21012122 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2102 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2123 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21032124
21042125 var a: [2:0]u32 = .{ 0, 1 };
21052126 var b: [2]u32 = .{ 2, 3 };
......@@ -2122,7 +2143,7 @@ test "peer type resolution: array and vector with same child type" {
21222143 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21232144 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21242145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2125 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2146 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21262147 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
21272148
21282149 var arr: [2]u32 = .{ 0, 1 };
......@@ -2143,7 +2164,7 @@ test "peer type resolution: array and vector with same child type" {
21432164}
21442165
21452166test "peer type resolution: array with smaller child type and vector with larger child type" {
2146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2167 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21472168 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21482169 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21492170 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" {
21702191 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21712192 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21722193 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2173 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2194 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21742195
21752196 const E = error{Foo};
21762197 var a: E!*u8 = error.Foo;
......@@ -2193,7 +2214,7 @@ test "peer type resolution: error union and optional of same type" {
21932214test "peer type resolution: C pointer and @TypeOf(null)" {
21942215 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21952216 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2196 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2217 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21972218
21982219 var a: [*c]c_int = 0x1000;
21992220 _ = &a;
......@@ -2215,7 +2236,7 @@ test "peer type resolution: C pointer and @TypeOf(null)" {
22152236test "peer type resolution: three-way resolution combines error set and optional" {
22162237 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22172238 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2218 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2239 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
22192240
22202241 const E = error{Foo};
22212242 var a: E = error.Foo;
......@@ -2258,7 +2279,7 @@ test "peer type resolution: vector and optional vector" {
22582279 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22592280 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22602281 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2261 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
2282 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
22622283 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
22632284
22642285 var a: ?@Vector(3, u32) = .{ 0, 1, 2 };
......@@ -2279,6 +2300,7 @@ test "peer type resolution: vector and optional vector" {
22792300}
22802301
22812302test "peer type resolution: optional fixed-width int and comptime_int" {
2303 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
22822304 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22832305 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
22842306
......@@ -2303,7 +2325,7 @@ test "peer type resolution: array and tuple" {
23032325 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23042326 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23052327 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2306 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2328 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23072329
23082330 var arr: [3]i32 = .{ 1, 2, 3 };
23092331 _ = &arr;
......@@ -2324,7 +2346,7 @@ test "peer type resolution: array and tuple" {
23242346}
23252347
23262348test "peer type resolution: vector and tuple" {
2327 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2349 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23282350 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23292351 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23302352 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -2351,7 +2373,7 @@ test "peer type resolution: vector and array and tuple" {
23512373 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23522374 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23532375 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2354 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2376 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23552377
23562378 var vec: @Vector(2, i8) = .{ 10, 20 };
23572379 var arr: [2]i8 = .{ 30, 40 };
......@@ -2393,7 +2415,7 @@ test "peer type resolution: vector and array and tuple" {
23932415test "peer type resolution: empty tuple pointer and slice" {
23942416 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23952417 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2396 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2418 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23972419
23982420 var a: [:0]const u8 = "Hello";
23992421 var b = &.{};
......@@ -2414,7 +2436,7 @@ test "peer type resolution: empty tuple pointer and slice" {
24142436test "peer type resolution: tuple pointer and slice" {
24152437 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24162438 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2417 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2439 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
24182440
24192441 var a: [:0]const u8 = "Hello";
24202442 var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
......@@ -2436,7 +2458,7 @@ test "peer type resolution: tuple pointer and optional slice" {
24362458 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24372459 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24382460 // Miscompilation on Intel's OpenCL CPU runtime.
2439 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
2461 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // flaky
24402462
24412463 var a: ?[:0]const u8 = null;
24422464 var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
......@@ -2457,7 +2479,7 @@ test "peer type resolution: tuple pointer and optional slice" {
24572479test "peer type resolution: many compatible pointers" {
24582480 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24592481 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2460 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2482 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
24612483
24622484 var buf = "foo-3".*;
24632485
......@@ -2521,6 +2543,7 @@ test "peer type resolution: many compatible pointers" {
25212543}
25222544
25232545test "peer type resolution: tuples with comptime fields" {
2546 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
25242547 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25252548 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25262549
......@@ -2553,7 +2576,7 @@ test "peer type resolution: tuples with comptime fields" {
25532576test "peer type resolution: C pointer and many pointer" {
25542577 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25552578 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2556 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2579 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
25572580
25582581 var buf = "hello".*;
25592582
......@@ -2576,7 +2599,7 @@ test "peer type resolution: C pointer and many pointer" {
25762599test "peer type resolution: pointer attributes are combined correctly" {
25772600 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25782601 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2579 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2602 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
25802603
25812604 var buf_a align(4) = "foo".*;
25822605 var buf_b align(4) = "bar".*;
......@@ -2663,7 +2686,7 @@ test "peer type resolution: arrays of compatible types" {
26632686 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
26642687 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26652688 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2666 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2689 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
26672690
26682691 var e0: u8 = 3;
26692692 var e1: u8 = 2;
......@@ -2680,7 +2703,7 @@ test "peer type resolution: arrays of compatible types" {
26802703test "cast builtins can wrap result in optional" {
26812704 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26822705 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2683 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2706 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
26842707
26852708 const S = struct {
26862709 const MyEnum = enum(u32) { _ };
......@@ -2715,7 +2738,7 @@ test "cast builtins can wrap result in optional" {
27152738}
27162739
27172740test "cast builtins can wrap result in error union" {
2718 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2741 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
27192742 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
27202743 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27212744
......@@ -2755,7 +2778,7 @@ test "cast builtins can wrap result in error union" {
27552778test "cast builtins can wrap result in error union and optional" {
27562779 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
27572780 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2758 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2781 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
27592782
27602783 const S = struct {
27612784 const MyEnum = enum(u32) { _ };
......@@ -2791,7 +2814,7 @@ test "cast builtins can wrap result in error union and optional" {
27912814}
27922815
27932816test "@floatCast on vector" {
2794 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2817 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
27952818 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
27962819 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
27972820 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -2836,7 +2859,7 @@ test "@ptrFromInt on vector" {
28362859 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28372860 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
28382861 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2839 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2862 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
28402863
28412864 const S = struct {
28422865 fn doTheTest() !void {
......@@ -2860,7 +2883,7 @@ test "@intFromPtr on vector" {
28602883 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28612884 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
28622885 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2863 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2886 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
28642887
28652888 const S = struct {
28662889 fn doTheTest() !void {
......@@ -2880,7 +2903,7 @@ test "@intFromPtr on vector" {
28802903}
28812904
28822905test "@floatFromInt on vector" {
2883 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2906 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
28842907 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
28852908 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28862909 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -2900,7 +2923,7 @@ test "@floatFromInt on vector" {
29002923}
29012924
29022925test "@intFromFloat on vector" {
2903 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2926 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
29042927 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29052928 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29062929 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -2920,6 +2943,7 @@ test "@intFromFloat on vector" {
29202943}
29212944
29222945test "@floatFromInt and @intFromFloat on vectors of any length" {
2946 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
29232947 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29242948 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29252949 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -2950,7 +2974,7 @@ test "@floatFromInt and @intFromFloat on vectors of any length" {
29502974}
29512975
29522976test "@intFromBool on vector" {
2953 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2977 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
29542978 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29552979 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29562980 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -2970,6 +2994,8 @@ test "@intFromBool on vector" {
29702994}
29712995
29722996test "numeric coercions with undefined" {
2997 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2998
29732999 const from: i32 = undefined;
29743000 var to: f32 = from;
29753001 to = @floatFromInt(from);
......@@ -2987,6 +3013,7 @@ test "15-bit int to float" {
29873013}
29883014
29893015test "@as does not corrupt values with incompatible representations" {
3016 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
29903017 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29913018 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
29923019
......@@ -3003,7 +3030,7 @@ test "@as does not corrupt values with incompatible representations" {
30033030test "result information is preserved through many nested structures" {
30043031 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
30053032 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3006 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
3033 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
30073034
30083035 const S = struct {
30093036 fn doTheTest() !void {
......@@ -3025,6 +3052,7 @@ test "result information is preserved through many nested structures" {
30253052}
30263053
30273054test "@intCast vector of signed integer" {
3055 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
30283056 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30293057 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
30303058 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -3047,6 +3075,7 @@ test "result type is preserved into comptime block" {
30473075}
30483076
30493077test "bitcast vector" {
3078 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
30503079 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
30513080
30523081 const u8x32 = @Vector(32, u8);
......@@ -3058,7 +3087,7 @@ test "bitcast vector" {
30583087}
30593088
30603089test "peer type resolution: slice of sentinel-terminated array" {
3061 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
3090 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
30623091
30633092 var f: bool = undefined;
30643093 f = false;
......@@ -3077,6 +3106,7 @@ test "peer type resolution: slice of sentinel-terminated array" {
30773106
30783107test "@intFromFloat boundary cases" {
30793108 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3109 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
30803110
30813111 const S = struct {
30823112 fn case(comptime I: type, x: f32, bump: enum { up, down }, expected: I) !void {
......@@ -3107,6 +3137,7 @@ test "@intFromFloat boundary cases" {
31073137}
31083138
31093139test "@intFromFloat vector boundary cases" {
3140 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
31103141 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
31113142 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
31123143
......@@ -3135,6 +3166,7 @@ test "@intFromFloat vector boundary cases" {
31353166}
31363167
31373168test "coerce enum to union with zero-bit fields through local variables" {
3169 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
31383170 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
31393171
31403172 const E = enum(u1) { foo, bar };
test/behavior/cast_int.zig+5-2
......@@ -6,6 +6,7 @@ const maxInt = std.math.maxInt;
66const minInt = std.math.minInt;
77
88test "@intCast i32 to u7" {
9 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
910 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1011 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1112 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -33,6 +34,7 @@ test "coerce i8 to i32 and @intCast back" {
3334}
3435
3536test "coerce non byte-sized integers accross 32bits boundary" {
37 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3638 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
3739
3840 {
......@@ -143,7 +145,8 @@ fn testIntCast(comptime S: type, a: S, comptime D: type, expected: D) !void {
143145
144146test "@intCast <= 64 bits" {
145147 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
148 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
149
147150 try testIntCast(i32, minInt(i32), i64, minInt(i32));
148151 try testIntCast(i32, maxInt(i32), i64, maxInt(i32));
149152 try testIntCast(u32, maxInt(u32), u64, maxInt(u32));
......@@ -168,7 +171,7 @@ test "@intCast <= 64 bits" {
168171
169172test "@intCast > 128 bits" {
170173 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
171 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
174 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
172175
173176 try testIntCast(u8, 123, u140, 123);
174177 try testIntCast(u64, 1 << 63, u140, 1 << 63);
test/behavior/comptime_memory.zig+7-2
......@@ -415,6 +415,8 @@ test "dereference undefined pointer to zero-bit type" {
415415}
416416
417417test "type pun extern struct" {
418 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
419
418420 const S = extern struct { f: u8 };
419421 comptime var s = S{ .f = 123 };
420422 @as(*u8, @ptrCast(&s)).* = 72;
......@@ -434,7 +436,7 @@ test "type pun null pointer-like optional" {
434436}
435437
436438test "write empty array to end" {
437 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
439 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
438440
439441 comptime var array: [5]u8 = "hello".*;
440442 array[5..5].* = .{};
......@@ -514,7 +516,8 @@ fn fieldPtrTest() u32 {
514516 return a.value;
515517}
516518test "pointer in aggregate field can mutate comptime state" {
517 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
519 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
520
518521 try comptime std.testing.expect(fieldPtrTest() == 2);
519522}
520523
......@@ -598,6 +601,8 @@ test "reinterpret sentinel-terminated array as packed struct" {
598601}
599602
600603test "reinterpret pointer as optional pointer via double-pointer coercion" {
604 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
605
601606 const p0: *const *anyopaque = &@ptrFromInt(0x1000);
602607 const p1: *const ?*anyopaque = p0;
603608
test/behavior/const_slice_child.zig+1-1
......@@ -10,7 +10,7 @@ test "const slice child" {
1010 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1111 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1212 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1414
1515 const strs = [_][*]const u8{ "one", "two", "three" };
1616 argv = &strs;
test/behavior/decl_literals.zig+4-2
......@@ -33,6 +33,7 @@ test "decl literal with pointer" {
3333}
3434
3535test "call decl literal with optional" {
36 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3637 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
3738 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3839
......@@ -48,7 +49,7 @@ test "call decl literal with optional" {
4849}
4950
5051test "call decl literal with pointer" {
51 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
52 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5253
5354 const S = struct {
5455 x: u32,
......@@ -62,6 +63,7 @@ test "call decl literal with pointer" {
6263}
6364
6465test "call decl literal" {
66 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
6567 const S = struct {
6668 x: u32,
6769 fn init() @This() {
......@@ -74,7 +76,7 @@ test "call decl literal" {
7476}
7577
7678test "call decl literal with error union" {
77 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
79 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
7880
7981 const S = struct {
8082 x: u32,
test/behavior/defer.zig+7-2
......@@ -5,6 +5,8 @@ const expectEqual = std.testing.expectEqual;
55const expectError = std.testing.expectError;
66
77test "break and continue inside loop inside defer expression" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9
810 testBreakContInDefer(10);
911 comptime testBreakContInDefer(10);
1012}
......@@ -32,6 +34,7 @@ test "defer and labeled break" {
3234}
3335
3436test "errdefer does not apply to fn inside fn" {
37 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3538 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3639
3740 if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad);
......@@ -49,6 +52,7 @@ fn testNestedFnErrDefer() anyerror!void {
4952}
5053
5154test "return variable while defer expression in scope to modify it" {
55 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
5256 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5357 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5458
......@@ -89,7 +93,7 @@ fn runSomeErrorDefers(x: bool) !bool {
8993}
9094
9195test "mixing normal and error defers" {
92 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
96 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9397 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9498 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9599
......@@ -109,7 +113,8 @@ test "mixing normal and error defers" {
109113
110114test "simple else prong doesn't emit an error for unreachable else prong" {
111115 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
112 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
116 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
117
113118 const S = struct {
114119 fn foo() error{Foo}!void {
115120 return error.Foo;
test/behavior/destructure.zig+14
......@@ -4,6 +4,8 @@ const assert = std.debug.assert;
44const expect = std.testing.expect;
55
66test "simple destructure" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
8
79 const S = struct {
810 fn doTheTest() !void {
911 var x: u32 = undefined;
......@@ -23,6 +25,8 @@ test "simple destructure" {
2325}
2426
2527test "destructure with comptime syntax" {
28 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
29
2630 const S = struct {
2731 fn doTheTest() !void {
2832 {
......@@ -78,6 +82,8 @@ test "destructure with comptime syntax" {
7882}
7983
8084test "destructure from labeled block" {
85 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
86
8187 const S = struct {
8288 fn doTheTest(rt_true: bool) !void {
8389 const x: u32, const y: u8, const z: i64 = blk: {
......@@ -96,6 +102,8 @@ test "destructure from labeled block" {
96102}
97103
98104test "destructure tuple value" {
105 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
106
99107 const tup: struct { f32, u32, i64 } = .{ 10.0, 20, 30 };
100108 const x, const y, const z = tup;
101109
......@@ -109,6 +117,8 @@ test "destructure tuple value" {
109117}
110118
111119test "destructure array value" {
120 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
121
112122 const arr: [3]u32 = .{ 10, 20, 30 };
113123 const x, const y, const z = arr;
114124
......@@ -122,6 +132,8 @@ test "destructure array value" {
122132}
123133
124134test "destructure from struct init with named tuple fields" {
135 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
136
125137 const Tuple = struct { u8, u16, u32 };
126138 const x, const y, const z = Tuple{
127139 .@"0" = 100,
......@@ -149,6 +161,8 @@ test "destructure of comptime-known tuple is comptime-known" {
149161}
150162
151163test "destructure of comptime-known tuple where some destinations are runtime-known is comptime-known" {
164 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
165
152166 var z: u32 = undefined;
153167 var x: u8, const y, z = .{ 1, 2, 3 };
154168 _ = &x;
test/behavior/enum.zig+32-13
......@@ -12,6 +12,8 @@ fn shouldEqual(n: Number, expected: u3) !void {
1212}
1313
1414test "enum to int" {
15 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
16
1517 try shouldEqual(Number.Zero, 0);
1618 try shouldEqual(Number.One, 1);
1719 try shouldEqual(Number.Two, 2);
......@@ -614,6 +616,7 @@ test "enum with specified tag values" {
614616}
615617
616618test "non-exhaustive enum" {
619 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
617620 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
618621
619622 const S = struct {
......@@ -657,6 +660,8 @@ test "non-exhaustive enum" {
657660}
658661
659662test "empty non-exhaustive enum" {
663 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
664
660665 const S = struct {
661666 const E = enum(u8) { _ };
662667
......@@ -678,6 +683,7 @@ test "empty non-exhaustive enum" {
678683}
679684
680685test "single field non-exhaustive enum" {
686 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
681687 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
682688
683689 const S = struct {
......@@ -796,6 +802,8 @@ test "enum with 1 field but explicit tag type should still have the tag type" {
796802}
797803
798804test "signed integer as enum tag" {
805 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
806
799807 const SignedEnum = enum(i2) {
800808 A0 = -1,
801809 A1 = 0,
......@@ -880,6 +888,8 @@ test "method call on an enum" {
880888}
881889
882890test "enum value allocation" {
891 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
892
883893 const LargeEnum = enum(u32) {
884894 A0 = 0x80000000,
885895 A1,
......@@ -892,6 +902,7 @@ test "enum value allocation" {
892902}
893903
894904test "enum literal casting to tagged union" {
905 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
895906 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
896907 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
897908
......@@ -918,6 +929,7 @@ test "enum literal casting to tagged union" {
918929const Bar = enum { A, B, C, D };
919930
920931test "enum literal casting to error union with payload enum" {
932 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
921933 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
922934
923935 var bar: error{B}!Bar = undefined;
......@@ -927,6 +939,7 @@ test "enum literal casting to error union with payload enum" {
927939}
928940
929941test "constant enum initialization with differing sizes" {
942 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
930943 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
931944 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
932945 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -972,7 +985,7 @@ test "@tagName" {
972985 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
973986 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
974987 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
975 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
988 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
976989
977990 try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
978991 comptime assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
......@@ -988,7 +1001,7 @@ test "@tagName non-exhaustive enum" {
9881001 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9891002 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9901003 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
991 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1004 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9921005 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9931006
9941007 try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
......@@ -1000,7 +1013,7 @@ test "@tagName is null-terminated" {
10001013 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10011014 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10021015 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1003 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1016 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10041017 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10051018
10061019 const S = struct {
......@@ -1016,7 +1029,7 @@ test "tag name with assigned enum values" {
10161029 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10171030 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10181031 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1019 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1032 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10201033 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10211034
10221035 const LocalFoo = enum(u8) {
......@@ -1030,7 +1043,7 @@ test "tag name with assigned enum values" {
10301043
10311044test "@tagName on enum literals" {
10321045 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1033 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1046 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10341047
10351048 try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
10361049 comptime assert(mem.eql(u8, @tagName(.FooBar), "FooBar"));
......@@ -1040,7 +1053,7 @@ test "tag name with signed enum values" {
10401053 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10411054 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10421055 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1043 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1056 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10441057 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10451058
10461059 const LocalFoo = enum(isize) {
......@@ -1057,7 +1070,7 @@ test "tag name with signed enum values" {
10571070test "tag name with large enum values" {
10581071 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10591072 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1060 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1073 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10611074
10621075 const Kdf = enum(u128) {
10631076 aes_kdf = 0xea4f8ac1080d74bf60448a629af3d9c9,
......@@ -1077,7 +1090,7 @@ test "tag name with large enum values" {
10771090test "@tagName with exotic integer enum types" {
10781091 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10791092 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1080 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1093 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10811094
10821095 const S = struct {
10831096 fn testEnumSigned(comptime T: type) !void {
......@@ -1177,7 +1190,7 @@ test "@tagName in callconv(.c) function" {
11771190 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11781191 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11791192 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1180 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1193 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11811194 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11821195
11831196 try expect(mem.orderZ(u8, testEnumTagNameCallconvC(), "Two") == .eq);
......@@ -1191,6 +1204,7 @@ fn testEnumTagNameCallconvC() callconv(.c) [*:0]const u8 {
11911204}
11921205
11931206test "enum literal casting to optional" {
1207 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11941208 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11951209 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11961210
......@@ -1217,6 +1231,7 @@ const bit_field_1 = BitFieldOfEnums{
12171231};
12181232
12191233test "bit field access with enum fields" {
1234 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12201235 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12211236 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
12221237 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1260,7 +1275,7 @@ test "tag name functions are unique" {
12601275 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12611276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
12621277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1263 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1278 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12641279 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12651280
12661281 {
......@@ -1279,7 +1294,7 @@ test "tag name functions are unique" {
12791294
12801295test "size of enum with only one tag which has explicit integer tag type" {
12811296 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1282 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1297 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12831298
12841299 const E = enum(u8) { nope = 10 };
12851300 const S0 = struct { e: E };
......@@ -1314,7 +1329,7 @@ test "switch on an extern enum with negative value" {
13141329}
13151330
13161331test "switch on an enum with small signed tag type" {
1317 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1332 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13181333
13191334 const E = enum(i3) {
13201335 y = -2,
......@@ -1358,7 +1373,7 @@ test "enum tag from a local variable" {
13581373}
13591374
13601375test "auto-numbered enum with signed tag type" {
1361 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1376 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13621377
13631378 const E = enum(i32) { a, b };
13641379
......@@ -1375,6 +1390,7 @@ test "auto-numbered enum with signed tag type" {
13751390}
13761391
13771392test "lazy initialized field" {
1393 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13781394 try std.testing.expectEqual(@as(u8, @alignOf(struct {})), getLazyInitialized(.a));
13791395}
13801396
......@@ -1403,6 +1419,7 @@ test "matching captures causes enum equivalence" {
14031419}
14041420
14051421test "large enum field values" {
1422 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14061423 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
14071424
14081425 {
......@@ -1451,6 +1468,8 @@ test "comptime @enumFromInt with signed arithmetic" {
14511468}
14521469
14531470test "enum int tag type uses declaration inside the enum" {
1471 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1472
14541473 const static = struct {
14551474 const E = enum(E.IntTag) {
14561475 const IntTag = u8;
test/behavior/error.zig+54-15
......@@ -30,6 +30,7 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
3030}
3131
3232test "error binary operator" {
33 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3334 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3435
3536 const a = errBinaryOperatorG(true) catch 3;
......@@ -61,12 +62,14 @@ pub fn baz() anyerror!i32 {
6162}
6263
6364test "error wrapping" {
65 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
6466 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6567
6668 try expect((baz() catch unreachable) == 15);
6769}
6870
6971test "unwrap simple value from error" {
72 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7073 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7174
7275 const i = unwrapSimpleValueFromErrorDo() catch unreachable;
......@@ -77,6 +80,7 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
7780}
7881
7982test "error return in assignment" {
83 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
8084 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8185
8286 doErrReturnInAssignment() catch unreachable;
......@@ -98,6 +102,7 @@ test "syntax: optional operator in front of error union operator" {
98102}
99103
100104test "widen cast integer payload of error union function call" {
105 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
101106 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
102107 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
103108
......@@ -124,7 +129,7 @@ test "debug info for optional error set" {
124129
125130test "implicit cast to optional to error union to return result loc" {
126131 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
132 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
128133
129134 const S = struct {
130135 fn entry() !void {
......@@ -145,12 +150,14 @@ test "implicit cast to optional to error union to return result loc" {
145150}
146151
147152test "fn returning empty error set can be passed as fn returning any error" {
153 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
154
148155 entry();
149156 comptime entry();
150157}
151158
152159test "fn returning empty error set can be passed as fn returning any error - pointer" {
153 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
160 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
154161
155162 entryPtr();
156163 comptime entryPtr();
......@@ -182,6 +189,8 @@ fn fooPtr(f: *const fn () anyerror!void) void {
182189fn bar2() (error{}!void) {}
183190
184191test "error union type " {
192 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
193
185194 try testErrorUnionType();
186195 try comptime testErrorUnionType();
187196}
......@@ -195,6 +204,8 @@ fn testErrorUnionType() !void {
195204}
196205
197206test "error set type" {
207 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
208
198209 try testErrorSetType();
199210 try comptime testErrorSetType();
200211}
......@@ -218,6 +229,7 @@ fn testErrorSetType() !void {
218229}
219230
220231test "explicit error set cast" {
232 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
221233 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222234
223235 try testExplicitErrorSetCast(Set1.A);
......@@ -236,6 +248,7 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
236248}
237249
238250test "@errorCast on error unions" {
251 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
239252 const S = struct {
240253 fn doTheTest() !void {
241254 {
......@@ -262,6 +275,7 @@ test "@errorCast on error unions" {
262275}
263276
264277test "comptime test error for empty error set" {
278 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
265279 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
266280
267281 try testComptimeTestErrorEmptySet(1234);
......@@ -298,6 +312,8 @@ test "inferred empty error set comptime catch" {
298312}
299313
300314test "error inference with an empty set" {
315 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
316
301317 const S = struct {
302318 const Struct = struct {
303319 pub fn func() (error{})!usize {
......@@ -319,6 +335,7 @@ test "error inference with an empty set" {
319335}
320336
321337test "error union peer type resolution" {
338 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
322339 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
323340
324341 try testErrorUnionPeerTypeResolution(1);
......@@ -350,6 +367,7 @@ fn quux_1() !i32 {
350367}
351368
352369test "error: Zero sized error set returned with value payload crash" {
370 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
353371 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
354372
355373 _ = try foo3(0);
......@@ -363,7 +381,7 @@ fn foo3(b: usize) Error!usize {
363381
364382test "error: Infer error set from literals" {
365383 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
366 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
384 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
367385
368386 _ = nullLiteral("n") catch |err| handleErrors(err);
369387 _ = floatLiteral("n") catch |err| handleErrors(err);
......@@ -400,6 +418,7 @@ fn intLiteral(str: []const u8) !?i64 {
400418}
401419
402420test "nested error union function call in optional unwrap" {
421 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
403422 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
404423 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
405424
......@@ -446,6 +465,7 @@ test "nested error union function call in optional unwrap" {
446465}
447466
448467test "return function call to error set from error union function" {
468 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
449469 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
450470
451471 const S = struct {
......@@ -477,6 +497,7 @@ test "optional error set is the same size as error set" {
477497}
478498
479499test "nested catch" {
500 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
480501 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
481502
482503 const S = struct {
......@@ -502,7 +523,7 @@ test "nested catch" {
502523
503524test "function pointer with return type that is error union with payload which is pointer of parent struct" {
504525 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
505 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
526 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
506527
507528 const S = struct {
508529 const Foo = struct {
......@@ -524,6 +545,7 @@ test "function pointer with return type that is error union with payload which i
524545}
525546
526547test "return result loc as peer result loc in inferred error set function" {
548 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
527549 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
528550 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
529551 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" {
555577}
556578
557579test "error payload type is correctly resolved" {
580 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
558581 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
559582 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
560583
......@@ -585,7 +608,7 @@ test "error union comptime caching" {
585608test "@errorName" {
586609 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
587610 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
588 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
611 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
589612 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
590613
591614 try expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
......@@ -599,7 +622,7 @@ fn gimmeItBroke() anyerror {
599622test "@errorName sentinel length matches slice length" {
600623 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
601624 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
602 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
625 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
603626 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
604627
605628 const name = testBuiltinErrorName(error.FooBar);
......@@ -613,6 +636,8 @@ pub fn testBuiltinErrorName(err: anyerror) [:0]const u8 {
613636}
614637
615638test "error set equality" {
639 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
640
616641 const a = error{One};
617642 const b = error{One};
618643
......@@ -628,6 +653,7 @@ test "error set equality" {
628653}
629654
630655test "inferred error set equality" {
656 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
631657 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
632658
633659 const S = struct {
......@@ -691,6 +717,7 @@ test "coerce error set to the current inferred error set" {
691717}
692718
693719test "error union payload is properly aligned" {
720 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
694721 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
695722 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
696723 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" {
723750}
724751
725752test "simple else prong allowed even when all errors handled" {
753 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
726754 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
727755
728756 const S = struct {
......@@ -750,7 +778,7 @@ test "simple else prong allowed even when all errors handled" {
750778test "pointer to error union payload" {
751779 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
752780 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
753 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
781 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
754782 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
755783
756784 var err_union: anyerror!u8 = 15;
......@@ -781,7 +809,7 @@ const NoReturn = struct {
781809};
782810
783811test "error union of noreturn used with if" {
784 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
812 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
785813 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
786814 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
787815 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -795,7 +823,7 @@ test "error union of noreturn used with if" {
795823}
796824
797825test "error union of noreturn used with try" {
798 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
826 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
799827 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
800828 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
801829 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -806,7 +834,7 @@ test "error union of noreturn used with try" {
806834}
807835
808836test "error union of noreturn used with catch" {
809 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
837 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
810838 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
811839 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
812840 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -819,7 +847,7 @@ test "error union of noreturn used with catch" {
819847test "alignment of wrapping an error union payload" {
820848 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
821849 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
822 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
850 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
823851 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
824852
825853 const S = struct {
......@@ -835,6 +863,7 @@ test "alignment of wrapping an error union payload" {
835863}
836864
837865test "compare error union and error set" {
866 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
838867 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
839868
840869 var a: anyerror = error.Foo;
......@@ -872,7 +901,7 @@ test "catch within a function that calls no errorable functions" {
872901test "error from comptime string" {
873902 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
874903 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
875 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
904 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
876905 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
877906
878907 const name = "Weird error name!";
......@@ -887,6 +916,8 @@ test "error from comptime string" {
887916}
888917
889918test "field access of anyerror results in smaller error set" {
919 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
920
890921 const E1 = @TypeOf(error.Foo);
891922 try expect(@TypeOf(E1.Foo) == E1);
892923 const E2 = error{ A, B, C };
......@@ -895,6 +926,7 @@ test "field access of anyerror results in smaller error set" {
895926}
896927
897928test "optional error union return type" {
929 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
898930 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
899931
900932 const S = struct {
......@@ -933,7 +965,7 @@ test "optional error set function parameter" {
933965
934966test "returning an error union containing a type with no runtime bits" {
935967 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
936 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
968 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
937969
938970 const ZeroByteType = struct {
939971 foo: void,
......@@ -949,7 +981,7 @@ test "returning an error union containing a type with no runtime bits" {
949981
950982test "try used in recursive function with inferred error set" {
951983 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
952 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
984 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
953985
954986 const Value = union(enum) {
955987 values: []const @This(),
......@@ -1010,6 +1042,7 @@ test "function called at runtime is properly analyzed for inferred error set" {
10101042}
10111043
10121044test "errorCast to adhoc inferred error set" {
1045 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10131046 const S = struct {
10141047 inline fn baz() !i32 {
10151048 return @errorCast(err());
......@@ -1022,6 +1055,7 @@ test "errorCast to adhoc inferred error set" {
10221055}
10231056
10241057test "@errorCast from error set to error union" {
1058 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10251059 const S = struct {
10261060 fn doTheTest(set: error{ A, B }) error{A}!i32 {
10271061 return @errorCast(set);
......@@ -1032,6 +1066,7 @@ test "@errorCast from error set to error union" {
10321066}
10331067
10341068test "@errorCast from error union to error union" {
1069 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10351070 const S = struct {
10361071 fn doTheTest(set: error{ A, B }!i32) error{A}!i32 {
10371072 return @errorCast(set);
......@@ -1045,7 +1080,7 @@ test "result location initialization of error union with OPV payload" {
10451080 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10461081 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10471082 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1048 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1083 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10491084 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
10501085
10511086 const S = struct {
......@@ -1067,6 +1102,7 @@ test "result location initialization of error union with OPV payload" {
10671102}
10681103
10691104test "return error union with i65" {
1105 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10701106 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10711107
10721108 try expect(try add(1000, 234) == 1234);
......@@ -1077,6 +1113,7 @@ fn add(x: i65, y: i65) anyerror!i65 {
10771113}
10781114
10791115test "compare error union to error set" {
1116 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10801117 const S = struct {
10811118 fn doTheTest(val: error{Foo}!i32) !void {
10821119 if (error.Foo == val) return error.Unexpected;
......@@ -1107,6 +1144,7 @@ test "'if' ignores error via local while 'else' ignores error directly" {
11071144}
11081145
11091146test "@errorCast into own inferred error set" {
1147 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11101148 const static = struct {
11111149 fn foo(b: bool) !void {
11121150 if (b) {
......@@ -1140,6 +1178,7 @@ test "@errorCast into other inferred error set" {
11401178}
11411179
11421180test "error union with vector type" {
1181 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11431182 var x: anyerror!@Vector(5, f64) = undefined;
11441183 x = error.Expected;
11451184 try expect(x == error.Expected);
test/behavior/eval.zig+49-21
......@@ -5,7 +5,7 @@ const expect = std.testing.expect;
55const expectEqual = std.testing.expectEqual;
66
77test "compile time recursion" {
8 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
8 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
99
1010 try expect(some_data.len == 21);
1111}
......@@ -72,6 +72,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
7272}
7373
7474test "constant expressions" {
75 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7576 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7677
7778 var array: [array_size]u8 = undefined;
......@@ -93,6 +94,7 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {
9394 return max(bool, a, b);
9495}
9596test "inlined block and runtime block phi" {
97 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9698 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9799
98100 try expect(letsTryToCompareBools(true, true));
......@@ -141,7 +143,7 @@ test "pointer to type" {
141143test "a type constructed in a global expression" {
142144 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
143145 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
144 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
146 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
145147
146148 var l: List = undefined;
147149 l.array[0] = 10;
......@@ -234,6 +236,7 @@ const vertices = [_]Vertex{
234236};
235237
236238test "statically initialized list" {
239 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
237240 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
238241
239242 try expect(static_point_list[0].x == 1);
......@@ -303,6 +306,7 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
303306}
304307
305308test "comptime iterate over fn ptr list" {
309 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
306310 try expect(performFn('t', 1) == 6);
307311 try expect(performFn('o', 0) == 1);
308312 try expect(performFn('w', 99) == 99);
......@@ -339,6 +343,7 @@ fn doesAlotT(comptime T: type, value: usize) T {
339343}
340344
341345test "@setEvalBranchQuota at same scope as generic function call" {
346 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
342347 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
343348
344349 try expect(doesAlotT(u32, 2) == 2);
......@@ -390,7 +395,7 @@ test "return 0 from function that has u0 return type" {
390395}
391396
392397test "statically initialized struct" {
393 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
398 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
394399 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
395400
396401 st_init_str_foo.x += 1;
......@@ -406,6 +411,7 @@ var st_init_str_foo = StInitStrFoo{
406411};
407412
408413test "inline for with same type but different values" {
414 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
409415 var res: usize = 0;
410416 inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
411417 var a: T = undefined;
......@@ -441,7 +447,7 @@ fn copyWithPartialInline(s: []u32, b: []u8) void {
441447test "binary math operator in partially inlined function" {
442448 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
443449 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
444 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
450 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
445451
446452 var s: [4]u32 = undefined;
447453 var b: [16]u8 = undefined;
......@@ -484,6 +490,7 @@ test "comptime bitwise operators" {
484490}
485491
486492test "comptime shlWithOverflow" {
493 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
487494 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
488495 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
489496 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -498,7 +505,7 @@ test "comptime shlWithOverflow" {
498505
499506test "const ptr to variable data changes at runtime" {
500507 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
508 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
502509
503510 try expect(foo_ref.name[0] == 'a');
504511 foo_ref.name = "b";
......@@ -515,7 +522,7 @@ const foo_ref = &foo_contents;
515522test "runtime 128 bit integer division" {
516523 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
517524 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
518 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
525 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
519526 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
520527
521528 var a: u128 = 152313999999999991610955792383;
......@@ -527,13 +534,14 @@ test "runtime 128 bit integer division" {
527534
528535test "@tagName of @typeInfo" {
529536 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
530 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
537 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
531538
532539 const str = @tagName(@typeInfo(u8));
533540 try expect(std.mem.eql(u8, str, "int"));
534541}
535542
536543test "static eval list init" {
544 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
537545 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
538546 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
539547
......@@ -551,6 +559,7 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
551559}
552560
553561test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
562 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
554563 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
555564
556565 var runtime = [1]i32{3};
......@@ -603,7 +612,7 @@ const hi1 = "hi";
603612const hi2 = hi1;
604613test "const global shares pointer with other same one" {
605614 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
606 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
615 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
607616
608617 try assertEqualPtrs(&hi1[0], &hi2[0]);
609618 comptime assert(&hi1[0] == &hi2[0]);
......@@ -722,7 +731,7 @@ fn testVarInsideInlineLoop(args: anytype) !void {
722731test "array concatenation of function calls" {
723732 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
724733 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
725 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
734 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
726735
727736 var a = oneItem(3) ++ oneItem(4);
728737 try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
......@@ -737,6 +746,7 @@ fn scalar(x: u32) u32 {
737746}
738747
739748test "array concatenation peer resolves element types - value" {
749 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
740750 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
741751 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
742752
......@@ -755,7 +765,7 @@ test "array concatenation peer resolves element types - value" {
755765test "array concatenation peer resolves element types - pointer" {
756766 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
757767 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
758 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
768 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
759769
760770 var a = [2]u3{ 1, 7 };
761771 var b = [3]u8{ 200, 225, 255 };
......@@ -772,7 +782,7 @@ test "array concatenation sets the sentinel - value" {
772782 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
773783 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
774784 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
775 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
785 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
776786
777787 var a = [2]u3{ 1, 7 };
778788 var b = [3:69]u8{ 200, 225, 255 };
......@@ -791,7 +801,7 @@ test "array concatenation sets the sentinel - value" {
791801test "array concatenation sets the sentinel - pointer" {
792802 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
793803 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
794 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
804 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
795805
796806 var a = [2]u3{ 1, 7 };
797807 var b = [3:69]u8{ 200, 225, 255 };
......@@ -926,7 +936,7 @@ test "closure capture type of runtime-known var" {
926936}
927937
928938test "comptime break passing through runtime condition converted to runtime break" {
929 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
939 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
930940 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
931941
932942 const S = struct {
......@@ -959,7 +969,7 @@ test "comptime break passing through runtime condition converted to runtime brea
959969}
960970
961971test "comptime break to outer loop passing through runtime condition converted to runtime break" {
962 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
972 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
963973 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
964974 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
965975
......@@ -996,6 +1006,8 @@ test "comptime break to outer loop passing through runtime condition converted t
9961006}
9971007
9981008test "comptime break operand passing through runtime condition converted to runtime break" {
1009 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1010
9991011 const S = struct {
10001012 fn doTheTest(runtime: u8) !void {
10011013 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
10121024}
10131025
10141026test "comptime break operand passing through runtime switch converted to runtime break" {
1027 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10151028 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10161029
10171030 const S = struct {
......@@ -1038,7 +1051,7 @@ test "equality of pointers to comptime const" {
10381051test "storing an array of type in a field" {
10391052 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10401053 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1041 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1054 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10421055
10431056 const S = struct {
10441057 fn doTheTest() void {
......@@ -1066,7 +1079,7 @@ test "storing an array of type in a field" {
10661079
10671080test "pass pointer to field of comptime-only type as a runtime parameter" {
10681081 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1069 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1082 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10701083
10711084 const S = struct {
10721085 const Mixed = struct {
......@@ -1192,7 +1205,8 @@ test "lazy value is resolved as slice operand" {
11921205 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11931206 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11941207 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1195 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1208 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1209
11961210 const A = struct { a: u32 };
11971211 var a: [512]u64 = undefined;
11981212
......@@ -1203,6 +1217,8 @@ test "lazy value is resolved as slice operand" {
12031217}
12041218
12051219test "break from inline loop depends on runtime condition" {
1220 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1221
12061222 const S = struct {
12071223 fn foo(a: u8) bool {
12081224 return a == 4;
......@@ -1249,6 +1265,7 @@ test "inline for inside a runtime condition" {
12491265}
12501266
12511267test "continue in inline for inside a comptime switch" {
1268 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12521269 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12531270
12541271 const arr = .{ 1, 2, 3 };
......@@ -1267,7 +1284,7 @@ test "continue in inline for inside a comptime switch" {
12671284}
12681285
12691286test "length of global array is determinable at comptime" {
1270 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1287 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12711288
12721289 const S = struct {
12731290 var bytes: [1024]u8 = undefined;
......@@ -1316,7 +1333,7 @@ test "continue nested inline for loop in named block expr" {
13161333}
13171334
13181335test "x and false is comptime-known false" {
1319 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1336 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13201337 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13211338
13221339 const T = struct {
......@@ -1344,7 +1361,7 @@ test "x and false is comptime-known false" {
13441361}
13451362
13461363test "x or true is comptime-known true" {
1347 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1364 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13481365 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13491366
13501367 const T = struct {
......@@ -1372,6 +1389,7 @@ test "x or true is comptime-known true" {
13721389}
13731390
13741391test "non-optional and optional array elements concatenated" {
1392 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13751393 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13761394 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13771395 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1391,6 +1409,8 @@ test "inline call in @TypeOf inherits is_inline property" {
13911409}
13921410
13931411test "comptime function turns function value to function pointer" {
1412 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1413
13941414 const S = struct {
13951415 fn fnPtr(function: anytype) *const @TypeOf(function) {
13961416 return &function;
......@@ -1406,7 +1426,7 @@ test "comptime function turns function value to function pointer" {
14061426}
14071427
14081428test "container level const and var have unique addresses" {
1409 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1429 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14101430
14111431 const S = struct {
14121432 x: i32,
......@@ -1451,6 +1471,8 @@ test "struct in comptime false branch is not evaluated" {
14511471}
14521472
14531473test "result of nested switch assigned to variable" {
1474 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1475
14541476 var zds: u32 = 0;
14551477 zds = switch (zds) {
14561478 0 => switch (zds) {
......@@ -1465,6 +1487,8 @@ test "result of nested switch assigned to variable" {
14651487}
14661488
14671489test "inline for loop of functions returning error unions" {
1490 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1491
14681492 const T1 = struct {
14691493 fn v() error{}!usize {
14701494 return 1;
......@@ -1519,6 +1543,8 @@ test "early exit in container level const" {
15191543}
15201544
15211545test "@inComptime" {
1546 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1547
15221548 const S = struct {
15231549 fn inComptime() bool {
15241550 return @inComptime();
......@@ -1584,6 +1610,8 @@ test "comptime labeled block implicit exit" {
15841610}
15851611
15861612test "comptime block has intermediate runtime-known values" {
1613 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1614
15871615 const arr: [2]u8 = .{ 1, 2 };
15881616
15891617 var idx: usize = undefined;
test/behavior/export_builtin.zig+3-3
......@@ -4,7 +4,7 @@ const expect = std.testing.expect;
44
55test "exporting enum value" {
66 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
88
99 const S = struct {
1010 const E = enum(c_int) { one, two };
......@@ -18,7 +18,7 @@ test "exporting enum value" {
1818
1919test "exporting using namespace access" {
2020 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
21 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2222
2323 const S = struct {
2424 const Inner = struct {
......@@ -35,7 +35,7 @@ test "exporting using namespace access" {
3535test "exporting comptime-known value" {
3636 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3737 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
38 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
38 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3939
4040 const x: u32 = 10;
4141 @export(&x, .{ .name = "exporting_comptime_known_value_foo" });
test/behavior/export_keyword.zig+1-1
......@@ -43,7 +43,7 @@ export fn testPackedStuff(a: *const PackedStruct, b: *const PackedUnion) void {
4343}
4444
4545test "export function alias" {
46 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
46 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4747
4848 _ = struct {
4949 fn foo_internal() callconv(.c) u32 {
test/behavior/extern.zig+3-3
......@@ -4,7 +4,7 @@ const expect = std.testing.expect;
44
55test "anyopaque extern symbol" {
66 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
88
99 const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
1010 const b: *i32 = @ptrCast(@alignCast(a));
......@@ -15,7 +15,7 @@ export var a_mystery_symbol: i32 = 1234;
1515
1616test "function extern symbol" {
1717 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
18 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
18 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1919
2020 const a = @extern(*const fn () callconv(.c) i32, .{ .name = "a_mystery_function" });
2121 try expect(a() == 4567);
......@@ -27,7 +27,7 @@ export fn a_mystery_function() i32 {
2727
2828test "function extern symbol matches extern decl" {
2929 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
30 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
30 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3131
3232 const S = struct {
3333 extern fn another_mystery_function() u32;
test/behavior/field_parent_ptr.zig+16-16
......@@ -2,7 +2,7 @@ const expect = @import("std").testing.expect;
22const builtin = @import("builtin");
33
44test "@fieldParentPtr struct" {
5 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
5 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
66 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
77
88 const C = struct {
......@@ -139,7 +139,7 @@ test "@fieldParentPtr struct" {
139139
140140test "@fieldParentPtr extern struct" {
141141 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
142 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
142 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
143143
144144 const C = extern struct {
145145 a: bool = true,
......@@ -274,7 +274,7 @@ test "@fieldParentPtr extern struct" {
274274}
275275
276276test "@fieldParentPtr extern struct first zero-bit field" {
277 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
277 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
278278 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
279279
280280 const C = extern struct {
......@@ -378,7 +378,7 @@ test "@fieldParentPtr extern struct first zero-bit field" {
378378}
379379
380380test "@fieldParentPtr extern struct middle zero-bit field" {
381 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
381 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
382382 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
383383
384384 const C = extern struct {
......@@ -482,7 +482,7 @@ test "@fieldParentPtr extern struct middle zero-bit field" {
482482}
483483
484484test "@fieldParentPtr extern struct last zero-bit field" {
485 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
485 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
486486 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
487487
488488 const C = extern struct {
......@@ -587,7 +587,7 @@ test "@fieldParentPtr extern struct last zero-bit field" {
587587
588588test "@fieldParentPtr unaligned packed struct" {
589589 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
590 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
590 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
591591 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
592592 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
593593
......@@ -725,7 +725,7 @@ test "@fieldParentPtr unaligned packed struct" {
725725
726726test "@fieldParentPtr aligned packed struct" {
727727 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
728 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
728 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
729729 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
730730 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
731731
......@@ -863,7 +863,7 @@ test "@fieldParentPtr aligned packed struct" {
863863
864864test "@fieldParentPtr nested packed struct" {
865865 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
866 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
866 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
867867 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
868868 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
869869
......@@ -1026,7 +1026,7 @@ test "@fieldParentPtr nested packed struct" {
10261026
10271027test "@fieldParentPtr packed struct first zero-bit field" {
10281028 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1029 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1029 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10301030 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10311031 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10321032
......@@ -1132,7 +1132,7 @@ test "@fieldParentPtr packed struct first zero-bit field" {
11321132
11331133test "@fieldParentPtr packed struct middle zero-bit field" {
11341134 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1135 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1135 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11361136 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11371137 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11381138
......@@ -1238,7 +1238,7 @@ test "@fieldParentPtr packed struct middle zero-bit field" {
12381238
12391239test "@fieldParentPtr packed struct last zero-bit field" {
12401240 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1241 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1241 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12421242 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12431243 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12441244
......@@ -1344,7 +1344,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {
13441344
13451345test "@fieldParentPtr tagged union" {
13461346 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1347 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1347 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13481348
13491349 const C = union(enum) {
13501350 a: bool,
......@@ -1479,7 +1479,7 @@ test "@fieldParentPtr tagged union" {
14791479}
14801480
14811481test "@fieldParentPtr untagged union" {
1482 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1482 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14831483 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
14841484
14851485 const C = union {
......@@ -1617,7 +1617,7 @@ test "@fieldParentPtr untagged union" {
16171617test "@fieldParentPtr extern union" {
16181618 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
16191619 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1620 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1620 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16211621
16221622 const C = extern union {
16231623 a: bool,
......@@ -1752,7 +1752,7 @@ test "@fieldParentPtr extern union" {
17521752}
17531753
17541754test "@fieldParentPtr packed union" {
1755 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1755 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17561756 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
17571757 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17581758
......@@ -1896,7 +1896,7 @@ test "@fieldParentPtr packed union" {
18961896
18971897test "@fieldParentPtr tagged union all zero-bit fields" {
18981898 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1899 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1899 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19001900
19011901 const C = union(enum) {
19021902 a: u0,
test/behavior/floatop.zig+73-47
......@@ -28,7 +28,7 @@ test "add f32/f64" {
2828}
2929
3030test "add f80/f128/c_longdouble" {
31 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
31 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3232 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3333
3434 try testAdd(f80);
......@@ -62,7 +62,7 @@ test "sub f32/f64" {
6262}
6363
6464test "sub f80/f128/c_longdouble" {
65 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
65 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6666 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6767
6868 try testSub(f80);
......@@ -96,7 +96,7 @@ test "mul f32/f64" {
9696}
9797
9898test "mul f80/f128/c_longdouble" {
99 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
99 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
100100 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
101101
102102 try testMul(f80);
......@@ -116,6 +116,7 @@ fn testMul(comptime T: type) !void {
116116}
117117
118118test "cmp f16" {
119 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
119120 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120121 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
121122
......@@ -124,7 +125,7 @@ test "cmp f16" {
124125}
125126
126127test "cmp f32" {
127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
128 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
128129 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
129130 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
130131 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" {
137138 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
138139 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
139140 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
141 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
140142
141143 try testCmp(f64);
142144 try comptime testCmp(f64);
......@@ -145,7 +147,7 @@ test "cmp f64" {
145147test "cmp f128" {
146148 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
147149 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
148 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
150 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
149151
150152 try testCmp(f128);
151153 try comptime testCmp(f128);
......@@ -153,7 +155,7 @@ test "cmp f128" {
153155
154156test "cmp f80/c_longdouble" {
155157 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
156 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
158 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
157159 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
158160
159161 try testCmp(f80);
......@@ -217,6 +219,7 @@ fn testCmp(comptime T: type) !void {
217219}
218220
219221test "vector cmp f16" {
222 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
220223 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
221224 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222225 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -228,7 +231,7 @@ test "vector cmp f16" {
228231
229232test "vector cmp f32" {
230233 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
231 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
234 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
232235 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
233236 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
234237 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isArm()) return error.SkipZigTest;
......@@ -247,6 +250,7 @@ test "vector cmp f64" {
247250 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
248251 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
249252 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
253 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
250254
251255 try testCmpVector(f64);
252256 try comptime testCmpVector(f64);
......@@ -255,7 +259,7 @@ test "vector cmp f64" {
255259test "vector cmp f128" {
256260 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
257261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
258 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
262 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
259263 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
260264 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
261265
......@@ -267,7 +271,7 @@ test "vector cmp f80/c_longdouble" {
267271 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
268272 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
269273 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
270 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
274 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
271275
272276 try testCmpVector(f80);
273277 try comptime testCmpVector(f80);
......@@ -357,7 +361,7 @@ test "@sqrt f16" {
357361 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
358362 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
359363 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
360 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
364 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
361365
362366 try testSqrt(f16);
363367 try comptime testSqrt(f16);
......@@ -366,7 +370,7 @@ test "@sqrt f16" {
366370test "@sqrt f32/f64" {
367371 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
368372 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
369 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
373 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
370374
371375 try testSqrt(f32);
372376 try comptime testSqrt(f32);
......@@ -378,7 +382,7 @@ test "@sqrt f80/f128/c_longdouble" {
378382 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
379383 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
380384 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
381 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
385 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
382386 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
383387
384388 try testSqrt(f80);
......@@ -457,6 +461,7 @@ fn testSqrt(comptime T: type) !void {
457461}
458462
459463test "@sqrt with vectors" {
464 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
460465 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
461466 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
462467 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -479,7 +484,7 @@ test "@sin f16" {
479484 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
480485 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
481486 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
482 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
487 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
483488
484489 try testSin(f16);
485490 try comptime testSin(f16);
......@@ -489,7 +494,7 @@ test "@sin f32/f64" {
489494 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
490495 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
491496 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
492 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
497 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
493498
494499 try testSin(f32);
495500 comptime try testSin(f32);
......@@ -501,7 +506,7 @@ test "@sin f80/f128/c_longdouble" {
501506 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
502507 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
503508 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
504 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
509 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
505510
506511 try testSin(f80);
507512 comptime try testSin(f80);
......@@ -524,6 +529,7 @@ fn testSin(comptime T: type) !void {
524529}
525530
526531test "@sin with vectors" {
532 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
527533 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
528534 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
529535 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -546,7 +552,7 @@ test "@cos f16" {
546552 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
547553 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
548554 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
549 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
555 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
550556
551557 try testCos(f16);
552558 try comptime testCos(f16);
......@@ -556,7 +562,7 @@ test "@cos f32/f64" {
556562 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
557563 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
558564 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
559 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
565 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
560566
561567 try testCos(f32);
562568 try comptime testCos(f32);
......@@ -568,7 +574,7 @@ test "@cos f80/f128/c_longdouble" {
568574 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
569575 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
570576 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
571 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
577 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
572578
573579 try testCos(f80);
574580 try comptime testCos(f80);
......@@ -591,6 +597,7 @@ fn testCos(comptime T: type) !void {
591597}
592598
593599test "@cos with vectors" {
600 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
594601 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
595602 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
596603 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -613,7 +620,7 @@ test "@tan f16" {
613620 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
614621 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
615622 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
616 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
623 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
617624
618625 try testTan(f16);
619626 try comptime testTan(f16);
......@@ -623,7 +630,7 @@ test "@tan f32/f64" {
623630 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
624631 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
625632 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
626 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
633 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
627634
628635 try testTan(f32);
629636 try comptime testTan(f32);
......@@ -635,7 +642,7 @@ test "@tan f80/f128/c_longdouble" {
635642 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
636643 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
637644 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
638 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
645 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
639646
640647 try testTan(f80);
641648 try comptime testTan(f80);
......@@ -658,6 +665,7 @@ fn testTan(comptime T: type) !void {
658665}
659666
660667test "@tan with vectors" {
668 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
661669 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
662670 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
663671 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -680,7 +688,7 @@ test "@exp f16" {
680688 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
681689 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
682690 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
683 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
691 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
684692
685693 try testExp(f16);
686694 try comptime testExp(f16);
......@@ -690,7 +698,7 @@ test "@exp f32/f64" {
690698 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
691699 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
692700 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
693 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
701 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
694702
695703 try testExp(f32);
696704 try comptime testExp(f32);
......@@ -702,7 +710,7 @@ test "@exp f80/f128/c_longdouble" {
702710 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
703711 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
704712 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
705 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
713 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
706714
707715 try testExp(f80);
708716 try comptime testExp(f80);
......@@ -729,6 +737,7 @@ fn testExp(comptime T: type) !void {
729737}
730738
731739test "@exp with vectors" {
740 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
732741 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
733742 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
734743 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -751,7 +760,7 @@ test "@exp2 f16" {
751760 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
752761 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
753762 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
754 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
763 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
755764
756765 try testExp2(f16);
757766 try comptime testExp2(f16);
......@@ -761,7 +770,7 @@ test "@exp2 f32/f64" {
761770 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
762771 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
763772 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
764 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
773 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
765774
766775 try testExp2(f32);
767776 try comptime testExp2(f32);
......@@ -773,7 +782,7 @@ test "@exp2 f80/f128/c_longdouble" {
773782 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
774783 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
775784 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
776 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
785 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
777786
778787 try testExp2(f80);
779788 try comptime testExp2(f80);
......@@ -795,6 +804,7 @@ fn testExp2(comptime T: type) !void {
795804}
796805
797806test "@exp2 with @vectors" {
807 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
798808 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
799809 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
800810 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -817,7 +827,7 @@ test "@log f16" {
817827 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
818828 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
819829 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
820 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
830 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
821831
822832 try testLog(f16);
823833 try comptime testLog(f16);
......@@ -827,7 +837,7 @@ test "@log f32/f64" {
827837 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
828838 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
829839 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
830 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
840 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
831841
832842 try testLog(f32);
833843 try comptime testLog(f32);
......@@ -839,7 +849,7 @@ test "@log f80/f128/c_longdouble" {
839849 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
840850 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
841851 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
842 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
852 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
843853
844854 try testLog(f80);
845855 try comptime testLog(f80);
......@@ -865,7 +875,7 @@ test "@log with @vectors" {
865875 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
866876 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
867877 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
868 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
878 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
869879
870880 {
871881 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
......@@ -882,7 +892,7 @@ test "@log2 f16" {
882892 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
883893 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
884894 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
885 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
895 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
886896
887897 try testLog2(f16);
888898 try comptime testLog2(f16);
......@@ -892,7 +902,7 @@ test "@log2 f32/f64" {
892902 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
893903 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
894904 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
895 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
905 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
896906
897907 try testLog2(f32);
898908 try comptime testLog2(f32);
......@@ -904,7 +914,7 @@ test "@log2 f80/f128/c_longdouble" {
904914 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
905915 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
906916 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
907 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
917 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
908918
909919 try testLog2(f80);
910920 try comptime testLog2(f80);
......@@ -926,6 +936,7 @@ fn testLog2(comptime T: type) !void {
926936}
927937
928938test "@log2 with vectors" {
939 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
929940 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
930941 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
931942 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -957,7 +968,7 @@ test "@log10 f16" {
957968 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
958969 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
959970 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
960 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
971 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
961972
962973 try testLog10(f16);
963974 try comptime testLog10(f16);
......@@ -967,7 +978,7 @@ test "@log10 f32/f64" {
967978 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
968979 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
969980 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
970 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
981 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
971982
972983 try testLog10(f32);
973984 try comptime testLog10(f32);
......@@ -979,7 +990,7 @@ test "@log10 f80/f128/c_longdouble" {
979990 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
980991 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
981992 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
982 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
993 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
983994
984995 try testLog10(f80);
985996 try comptime testLog10(f80);
......@@ -1004,7 +1015,7 @@ test "@log10 with vectors" {
10041015 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10051016 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10061017 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1007 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1018 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10081019
10091020 try testLog10WithVectors();
10101021 try comptime testLog10WithVectors();
......@@ -1024,6 +1035,7 @@ test "@abs f16" {
10241035 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10251036 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10261037 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1038 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
10271039
10281040 try testFabs(f16);
10291041 try comptime testFabs(f16);
......@@ -1032,6 +1044,7 @@ test "@abs f16" {
10321044test "@abs f32/f64" {
10331045 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10341046 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1047 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
10351048
10361049 try testFabs(f32);
10371050 try comptime testFabs(f32);
......@@ -1042,7 +1055,7 @@ test "@abs f32/f64" {
10421055test "@abs f80/f128/c_longdouble" {
10431056 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10441057 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1045 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1058 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10461059 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10471060
10481061 try testFabs(f80);
......@@ -1118,6 +1131,7 @@ fn testFabs(comptime T: type) !void {
11181131}
11191132
11201133test "@abs with vectors" {
1134 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11211135 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11221136 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11231137 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1137,6 +1151,7 @@ fn testFabsWithVectors() !void {
11371151}
11381152
11391153test "@floor f16" {
1154 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11401155 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11411156 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11421157 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1146,6 +1161,7 @@ test "@floor f16" {
11461161}
11471162
11481163test "@floor f32/f64" {
1164 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11491165 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11501166 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11511167 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1159,7 +1175,7 @@ test "@floor f32/f64" {
11591175test "@floor f80/f128/c_longdouble" {
11601176 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11611177 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1162 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1178 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11631179 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11641180
11651181 try testFloor(f80);
......@@ -1201,6 +1217,7 @@ fn testFloor(comptime T: type) !void {
12011217}
12021218
12031219test "@floor with vectors" {
1220 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12041221 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12051222 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12061223 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1220,6 +1237,7 @@ fn testFloorWithVectors() !void {
12201237}
12211238
12221239test "@ceil f16" {
1240 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12231241 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12241242 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12251243 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1229,6 +1247,7 @@ test "@ceil f16" {
12291247}
12301248
12311249test "@ceil f32/f64" {
1250 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12321251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12331252 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12341253 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1242,7 +1261,7 @@ test "@ceil f32/f64" {
12421261test "@ceil f80/f128/c_longdouble" {
12431262 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12441263 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1245 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1264 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12461265 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12471266
12481267 try testCeil(f80);
......@@ -1256,7 +1275,7 @@ test "@ceil f80/f128/c_longdouble" {
12561275test "@ceil f80 maxInt(u64)" {
12571276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12581277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1259 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1278 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12601279 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12611280
12621281 var x: u64 = std.math.maxInt(u64);
......@@ -1296,6 +1315,7 @@ fn testCeil(comptime T: type) !void {
12961315}
12971316
12981317test "@ceil with vectors" {
1318 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12991319 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13001320 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13011321 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1315,6 +1335,7 @@ fn testCeilWithVectors() !void {
13151335}
13161336
13171337test "@trunc f16" {
1338 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13181339 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13191340 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13201341 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1324,6 +1345,7 @@ test "@trunc f16" {
13241345}
13251346
13261347test "@trunc f32/f64" {
1348 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13271349 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13281350 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13291351 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1337,7 +1359,7 @@ test "@trunc f32/f64" {
13371359test "@trunc f80/f128/c_longdouble" {
13381360 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13391361 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1340 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1362 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13411363 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13421364
13431365 try testTrunc(f80);
......@@ -1379,6 +1401,7 @@ fn testTrunc(comptime T: type) !void {
13791401}
13801402
13811403test "@trunc with vectors" {
1404 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13821405 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13831406 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13841407 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1398,6 +1421,7 @@ fn testTruncWithVectors() !void {
13981421}
13991422
14001423test "neg f16" {
1424 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14011425 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14021426 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14031427 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1407,6 +1431,7 @@ test "neg f16" {
14071431}
14081432
14091433test "neg f32/f64" {
1434 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14101435 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14111436 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14121437 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1420,7 +1445,7 @@ test "neg f32/f64" {
14201445test "neg f80/f128/c_longdouble" {
14211446 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14221447 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1423 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1448 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14241449 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
14251450
14261451 try testNeg(f80);
......@@ -1501,7 +1526,7 @@ fn testNeg(comptime T: type) !void {
15011526}
15021527
15031528test "negate f80" {
1504 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1529 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15051530
15061531 var f: f80 = 0.0;
15071532 const a: u80 = @bitCast(f);
......@@ -1535,7 +1560,7 @@ test "f128 at compile time is lossy" {
15351560test "comptime fixed-width float zero divided by zero produces NaN" {
15361561 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15371562 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1538 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1563 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15391564 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
15401565
15411566 inline for (.{ f16, f32, f64, f80, f128 }) |F| {
......@@ -1544,6 +1569,7 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
15441569}
15451570
15461571test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
1572 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
15471573 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15481574 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15491575
......@@ -1687,7 +1713,7 @@ test "comptime calls are only memoized when float arguments are bit-for-bit equa
16871713test "result location forwarded through unary float builtins" {
16881714 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16891715 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1690 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1716 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16911717
16921718 const S = struct {
16931719 var x: u32 = 10;
test/behavior/fn.zig+35-13
......@@ -21,6 +21,8 @@ fn testLocVars(b: i32) void {
2121}
2222
2323test "mutable local variables" {
24 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
25
2426 var zero: i32 = 0;
2527 _ = &zero;
2628 try expect(zero == 0);
......@@ -70,13 +72,14 @@ fn outer(y: u32) *const fn (u32) u32 {
7072}
7173
7274test "return inner function which references comptime variable of outer function" {
73 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
75 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7476
7577 const func = outer(10);
7678 try expect(func(3) == 7);
7779}
7880
7981test "discard the result of a function that returns a struct" {
82 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
8083 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8184 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8285
......@@ -101,7 +104,7 @@ test "discard the result of a function that returns a struct" {
101104test "inline function call that calls optional function pointer, return pointer at callsite interacts correctly with callsite return type" {
102105 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
103106 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
104 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
107 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
105108
106109 const S = struct {
107110 field: u32,
......@@ -147,7 +150,7 @@ fn fnWithUnreachable() noreturn {
147150
148151test "extern struct with stdcallcc fn pointer" {
149152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
150 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
153 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
151154
152155 const S = extern struct {
153156 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: {
175178}
176179
177180test "function with complex callconv and return type expressions" {
181 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
178182 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
179183 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
180184
......@@ -182,6 +186,7 @@ test "function with complex callconv and return type expressions" {
182186}
183187
184188test "pass by non-copying value" {
189 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
185190 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
186191
187192 try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
......@@ -197,6 +202,7 @@ fn addPointCoords(pt: Point) i32 {
197202}
198203
199204test "pass by non-copying value through var arg" {
205 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
200206 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
201207
202208 try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
......@@ -208,6 +214,7 @@ fn addPointCoordsVar(pt: anytype) !i32 {
208214}
209215
210216test "pass by non-copying value as method" {
217 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
211218 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
212219
213220 var pt = Point2{ .x = 1, .y = 2 };
......@@ -224,6 +231,7 @@ const Point2 = struct {
224231};
225232
226233test "pass by non-copying value as method, which is generic" {
234 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
227235 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
228236
229237 var pt = Point3{ .x = 1, .y = 2 };
......@@ -252,7 +260,7 @@ test "pass by non-copying value as method, at comptime" {
252260test "implicit cast fn call result to optional in field result" {
253261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
254262 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
255 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
263 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
256264
257265 const S = struct {
258266 fn entry() !void {
......@@ -290,6 +298,7 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void {
290298}
291299
292300test "call function with empty string" {
301 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
293302 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
294303
295304 acceptsString("");
......@@ -302,7 +311,7 @@ fn acceptsString(foo: []u8) void {
302311test "function pointers" {
303312 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
304313 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
305 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
314 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
306315
307316 const fns = [_]*const @TypeOf(fn1){
308317 &fn1,
......@@ -337,6 +346,7 @@ fn numberLiteralArg(a: anytype) !void {
337346}
338347
339348test "function call with anon list literal" {
349 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
340350 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
341351 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
342352
......@@ -356,6 +366,7 @@ test "function call with anon list literal" {
356366}
357367
358368test "function call with anon list literal - 2D" {
369 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
359370 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
360371 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
361372
......@@ -394,6 +405,8 @@ test "ability to give comptime types and non comptime types to same parameter" {
394405}
395406
396407test "function with inferred error set but returning no error" {
408 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
409
397410 const S = struct {
398411 fn foo() !void {}
399412 };
......@@ -404,7 +417,7 @@ test "function with inferred error set but returning no error" {
404417
405418test "import passed byref to function in return type" {
406419 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
407 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
420 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
408421
409422 const S = struct {
410423 fn get() @import("std").ArrayList(i32) {
......@@ -418,7 +431,7 @@ test "import passed byref to function in return type" {
418431
419432test "implicit cast function to function ptr" {
420433 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
421 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
434 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
422435
423436 const S1 = struct {
424437 export fn someFunctionThatReturnsAValue() c_int {
......@@ -439,7 +452,7 @@ test "implicit cast function to function ptr" {
439452test "method call with optional and error union first param" {
440453 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
441454 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
442 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
455 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
443456
444457 const S = struct {
445458 x: i32 = 1234,
......@@ -459,7 +472,7 @@ test "method call with optional and error union first param" {
459472test "method call with optional pointer first param" {
460473 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
461474 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
462 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
475 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
463476
464477 const S = struct {
465478 x: i32 = 1234,
......@@ -477,7 +490,7 @@ test "method call with optional pointer first param" {
477490test "using @ptrCast on function pointers" {
478491 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
479492 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
480 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
493 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
481494
482495 const S = struct {
483496 const A = struct { data: [4]u8 };
......@@ -514,6 +527,8 @@ test "function returns function returning type" {
514527}
515528
516529test "peer type resolution of inferred error set with non-void payload" {
530 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
531
517532 const S = struct {
518533 fn openDataFile(mode: enum { read, write }) !u32 {
519534 return switch (mode) {
......@@ -532,6 +547,8 @@ test "peer type resolution of inferred error set with non-void payload" {
532547}
533548
534549test "lazy values passed to anytype parameter" {
550 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
551
535552 const A = struct {
536553 a: u32,
537554 fn foo(comptime a: anytype) !void {
......@@ -570,7 +587,7 @@ test "pass and return comptime-only types" {
570587
571588test "pointer to alias behaves same as pointer to function" {
572589 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
573 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
590 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
574591
575592 const S = struct {
576593 fn foo() u32 {
......@@ -593,6 +610,7 @@ test "comptime parameters don't have to be marked comptime if only called at com
593610}
594611
595612test "inline function with comptime-known comptime-only return type called at runtime" {
613 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
596614 const S = struct {
597615 inline fn foo(x: *i32, y: *const i32) type {
598616 x.* = y.*;
......@@ -607,7 +625,7 @@ test "inline function with comptime-known comptime-only return type called at ru
607625}
608626
609627test "address of function parameter is consistent" {
610 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
628 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
611629
612630 const S = struct {
613631 fn paramAddrMatch(x: u8) bool {
......@@ -635,6 +653,8 @@ test "address of function parameter is consistent in function return type" {
635653}
636654
637655test "function parameter self equality" {
656 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
657
638658 const S = struct {
639659 fn equal(x: u32) bool {
640660 return x == x;
......@@ -664,6 +684,8 @@ test "function parameter self equality" {
664684}
665685
666686test "inline call propagates comptime-known argument to generic parameter and return types" {
687 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
688
667689 const S = struct {
668690 inline fn f(x: bool, y: if (x) u8 else u16) if (x) bool else u32 {
669691 if (x) {
......@@ -744,7 +766,7 @@ test "coerce generic function making generic parameter concrete" {
744766}
745767
746768test "return undefined pointer from function, directly and by expired local" {
747 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
769 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
748770
749771 const S = struct {
750772 var global: i32 = 1;
test/behavior/fn_delegation.zig+1
......@@ -32,6 +32,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
3232}
3333
3434test "fn delegation" {
35 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3536 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3637 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3738
test/behavior/fn_in_struct_in_comptime.zig+1-1
......@@ -12,7 +12,7 @@ fn get_foo() fn (*u8) usize {
1212}
1313
1414test "define a function in an anonymous struct in comptime" {
15 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
15 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1616
1717 const foo = get_foo();
1818 try expect(foo(@as(*u8, @ptrFromInt(12345))) == 12345);
test/behavior/for.zig+20-11
......@@ -5,6 +5,7 @@ const expectEqual = std.testing.expectEqual;
55const mem = std.mem;
66
77test "continue in for loop" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910
1011 const array = [_]i32{ 1, 2, 3, 4, 5 };
......@@ -67,7 +68,7 @@ test "ignore lval with underscore (for loop)" {
6768test "basic for loop" {
6869 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6970 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
70 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
71 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7172
7273 const expected_result: [24]u8 = .{
7374 9, 8, 7, 6, 0, 1, 2, 3,
......@@ -114,7 +115,7 @@ test "basic for loop" {
114115test "for with null and T peer types and inferred result location type" {
115116 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
116117 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
118 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
118119
119120 const S = struct {
120121 fn doTheTest(slice: []const u8) !void {
......@@ -133,6 +134,7 @@ test "for with null and T peer types and inferred result location type" {
133134}
134135
135136test "2 break statements and an else" {
137 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
136138 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137139
138140 const S = struct {
......@@ -154,7 +156,7 @@ test "2 break statements and an else" {
154156test "for loop with pointer elem var" {
155157 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
156158 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
157 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
159 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
158160
159161 const source = "abcdefg";
160162 var target: [source.len]u8 = undefined;
......@@ -179,6 +181,7 @@ fn mangleString(s: []u8) void {
179181}
180182
181183test "for copies its payload" {
184 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
182185 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
183186
184187 const S = struct {
......@@ -198,7 +201,7 @@ test "for copies its payload" {
198201test "for on slice with allowzero ptr" {
199202 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200203 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
201 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
204 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
202205
203206 const S = struct {
204207 fn doTheTest(slice: []const u8) !void {
......@@ -213,7 +216,7 @@ test "for on slice with allowzero ptr" {
213216
214217test "else continue outer for" {
215218 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
216 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
219 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
217220
218221 var i: usize = 6;
219222 var buf: [5]u8 = undefined;
......@@ -226,6 +229,7 @@ test "else continue outer for" {
226229}
227230
228231test "for loop with else branch" {
232 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
229233 {
230234 var x = [_]u32{ 1, 2 };
231235 _ = &x;
......@@ -272,6 +276,7 @@ test "two counters" {
272276}
273277
274278test "1-based counter and ptr to array" {
279 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
275280 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
276281 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
277282
......@@ -306,7 +311,7 @@ test "1-based counter and ptr to array" {
306311test "slice and two counters, one is offset and one is runtime" {
307312 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
308313 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
309 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
314 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
310315
311316 const slice: []const u8 = "blah";
312317 var start: usize = 0;
......@@ -335,7 +340,7 @@ test "slice and two counters, one is offset and one is runtime" {
335340test "two slices, one captured by-ref" {
336341 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
337342 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
338 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
343 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
339344
340345 var buf: [10]u8 = undefined;
341346 const slice1: []const u8 = "blah";
......@@ -354,7 +359,7 @@ test "two slices, one captured by-ref" {
354359test "raw pointer and slice" {
355360 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
356361 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
357 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
362 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
358363
359364 var buf: [10]u8 = undefined;
360365 const slice: []const u8 = "blah";
......@@ -373,7 +378,7 @@ test "raw pointer and slice" {
373378test "raw pointer and counter" {
374379 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
375380 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
376 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
381 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
377382
378383 var buf: [10]u8 = undefined;
379384 const ptr: [*]u8 = &buf;
......@@ -391,7 +396,7 @@ test "raw pointer and counter" {
391396test "inline for with slice as the comptime-known" {
392397 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
393398 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
394 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
399 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
395400
396401 const comptime_slice = "hello";
397402 var runtime_i: usize = 3;
......@@ -422,7 +427,7 @@ test "inline for with slice as the comptime-known" {
422427test "inline for with counter as the comptime-known" {
423428 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
424429 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
425 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
430 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
426431
427432 var runtime_slice = "hello";
428433 var runtime_i: usize = 3;
......@@ -451,6 +456,7 @@ test "inline for with counter as the comptime-known" {
451456}
452457
453458test "inline for on tuple pointer" {
459 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
454460 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
455461 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
456462
......@@ -465,6 +471,7 @@ test "inline for on tuple pointer" {
465471}
466472
467473test "ref counter that starts at zero" {
474 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
468475 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
469476 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
470477
......@@ -479,6 +486,7 @@ test "ref counter that starts at zero" {
479486}
480487
481488test "inferred alloc ptr of for loop" {
489 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
482490 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
483491 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
484492
......@@ -501,6 +509,7 @@ test "inferred alloc ptr of for loop" {
501509}
502510
503511test "for loop results in a bool" {
512 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
504513 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
505514
506515 try std.testing.expect(for ([1]u8{0}) |x| {
test/behavior/generics.zig+27-12
......@@ -5,6 +5,8 @@ const expect = testing.expect;
55const expectEqual = testing.expectEqual;
66
77test "one param, explicit comptime" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9
810 var x: usize = 0;
911 x += checkSize(i32);
1012 x += checkSize(bool);
......@@ -17,6 +19,7 @@ fn checkSize(comptime T: type) usize {
1719}
1820
1921test "simple generic fn" {
22 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2023 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2124
2225 try expect(max(i32, 3, -1) == 3);
......@@ -51,6 +54,7 @@ fn sameButWithFloats(a: f64, b: f64) f64 {
5154}
5255
5356test "fn with comptime args" {
57 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
5458 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5559 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5660
......@@ -86,7 +90,7 @@ fn max_f64(a: f64, b: f64) f64 {
8690test "type constructed by comptime function call" {
8791 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8892 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
93 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9094
9195 var l: SimpleList(10) = undefined;
9296 l.array[0] = 10;
......@@ -108,6 +112,7 @@ fn SimpleList(comptime L: usize) type {
108112}
109113
110114test "function with return type type" {
115 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
111116 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
112117 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
113118
......@@ -150,7 +155,7 @@ fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
150155test "generic fn with implicit cast" {
151156 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
152157 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
153 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
158 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
154159
155160 try expect(getFirstByte(u8, &[_]u8{13}) == 13);
156161 try expect(getFirstByte(u16, &[_]u16{
......@@ -169,7 +174,7 @@ test "generic fn keeps non-generic parameter types" {
169174 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
170175 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171176 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
172 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
177 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
173178
174179 const A = 128;
175180
......@@ -204,7 +209,7 @@ fn foo2(arg: anytype) bool {
204209
205210test "generic struct" {
206211 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
207 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
212 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
208213
209214 var a1 = GenNode(i32){
210215 .value = 13,
......@@ -245,7 +250,7 @@ test "function parameter is generic" {
245250test "generic function instantiation turns into comptime call" {
246251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
247252 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
248 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
253 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
249254
250255 const S = struct {
251256 fn doTheTest() !void {
......@@ -273,6 +278,7 @@ test "generic function instantiation turns into comptime call" {
273278}
274279
275280test "generic function with void and comptime parameter" {
281 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
276282 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
277283
278284 const S = struct { x: i32 };
......@@ -288,6 +294,7 @@ test "generic function with void and comptime parameter" {
288294}
289295
290296test "anonymous struct return type referencing comptime parameter" {
297 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
291298 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
292299
293300 const S = struct {
......@@ -306,7 +313,7 @@ test "anonymous struct return type referencing comptime parameter" {
306313test "generic function instantiation non-duplicates" {
307314 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
308315 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
309 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
316 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
310317
311318 const S = struct {
312319 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" {
339346}
340347
341348test "generic parameter type is function type" {
342 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
349 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
343350
344351 const S = struct {
345352 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" {
374381}
375382
376383test "generic struct as parameter type" {
384 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
377385 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
378386
379387 const S = struct {
......@@ -389,7 +397,7 @@ test "generic struct as parameter type" {
389397}
390398
391399test "slice as parameter type" {
392 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
400 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
393401 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
394402
395403 const S = struct {
......@@ -406,7 +414,7 @@ test "slice as parameter type" {
406414}
407415
408416test "null sentinel pointer passed as generic argument" {
409 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
417 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
410418
411419 const S = struct {
412420 fn doTheTest(a: anytype) !void {
......@@ -417,6 +425,8 @@ test "null sentinel pointer passed as generic argument" {
417425}
418426
419427test "generic function passed as comptime argument" {
428 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
429
420430 const S = struct {
421431 fn doMath(comptime f: fn (comptime type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {
422432 const result = try f(i32, a, b);
......@@ -427,7 +437,7 @@ test "generic function passed as comptime argument" {
427437}
428438
429439test "return type of generic function is function pointer" {
430 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
440 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
431441
432442 const S = struct {
433443 fn b(comptime T: type) ?*const fn () error{}!T {
......@@ -439,6 +449,8 @@ test "return type of generic function is function pointer" {
439449}
440450
441451test "coerced function body has inequal value with its uncoerced body" {
452 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
453
442454 const S = struct {
443455 const A = B(i32, c);
444456 fn c() !i32 {
......@@ -485,7 +497,9 @@ test "union in struct captures argument" {
485497}
486498
487499test "function argument tuple used as struct field" {
500 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
488501 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
502
489503 const S = struct {
490504 fn DeleagateWithContext(comptime Function: type) type {
491505 const ArgArgs = std.meta.ArgsTuple(Function);
......@@ -516,7 +530,7 @@ test "comptime callconv(.c) function ptr uses comptime type argument" {
516530}
517531
518532test "call generic function with from function called by the generic function" {
519 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
533 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
520534 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
521535 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
522536 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -559,6 +573,7 @@ fn StructCapture(comptime T: type) type {
559573}
560574
561575test "call generic function that uses capture from function declaration's scope" {
576 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
562577 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
563578
564579 const S = StructCapture(f64);
......@@ -573,7 +588,7 @@ comptime {
573588}
574589
575590test "generic parameter resolves to comptime-only type but is not marked comptime" {
576 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
591 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
577592
578593 const S = struct {
579594 fn foo(comptime T: type, rt_false: bool, func: fn (T) void) T {
test/behavior/globals.zig+12-8
......@@ -4,7 +4,7 @@ const expect = std.testing.expect;
44
55var pos = [2]f32{ 0.0, 0.0 };
66test "store to global array" {
7 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
88 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1010
......@@ -15,7 +15,7 @@ test "store to global array" {
1515
1616var vpos = @Vector(2, f32){ 0.0, 0.0 };
1717test "store to global vector" {
18 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
18 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1919 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
2020 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2121
......@@ -27,7 +27,7 @@ test "store to global vector" {
2727test "slices pointing at the same address as global array." {
2828 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2929 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
30 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3131
3232 const S = struct {
3333 const a = [_]u8{ 1, 2, 3 };
......@@ -44,7 +44,7 @@ test "slices pointing at the same address as global array." {
4444}
4545
4646test "global loads can affect liveness" {
47 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
47 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4848 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
4949 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5050
......@@ -68,6 +68,8 @@ test "global loads can affect liveness" {
6868}
6969
7070test "global const can be self-referential" {
71 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
72
7173 const S = struct {
7274 self: *const @This(),
7375 x: u32,
......@@ -83,7 +85,7 @@ test "global const can be self-referential" {
8385}
8486
8587test "global var can be self-referential" {
86 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
88 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8789
8890 const S = struct {
8991 self: *@This(),
......@@ -112,6 +114,8 @@ test "global var can be self-referential" {
112114}
113115
114116test "global const can be indirectly self-referential" {
117 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
118
115119 const S = struct {
116120 other: *const @This(),
117121 x: u32,
......@@ -136,7 +140,7 @@ test "global const can be indirectly self-referential" {
136140}
137141
138142test "global var can be indirectly self-referential" {
139 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
143 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
140144
141145 const S = struct {
142146 other: *@This(),
......@@ -175,7 +179,7 @@ var callbacks: Callbacks = undefined;
175179var callbacks_loaded: bool = false;
176180
177181test "function pointer field call on global extern struct, conditional on global" {
178 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
182 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
179183
180184 if (callbacks_loaded) {
181185 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
184188
185189test "function pointer field call on global extern struct" {
186190 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
187 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
191 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
188192
189193 const S = struct {
190194 fn keyCallback(key: i32) callconv(.c) i32 {
test/behavior/hasdecl.zig+2
......@@ -12,6 +12,7 @@ pub const Bar = struct {
1212};
1313
1414test "@hasDecl" {
15 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1516 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1617
1718 try expect(@hasDecl(Foo, "public_thing"));
......@@ -24,6 +25,7 @@ test "@hasDecl" {
2425}
2526
2627test "@hasDecl using a sliced string literal" {
28 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2729 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2830
2931 try expect(@hasDecl(@This(), "Bar") == true);
test/behavior/hasfield.zig+2
......@@ -2,6 +2,8 @@ const expect = @import("std").testing.expect;
22const builtin = @import("builtin");
33
44test "@hasField" {
5 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
6
57 const struc = struct {
68 a: i32,
79 b: []u8,
test/behavior/if.zig+10-2
......@@ -4,6 +4,8 @@ const expect = std.testing.expect;
44const expectEqual = std.testing.expectEqual;
55
66test "if statements" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
8
79 shouldBeEqual(1, 1);
810 firstEqlThird(2, 1, 2);
911}
......@@ -44,7 +46,7 @@ var global_with_val: anyerror!u32 = 0;
4446var global_with_err: anyerror!u32 = error.SomeError;
4547
4648test "unwrap mutable global var" {
47 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
49 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4850 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4951
5052 if (global_with_val) |v| {
......@@ -94,6 +96,7 @@ test "const result loc, runtime if cond, else unreachable" {
9496}
9597
9698test "if copies its payload" {
99 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
97100 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
98101 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
99102
......@@ -131,7 +134,7 @@ test "if prongs cast to expected type instead of peer type resolution" {
131134test "if peer expressions inferred optional type" {
132135 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
133136 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
134 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
137 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
135138
136139 var self: []const u8 = "abcdef";
137140 var index: usize = 0;
......@@ -147,6 +150,7 @@ test "if peer expressions inferred optional type" {
147150}
148151
149152test "if-else expression with runtime condition result location is inferred optional" {
153 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
150154 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
151155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
152156
......@@ -158,6 +162,8 @@ test "if-else expression with runtime condition result location is inferred opti
158162}
159163
160164test "result location with inferred type ends up being pointer to comptime_int" {
165 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
166
161167 var a: ?u32 = 1234;
162168 var b: u32 = 2000;
163169 _ = .{ &a, &b };
......@@ -186,6 +192,7 @@ fn returnTrue() bool {
186192}
187193
188194test "if value shouldn't be load-elided if used later (structs)" {
195 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
189196 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
190197
191198 const Foo = struct { x: i32 };
......@@ -205,6 +212,7 @@ test "if value shouldn't be load-elided if used later (structs)" {
205212}
206213
207214test "if value shouldn't be load-elided if used later (optionals)" {
215 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
208216 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
209217
210218 var a: ?i32 = 1;
test/behavior/import_c_keywords.zig+1-1
......@@ -29,7 +29,7 @@ extern fn an_alias_of_some_non_c_keyword_function() Id;
2929test "import c keywords" {
3030 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3131 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
32 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3333 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
3434 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3535
test/behavior/incomplete_struct_param_tld.zig+1-1
......@@ -23,7 +23,7 @@ fn foo(a: A) i32 {
2323
2424test "incomplete struct param top level declaration" {
2525 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
26 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2727
2828 const a = A{
2929 .b = B{
test/behavior/inline_switch.zig+6
......@@ -3,6 +3,7 @@ const expect = std.testing.expect;
33const builtin = @import("builtin");
44
55test "inline scalar prongs" {
6 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
67 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
78
89 var x: usize = 0;
......@@ -42,6 +43,7 @@ test "inline switch enums" {
4243
4344const U = union(E) { a: void, b: u2, c: u3, d: u4 };
4445test "inline switch unions" {
46 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4547 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4648 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4749 var x: U = .a;
......@@ -67,6 +69,7 @@ test "inline switch unions" {
6769}
6870
6971test "inline else bool" {
72 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7073 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7174 var a = true;
7275 _ = &a;
......@@ -89,6 +92,7 @@ test "inline else error" {
8992}
9093
9194test "inline else enum" {
95 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9296 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9397
9498 const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };
......@@ -134,6 +138,8 @@ test "inline else int all values" {
134138}
135139
136140test "inline switch capture is set when switch operand is comptime known" {
141 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
142
137143 const U2 = union(enum) {
138144 a: u32,
139145 };
test/behavior/int128.zig+5-2
......@@ -5,6 +5,7 @@ const minInt = std.math.minInt;
55const builtin = @import("builtin");
66
77test "uint128" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
910 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1011 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -25,7 +26,7 @@ test "uint128" {
2526test "undefined 128 bit int" {
2627 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2728 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
28 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
29 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2930 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3031
3132 @setRuntimeSafety(true);
......@@ -42,6 +43,7 @@ test "undefined 128 bit int" {
4243}
4344
4445test "int128" {
46 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4547 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4648 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4749 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -66,7 +68,7 @@ test "int128" {
6668test "truncate int128" {
6769 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6870 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
69 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
71 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7072 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7173
7274 {
......@@ -87,6 +89,7 @@ test "truncate int128" {
8789}
8890
8991test "shift int128" {
92 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9093 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9194 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9295 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
test/behavior/int_comparison_elision.zig+2-1
......@@ -4,6 +4,7 @@ const maxInt = std.math.maxInt;
44const builtin = @import("builtin");
55
66test "int comparison elision" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
89
910 testIntEdges(u0);
......@@ -14,7 +15,7 @@ test "int comparison elision" {
1415
1516 // TODO: support int types > 128 bits wide in other backends
1617 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
18 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1819
1920 // TODO: panic: integer overflow with int types > 65528 bits wide
2021 // TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide
test/behavior/ir_block_deps.zig+1
......@@ -18,6 +18,7 @@ fn getErrInt() anyerror!i32 {
1818}
1919
2020test "ir block deps" {
21 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2223 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2324
test/behavior/lower_strlit_to_vector.zig+1-1
......@@ -4,7 +4,7 @@ const builtin = @import("builtin");
44test "strlit to vector" {
55 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
66 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
88
99 const strlit = "0123456789abcdef0123456789ABCDEF";
1010 const vec_from_strlit: @Vector(32, u8) = strlit.*;
test/behavior/math.zig+82-46
......@@ -10,6 +10,7 @@ const mem = std.mem;
1010const math = std.math;
1111
1212test "assignment operators" {
13 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1314 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1415 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1516 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -40,6 +41,8 @@ test "assignment operators" {
4041}
4142
4243test "three expr in a row" {
44 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
45
4346 try testThreeExprInARow(false, true);
4447 try comptime testThreeExprInARow(false, true);
4548}
......@@ -64,7 +67,7 @@ fn assertFalse(b: bool) !void {
6467test "@clz small" {
6568 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6669 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
70 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6871 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
6972
7073 try testClzSmall();
......@@ -82,7 +85,7 @@ fn testClzSmall() !void {
8285test "@clz big ints" {
8386 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8487 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
85 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
88 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8689 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8790
8891 try testClzBigInts();
......@@ -102,7 +105,7 @@ test "@clz vectors" {
102105 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
103106 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
104107 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
108 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
106109 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
107110
108111 try testClzVectors();
......@@ -143,7 +146,7 @@ test "@ctz small" {
143146 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
144147 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
145148 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
149 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
147150
148151 try testCtzSmall();
149152 try comptime testCtzSmall();
......@@ -165,7 +168,7 @@ fn testOneCtz(comptime T: type, x: T) u32 {
165168test "@ctz 128-bit integers" {
166169 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
167170 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
168 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
171 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
169172 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
170173
171174 try testCtz128();
......@@ -184,7 +187,7 @@ test "@ctz vectors" {
184187 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
185188 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
186189 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
187 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
190 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
188191
189192 try testCtzVectors();
190193 try comptime testCtzVectors();
......@@ -258,6 +261,8 @@ test "quad hex float literal parsing in range" {
258261}
259262
260263test "underscore separator parsing" {
264 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
265
261266 try expect(1_234_567 == 1234567);
262267 try expect(1_234_567 == 1234567);
263268 try expect(1_2_3_4_5_6_7 == 1234567);
......@@ -334,6 +339,7 @@ test "comptime_int multi-limb partial shift right" {
334339}
335340
336341test "xor" {
342 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
337343 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
338344
339345 try test_xor();
......@@ -382,6 +388,7 @@ fn not(comptime T: type, a: T) T {
382388}
383389
384390test "binary not" {
391 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
385392 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
386393
387394 try expect(not(u0, 0) == 0);
......@@ -421,6 +428,7 @@ test "binary not" {
421428}
422429
423430test "binary not big int <= 128 bits" {
431 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
424432 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
425433 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
426434 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -456,7 +464,8 @@ test "division" {
456464 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
457465 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
458466 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
459 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
467 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
468
460469 try testIntDivision();
461470 try comptime testIntDivision();
462471
......@@ -629,7 +638,7 @@ test "large integer division" {
629638 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
630639 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
631640 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
632 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
641 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
633642 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
634643
635644 {
......@@ -650,7 +659,7 @@ test "division half-precision floats" {
650659 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
651660 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
652661 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
653 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
662 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
654663
655664 try testDivisionFP16();
656665 try comptime testDivisionFP16();
......@@ -737,6 +746,7 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {
737746}
738747
739748test "negation wrapping" {
749 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
740750 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
741751 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
742752
......@@ -750,6 +760,7 @@ fn negateWrap(comptime T: type, x: T) T {
750760}
751761
752762test "unsigned 64-bit division" {
763 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
753764 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
754765 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
755766
......@@ -791,7 +802,7 @@ fn testShrTrunc(x: u16) !void {
791802test "f128" {
792803 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
793804 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
794 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
805 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
795806 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
796807
797808 try test_f128();
......@@ -817,6 +828,7 @@ fn should_not_be_zero(x: f128) !void {
817828}
818829
819830test "umax wrapped squaring" {
831 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
820832 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
821833 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
822834
......@@ -873,6 +885,7 @@ test "umax wrapped squaring" {
873885}
874886
875887test "128-bit multiplication" {
888 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
876889 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
877890 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
878891 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 {
905918}
906919
907920test "@addWithOverflow" {
921 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
908922 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
909923 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910924 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
......@@ -923,6 +937,7 @@ test "@addWithOverflow" {
923937}
924938
925939test "@addWithOverflow <= 128 bits" {
940 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
926941 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
927942 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
928943 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -968,7 +983,7 @@ test "@addWithOverflow > 128 bits" {
968983 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
969984 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
970985 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
971 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
986 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
972987
973988 try testAddWithOverflow(u129, 4, 105, 109, 0);
974989 try testAddWithOverflow(u129, 1000, 100, 1100, 0);
......@@ -1008,6 +1023,7 @@ test "@addWithOverflow > 128 bits" {
10081023}
10091024
10101025test "small int addition" {
1026 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10111027 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10121028 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10131029 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 {
10361052}
10371053
10381054test "basic @mulWithOverflow" {
1055 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10391056 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10401057 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10411058 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
......@@ -1048,6 +1065,7 @@ test "basic @mulWithOverflow" {
10481065}
10491066
10501067test "extensive @mulWithOverflow" {
1068 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10511069 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10521070 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10531071 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1087,6 +1105,7 @@ test "extensive @mulWithOverflow" {
10871105}
10881106
10891107test "@mulWithOverflow bitsize > 32" {
1108 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10901109 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10911110 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10921111 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
11231142}
11241143
11251144test "Multiply unwrap error * immediate" {
1145 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11261146 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11271147 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11281148 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1139,7 +1159,7 @@ test "@mulWithOverflow bitsize 128 bits" {
11391159 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11401160 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11411161 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1142 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1162 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
11431163
11441164 try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0);
11451165 try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1);
......@@ -1162,7 +1182,7 @@ test "@mulWithOverflow bitsize 128 bits" {
11621182
11631183test "@mulWithOverflow > 128 bits" {
11641184 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1165 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1185 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11661186
11671187 try testMulWithOverflow(u140, 0, maxInt(u140), 0, 0);
11681188 try testMulWithOverflow(u140, 1, maxInt(u140), maxInt(u140), 0);
......@@ -1191,7 +1211,7 @@ test "@mulWithOverflow > 128 bits" {
11911211
11921212test "@mulWithOverflow bitsize 256 bits" {
11931213 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1194 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1214 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11951215 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11961216
11971217 {
......@@ -1235,6 +1255,7 @@ fn testSubWithOverflow(comptime T: type, a: T, b: T, sub: T, bit: u1) !void {
12351255}
12361256
12371257test "@subWithOverflow" {
1258 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12381259 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12391260 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12401261
......@@ -1251,6 +1272,7 @@ test "@subWithOverflow" {
12511272}
12521273
12531274test "@subWithOverflow <= 128 bits" {
1275 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12541276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12551277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12561278 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1294,7 +1316,7 @@ test "@subWithOverflow > 128 bits" {
12941316 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12951317 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12961318 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1297 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1319 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
12981320
12991321 try testSubWithOverflow(u129, 4, 105, maxInt(u129) - 100, 1);
13001322 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:
13401362test "@shlWithOverflow" {
13411363 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13421364 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1343 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1365 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13441366 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13451367
13461368 try testShlWithOverflow(u4, 2, 1, 4, 0);
......@@ -1359,7 +1381,7 @@ test "@shlWithOverflow" {
13591381test "@shlWithOverflow > 64 bits" {
13601382 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13611383 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1362 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1384 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13631385 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13641386
13651387 try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 7, 0x0_8000_0000_0000_0000, 0);
......@@ -1385,7 +1407,7 @@ test "@shlWithOverflow > 64 bits" {
13851407
13861408test "@shlWithOverflow > 128 bits" {
13871409 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1388 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1410 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13891411
13901412 try testShlWithOverflow(u140, 1 << 100, 20, 1 << 120, 0);
13911413 try testShlWithOverflow(u140, 1 << 100, 40, 0, 1);
......@@ -1413,6 +1435,7 @@ fn testAnd(comptime T: type, a: T, b: T, expected: T) !void {
14131435}
14141436
14151437test "and > 128 bits" {
1438 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14161439 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14171440
14181441 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 {
14411464}
14421465
14431466test "or > 128 bits" {
1467 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14441468 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14451469
14461470 try testOr(u140, 0, 1 << 139, 1 << 139);
......@@ -1469,6 +1493,7 @@ fn testXor(comptime T: type, a: T, b: T, expected: T) !void {
14691493}
14701494
14711495test "xor > 128 bits" {
1496 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14721497 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14731498
14741499 try testXor(u140, 0, maxInt(u140), maxInt(u140));
......@@ -1497,6 +1522,7 @@ fn testNot(comptime T: type, a: T, expected: T) !void {
14971522}
14981523
14991524test "not > 128 bits" {
1525 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
15001526 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15011527
15021528 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 {
15251551}
15261552
15271553test "shl > 128 bits" {
1554 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
15281555 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15291556
15301557 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 {
15531580}
15541581
15551582test "shr > 128 bits" {
1583 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
15561584 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15571585
15581586 try testShr(u140, 1 << 139, 39, 1 << 100);
......@@ -1582,7 +1610,7 @@ fn testClz(comptime T: type, a: T, expected: u16) !void {
15821610
15831611test "@clz > 128 bits" {
15841612 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1585 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1613 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15861614
15871615 try testClz(u140, 0, 140);
15881616 try testClz(u140, 1 << 139, 0);
......@@ -1611,7 +1639,7 @@ fn testCtz(comptime T: type, a: T, expected: u16) !void {
16111639
16121640test "@ctz > 128 bits" {
16131641 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1614 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1642 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16151643
16161644 try testCtz(u140, 0, 140);
16171645 try testCtz(u140, 1 << 139, 139);
......@@ -1640,7 +1668,7 @@ fn testPopCount(comptime T: type, a: T, expected: u16) !void {
16401668
16411669test "@popCount > 128 bits" {
16421670 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1643 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1671 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16441672
16451673 try testPopCount(u140, 0, 0);
16461674 try testPopCount(u140, maxInt(u140), 140);
......@@ -1669,7 +1697,7 @@ fn testBitReverse(comptime T: type, a: T, expected: T) !void {
16691697
16701698test "@bitReverse > 128 bits" {
16711699 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1672 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1700 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16731701
16741702 try testBitReverse(u140, 1 << 139, 1);
16751703 try testBitReverse(u140, 1 << 70, 1 << 69);
......@@ -1698,7 +1726,7 @@ fn testByteSwap(comptime T: type, a: T, expected: T) !void {
16981726
16991727test "@byteSwap > 128 bits" {
17001728 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1701 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1729 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17021730
17031731 try testByteSwap(u144, 1 << 136, 1);
17041732 try testByteSwap(u144, 1, 1 << 136);
......@@ -1727,7 +1755,7 @@ fn testMax(comptime T: type, a: T, b: T, expected: T) !void {
17271755
17281756test "@max > 128 bits" {
17291757 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1730 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1758 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17311759
17321760 try testMax(u140, 0, maxInt(u140), maxInt(u140));
17331761 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 {
17561784
17571785test "@min > 128 bits" {
17581786 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1759 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1787 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17601788
17611789 try testMin(u140, 0, maxInt(u140), 0);
17621790 try testMin(u140, 1 << 139, 1 << 138, 1 << 138);
......@@ -1784,6 +1812,7 @@ fn testAbs(comptime T: type, a: T, expected: anytype) !void {
17841812}
17851813
17861814test "@abs > 128 bits" {
1815 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
17871816 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17881817
17891818 try testAbs(u140, 0, 0);
......@@ -1808,7 +1837,7 @@ fn testRem(comptime T: type, numerator: T, denominator: T, expected: T) !void {
18081837
18091838test "@rem > 128 bits" {
18101839 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1811 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1840 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18121841
18131842 try testRem(u140, 0, maxInt(u140), 0);
18141843 try testRem(u140, maxInt(u140), maxInt(u140), 0);
......@@ -1835,7 +1864,7 @@ fn testMod(comptime T: type, numerator: T, denominator: T, expected: T) !void {
18351864
18361865test "@mod > 128 bits" {
18371866 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1838 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1867 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18391868
18401869 try testMod(u140, 0, maxInt(u140), 0);
18411870 try testMod(u140, maxInt(u140), maxInt(u140), 0);
......@@ -1862,7 +1891,7 @@ fn testDivFloor(comptime T: type, numerator: T, denominator: T, expected: T) !vo
18621891
18631892test "@divFloor > 128 bits" {
18641893 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1865 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1894 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18661895
18671896 try testDivFloor(u140, 0, maxInt(u140), 0);
18681897 try testDivFloor(u140, maxInt(u140), maxInt(u140), 1);
......@@ -1890,7 +1919,7 @@ fn testDivCeil(comptime T: type, numerator: T, denominator: T, expected: T) !voi
18901919
18911920test "@divCeil > 128 bits" {
18921921 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1893 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1922 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18941923
18951924 try testDivCeil(u140, 0, maxInt(u140), 0);
18961925 try testDivCeil(u140, maxInt(u140), maxInt(u140), 1);
......@@ -1918,7 +1947,7 @@ fn testDivTrunc(comptime T: type, numerator: T, denominator: T, expected: T) !vo
19181947
19191948test "@divTrunc > 128 bits" {
19201949 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1921 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1950 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19221951
19231952 try testDivTrunc(u140, 0, maxInt(u140), 0);
19241953 try testDivTrunc(u140, maxInt(u140), maxInt(u140), 1);
......@@ -1941,6 +1970,8 @@ test "@divTrunc > 128 bits" {
19411970}
19421971
19431972test "overflow arithmetic with u0 values" {
1973 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1974
19441975 {
19451976 var a: u0 = 0;
19461977 _ = &a;
......@@ -1972,6 +2003,8 @@ test "overflow arithmetic with u0 values" {
19722003}
19732004
19742005test "allow signed integer division/remainder when values are comptime-known and positive or exact" {
2006 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2007
19752008 try expect(5 / 3 == 1);
19762009 try expect(-5 / -3 == 1);
19772010 try expect(-6 / 3 == -2);
......@@ -1983,7 +2016,7 @@ test "allow signed integer division/remainder when values are comptime-known and
19832016test "quad hex float literal parsing accurate" {
19842017 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19852018 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1986 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2019 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19872020 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
19882021
19892022 const a: f128 = 0x1.1111222233334444555566667777p+0;
......@@ -2089,6 +2122,7 @@ fn testShlTrunc(x: u16) !void {
20892122}
20902123
20912124test "exact shift left" {
2125 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
20922126 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20932127
20942128 try testShlExact(0b00110101);
......@@ -2141,7 +2175,7 @@ test "remainder division" {
21412175 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21422176 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21432177 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2144 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2178 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21452179 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21462180
21472181 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 {
21742208test "float remainder division using @rem" {
21752209 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21762210 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2177 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2211 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21782212 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21792213
21802214 try comptime frem(f16);
......@@ -2216,7 +2250,7 @@ test "float modulo division using @mod" {
22162250 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22172251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22182252 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2219 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2253 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
22202254 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22212255
22222256 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" {
22842318test "@round f80" {
22852319 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22862320 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2287 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2321 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
22882322 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22892323
22902324 try testRound(f80, 12.0);
......@@ -2294,7 +2328,7 @@ test "@round f80" {
22942328test "@round f128" {
22952329 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22962330 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2297 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2331 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
22982332 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22992333
23002334 try testRound(f128, 12.0);
......@@ -2312,7 +2346,7 @@ test "vector integer addition" {
23122346 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23132347 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23142348 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2315 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2349 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23162350
23172351 const S = struct {
23182352 fn doTheTest() !void {
......@@ -2332,7 +2366,7 @@ test "vector integer addition" {
23322366test "NaN comparison" {
23332367 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23342368 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2335 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2369 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23362370 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23372371
23382372 try testNanEqNan(f16);
......@@ -2348,7 +2382,7 @@ test "NaN comparison" {
23482382test "NaN comparison f80" {
23492383 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23502384 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2351 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2385 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23522386 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23532387
23542388 try testNanEqNan(f80);
......@@ -2372,7 +2406,7 @@ test "vector comparison" {
23722406 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23732407 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23742408 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2375 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2409 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
23762410
23772411 const S = struct {
23782412 fn doTheTest() !void {
......@@ -2401,7 +2435,7 @@ test "compare undefined literal with comptime_int" {
24012435test "signed zeros are represented properly" {
24022436 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24032437 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2404 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2438 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
24052439 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24062440
24072441 const S = struct {
......@@ -2463,7 +2497,7 @@ test "@clz works on both vector and scalar inputs" {
24632497 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24642498 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24652499 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2466 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2500 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
24672501
24682502 var x: u32 = 0x1;
24692503 _ = &x;
......@@ -2478,7 +2512,7 @@ test "@clz works on both vector and scalar inputs" {
24782512test "runtime comparison to NaN is comptime-known" {
24792513 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24802514 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2481 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2515 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
24822516 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24832517
24842518 const S = struct {
......@@ -2534,7 +2568,7 @@ test "float divide by zero" {
25342568 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25352569 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25362570 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2537 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2571 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
25382572
25392573 if (builtin.zig_backend == .stage2_x86_64 and builtin.object_format == .coff and builtin.abi != .gnu) return error.SkipZigTest;
25402574
......@@ -2569,7 +2603,7 @@ test "partially-runtime integer vector division would be illegal if vector eleme
25692603 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25702604 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25712605 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2572 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2606 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
25732607 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
25742608
25752609 var lhs: @Vector(2, i8) = .{ -128, 5 };
......@@ -2593,6 +2627,7 @@ test "partially-runtime integer vector division would be illegal if vector eleme
25932627}
25942628
25952629test "float vector division of comptime zero by runtime nan is nan" {
2630 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
25962631 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
25972632 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25982633 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" {
26132648 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26142649 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26152650 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2651 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
26162652
26172653 const ct_zero: @Vector(1, f32) = .{0};
26182654 var rt_nan: @Vector(1, f32) = .{math.nan(f32)};
......@@ -2649,7 +2685,7 @@ test "comptime float vector multiplication of zero by nan is nan" {
26492685}
26502686
26512687test "i96 operations" {
2652 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2688 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
26532689
26542690 // This is coverage for some stuff used by std.Io timestamps, to catch
26552691 // issues earlier than bootstrapping.
test/behavior/maximum_minimum.zig+16-7
......@@ -6,6 +6,7 @@ const expect = std.testing.expect;
66const expectEqual = std.testing.expectEqual;
77
88test "@max" {
9 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
910 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1011 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1112 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -31,7 +32,7 @@ test "@max on vectors" {
3132 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3233 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3334 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
34 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
35 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3536
3637 const S = struct {
3738 fn doTheTest() !void {
......@@ -62,6 +63,7 @@ test "@min" {
6263 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6364 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6465 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
66 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Fails on lavapipe
6567
6668 const S = struct {
6769 fn doTheTest() !void {
......@@ -84,7 +86,7 @@ test "@min for vectors" {
8486 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8587 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8688 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
87 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
89 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8890
8991 const S = struct {
9092 fn doTheTest() !void {
......@@ -114,7 +116,7 @@ test "@min for vectors" {
114116test "@min/max for floats" {
115117 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
116118 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
119 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
118120 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
119121
120122 const S = struct {
......@@ -151,6 +153,8 @@ test "@min/@max on lazy values" {
151153}
152154
153155test "@min/@max more than two arguments" {
156 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
157
154158 const x: u32 = 30;
155159 const y: u32 = 10;
156160 const z: u32 = 20;
......@@ -159,7 +163,7 @@ test "@min/@max more than two arguments" {
159163}
160164
161165test "@min/@max more than two vector arguments" {
162 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
166 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
163167 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
164168 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
165169 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -173,6 +177,7 @@ test "@min/@max more than two vector arguments" {
173177}
174178
175179test "@min/@max notices bounds" {
180 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
176181 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
177182 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
178183
......@@ -189,7 +194,7 @@ test "@min/@max notices bounds" {
189194}
190195
191196test "@min/@max notices vector bounds" {
192 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
197 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
193198 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
194199 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195200 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -221,6 +226,7 @@ test "@min/@max on comptime_int" {
221226}
222227
223228test "@min/@max notices bounds from types" {
229 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
224230 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
225231 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
226232
......@@ -240,7 +246,7 @@ test "@min/@max notices bounds from types" {
240246}
241247
242248test "@min/@max notices bounds from vector types" {
243 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
249 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
244250 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
245251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
246252 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" {
281287}
282288
283289test "@min/@max notices bounds from vector types when element of comptime-known vector is undef" {
290 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
284291 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
285292 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
286293 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
303310}
304311
305312test "@min/@max of signed and unsigned runtime integers" {
313 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
314
306315 var x: i32 = -1;
307316 var y: u31 = 1;
308317 _ = .{ &x, &y };
......@@ -348,7 +357,7 @@ test "@min/@max with runtime signed and unsigned integers of same size" {
348357}
349358
350359test "@min/@max with runtime vectors of signed and unsigned integers of same size" {
351 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
360 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
352361 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
353362 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
354363 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/member_func.zig+2-2
......@@ -29,7 +29,7 @@ const HasFuncs = struct {
2929test "standard field calls" {
3030 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3131 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3333
3434 try expect(HasFuncs.one(0) == 1);
3535 try expect(HasFuncs.two(0) == 2);
......@@ -72,7 +72,7 @@ test "standard field calls" {
7272test "@field field calls" {
7373 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7474 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
75 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
75 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7676
7777 try expect(@field(HasFuncs, "one")(0) == 1);
7878 try expect(@field(HasFuncs, "two")(0) == 2);
test/behavior/memcpy.zig+9-7
......@@ -6,7 +6,7 @@ const assert = std.debug.assert;
66test "memcpy and memset intrinsics" {
77 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
88 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1010
1111 try testMemcpyMemset();
1212 try comptime testMemcpyMemset();
......@@ -27,7 +27,7 @@ fn testMemcpyMemset() !void {
2727test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
2828 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2929 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
30 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
30 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3131
3232 try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
3333 try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();
......@@ -47,7 +47,7 @@ fn testMemcpyBothSinglePtrArrayOneIsNullTerminated() !void {
4747test "@memcpy dest many pointer" {
4848 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4949 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
50 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
50 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5151
5252 try testMemcpyDestManyPtr();
5353 try comptime testMemcpyDestManyPtr();
......@@ -69,7 +69,7 @@ fn testMemcpyDestManyPtr() !void {
6969test "@memcpy C pointer" {
7070 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7171 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
72 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
72 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7373
7474 try testMemcpyCPointer();
7575 try comptime testMemcpyCPointer();
......@@ -90,7 +90,7 @@ test "@memcpy slice" {
9090 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9191 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9292 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
93 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
93 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9494
9595 try testMemcpySlice();
9696 try comptime testMemcpySlice();
......@@ -133,7 +133,7 @@ test "@memcpy comptime-only type" {
133133}
134134
135135test "@memcpy zero-bit type with aliasing" {
136 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
136 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
137137
138138 const S = struct {
139139 fn doTheTest() void {
......@@ -153,7 +153,7 @@ test "@memcpy zero-bit type with aliasing" {
153153
154154test "@memcpy with sentinel" {
155155 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
156 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
156 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
157157
158158 const S = struct {
159159 fn doTheTest() void {
......@@ -182,6 +182,8 @@ test "@memcpy no sentinel source into sentinel destination" {
182182}
183183
184184test "@memcpy a global array" {
185 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
186
185187 const S = struct {
186188 var array_u8: [1]u8 = .{1};
187189 const slice_u8: []u8 = &array_u8;
test/behavior/memmove.zig+6-4
......@@ -5,7 +5,7 @@ const expect = std.testing.expect;
55test "memmove and memset intrinsics" {
66 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
77 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
8 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1010
1111 try testMemmoveMemset();
......@@ -32,7 +32,7 @@ fn testMemmoveMemset() !void {
3232test "@memmove with both operands single-ptr-to-array, one is null-terminated" {
3333 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3434 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
35 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
35 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3636 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3737
3838 try testMemmoveBothSinglePtrArrayOneIsNullTerminated();
......@@ -75,7 +75,7 @@ fn testMemmoveBothSinglePtrArrayOneIsNullTerminated() !void {
7575test "@memmove dest many pointer" {
7676 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7777 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
78 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7979 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8080
8181 try testMemmoveDestManyPtr();
......@@ -117,7 +117,7 @@ test "@memmove slice" {
117117 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
118118 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
119119 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
120 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
120 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
121121 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
122122
123123 try testMemmoveSlice();
......@@ -172,6 +172,8 @@ comptime {
172172}
173173
174174test "@memmove a global array" {
175 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
176
175177 const S = struct {
176178 var array_u8: [1]u8 = .{1};
177179 const slice_u8: []u8 = &array_u8;
test/behavior/memset.zig+12-12
......@@ -5,7 +5,7 @@ const expect = std.testing.expect;
55test "@memset on array pointers" {
66 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
77 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
8 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
8 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
99
1010 try testMemsetArray();
1111 try comptime testMemsetArray();
......@@ -33,7 +33,7 @@ fn testMemsetArray() !void {
3333test "@memset preserves array sentinel" {
3434 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3535 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
36 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
36 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3737
3838 try testMemsetArraySentinel();
3939 try comptime testMemsetArraySentinel();
......@@ -55,7 +55,7 @@ fn testMemsetArraySentinel() !void {
5555test "@memset on slices" {
5656 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5757 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
58 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5959 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6060
6161 try testMemsetSlice();
......@@ -90,7 +90,7 @@ fn testMemsetSlice() !void {
9090test "memset with bool element" {
9191 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9292 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
93 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
93 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9494
9595 var buf: [5]bool = undefined;
9696 @memset(&buf, true);
......@@ -101,7 +101,7 @@ test "memset with bool element" {
101101test "memset with 1-byte struct element" {
102102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
103103 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
104 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
104 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
105105
106106 const S = struct { x: bool };
107107 var buf: [5]S = undefined;
......@@ -113,7 +113,7 @@ test "memset with 1-byte struct element" {
113113test "memset with 1-byte array element" {
114114 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
115115 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
116 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
116 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
117117
118118 const A = [1]bool;
119119 var buf: [5]A = undefined;
......@@ -126,7 +126,7 @@ test "memset with large array element, runtime known" {
126126 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127127 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
128128 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
129 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
129 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
130130 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
131131
132132 const A = [128]u64;
......@@ -144,7 +144,7 @@ test "memset with large array element, runtime known" {
144144test "memset with large array element, comptime known" {
145145 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
146146 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
147 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
147 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
148148 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
149149
150150 const A = [128]u64;
......@@ -161,7 +161,7 @@ test "memset with large array element, comptime known" {
161161test "@memset provides result type" {
162162 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
163163 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
164 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
164 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
165165 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
166166
167167 const S = struct { x: u32 };
......@@ -179,7 +179,7 @@ test "@memset provides result type" {
179179test "zero keys with @memset" {
180180 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
181181 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
182 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
182 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
183183
184184 const Keys = struct {
185185 up: bool,
......@@ -201,7 +201,7 @@ test "@memset with zero-length array" {
201201}
202202
203203test "@memset a global array" {
204 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
204 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
205205
206206 const S = struct {
207207 var array_u8: [1]u8 = .{1};
......@@ -232,7 +232,7 @@ test "@memset a global array" {
232232}
233233
234234test "@memset array of booleans" {
235 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
235 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
236236
237237 const S = struct {
238238 var x: bool = false;
test/behavior/merge_error_sets.zig+1
......@@ -12,6 +12,7 @@ fn foo() C!void {
1212}
1313
1414test "merge error sets" {
15 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1516 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1617
1718 if (foo()) {
test/behavior/muladd.zig+7-4
......@@ -48,7 +48,7 @@ fn testMulAdd16() !void {
4848test "@mulAdd f80" {
4949 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5050 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
51 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5252 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
5353
5454 try comptime testMulAdd80();
......@@ -66,7 +66,7 @@ fn testMulAdd80() !void {
6666test "@mulAdd f128" {
6767 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6868 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
69 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
69 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7070 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7171
7272 try comptime testMulAdd128();
......@@ -95,6 +95,7 @@ fn vector16() !void {
9595}
9696
9797test "vector f16" {
98 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9899 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
99100 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
100101 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -118,6 +119,7 @@ fn vector32() !void {
118119}
119120
120121test "vector f32" {
122 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
121123 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
122124 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
123125 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -141,6 +143,7 @@ fn vector64() !void {
141143}
142144
143145test "vector f64" {
146 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
144147 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
145148 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
146149 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -166,7 +169,7 @@ test "vector f80" {
166169 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
167170 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
168171 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
169 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
172 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
170173 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
171174
172175 try comptime vector80();
......@@ -190,7 +193,7 @@ test "vector f128" {
190193 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
191194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
192195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
193 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
196 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
194197 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
195198
196199 try comptime vector128();
test/behavior/multiple_externs_with_conflicting_types.zig+2-2
......@@ -5,7 +5,7 @@ const A = extern struct {
55extern fn issue529(?*A) void;
66
77comptime {
8 if (builtin.zig_backend != .stage2_spirv) {
8 if (!builtin.cpu.arch.isSpirv()) {
99 _ = @import("conflicting_externs/b.zig");
1010 }
1111}
......@@ -15,7 +15,7 @@ const builtin = @import("builtin");
1515test "call extern function defined with conflicting type" {
1616 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1717 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
18 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1919 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2020
2121 @import("conflicting_externs/a.zig").issue529(null);
test/behavior/nan.zig+1-1
......@@ -24,7 +24,7 @@ const snan_f128: f128 = math.snan(f128);
2424test "nan memory equality" {
2525 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2626 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
27 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
27 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2828
2929 // signaled
3030 try testing.expect(mem.eql(u8, mem.asBytes(&snan_u16), mem.asBytes(&snan_f16)));
test/behavior/null.zig+6-2
......@@ -29,6 +29,7 @@ test "optional type" {
2929}
3030
3131test "test maybe object and get a pointer to the inner value" {
32 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3233 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3334 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3435 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -50,6 +51,7 @@ test "rhs maybe unwrap return" {
5051}
5152
5253test "maybe return" {
54 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
5355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5456 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5557
......@@ -69,6 +71,7 @@ fn foo(x: ?i32) ?bool {
6971}
7072
7173test "test null runtime" {
74 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7275 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7376 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7477
......@@ -130,7 +133,7 @@ test "null with default unwrap" {
130133
131134test "optional pointer to 0 bit type null value at runtime" {
132135 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
136 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
134137
135138 const EmptyStruct = struct {};
136139 var x: ?*EmptyStruct = null;
......@@ -139,6 +142,7 @@ test "optional pointer to 0 bit type null value at runtime" {
139142}
140143
141144test "if var maybe pointer" {
145 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
142146 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
143147 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
144148 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -183,7 +187,7 @@ const SillyStruct = struct {
183187const here_is_a_null_literal = SillyStruct{ .context = null };
184188
185189test "unwrap optional which is field of global var" {
186 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
190 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
187191 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
188192 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
189193
test/behavior/optional.zig+28-14
......@@ -7,6 +7,7 @@ const expectEqual = testing.expectEqual;
77const expectEqualStrings = std.testing.expectEqualStrings;
88
99test "passing an optional integer as a parameter" {
10 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1011 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1112 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1213
......@@ -28,7 +29,7 @@ pub const EmptyStruct = struct {};
2829
2930test "optional pointer to size zero struct" {
3031 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3233
3334 var e = EmptyStruct{};
3435 const o: ?*EmptyStruct = &e;
......@@ -36,7 +37,7 @@ test "optional pointer to size zero struct" {
3637}
3738
3839test "equality compare optional pointers" {
39 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
40 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4041
4142 try testNullPtrsEql();
4243 try comptime testNullPtrsEql();
......@@ -94,7 +95,7 @@ test "optional error equality" {
9495
9596test "optional with zero-bit type" {
9697 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
97 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
98 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9899
99100 const S = struct {
100101 fn doTheTest(comptime ZeroBit: type, comptime zero_bit: ZeroBit) !void {
......@@ -147,7 +148,7 @@ test "address of unwrap optional" {
147148 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
148149 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
149150 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
150 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
151 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
151152
152153 const S = struct {
153154 const Foo = struct {
......@@ -166,6 +167,7 @@ test "address of unwrap optional" {
166167}
167168
168169test "nested optional field in struct" {
170 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
169171 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
170172 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171173
......@@ -183,6 +185,7 @@ test "nested optional field in struct" {
183185}
184186
185187test "equality compare optionals and non-optionals" {
188 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
186189 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
187190 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188191 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -242,6 +245,7 @@ test "equality compare optionals and non-optionals" {
242245}
243246
244247test "compare optionals with modified payloads" {
248 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
245249 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
246250
247251 var lhs: ?bool = false;
......@@ -269,7 +273,7 @@ test "compare optionals with modified payloads" {
269273
270274test "unwrap function call with optional pointer return value" {
271275 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
272 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
276 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
273277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
274278
275279 const S = struct {
......@@ -290,6 +294,7 @@ test "unwrap function call with optional pointer return value" {
290294}
291295
292296test "nested orelse" {
297 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
293298 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
294299 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295300
......@@ -318,7 +323,7 @@ test "nested orelse" {
318323test "self-referential struct through a slice of optional" {
319324 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
320325 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
321 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
326 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
322327
323328 const S = struct {
324329 const Node = struct {
......@@ -351,6 +356,7 @@ test "assigning to an unwrapped optional field in an inline loop" {
351356}
352357
353358test "coerce an anon struct literal to optional struct" {
359 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
354360 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
355361 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
356362
......@@ -369,6 +375,7 @@ test "coerce an anon struct literal to optional struct" {
369375}
370376
371377test "0-bit child type coerced to optional return ptr result location" {
378 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
372379 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
373380 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
374381 const S = struct {
......@@ -395,7 +402,7 @@ test "0-bit child type coerced to optional return ptr result location" {
395402test "0-bit child type coerced to optional" {
396403 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
397404 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
398 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
405 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
399406 const S = struct {
400407 fn doTheTest() !void {
401408 var it: Foo = .{
......@@ -419,6 +426,7 @@ test "0-bit child type coerced to optional" {
419426}
420427
421428test "array of optional unaligned types" {
429 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
422430 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
423431 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
424432
......@@ -454,6 +462,7 @@ test "array of optional unaligned types" {
454462}
455463
456464test "optional pointer to zero bit optional payload" {
465 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
457466 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
458467 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
459468 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -475,7 +484,7 @@ test "optional pointer to zero bit optional payload" {
475484test "optional pointer to zero bit error union payload" {
476485 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
477486 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
478 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
487 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
479488 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
480489
481490 const B = struct {
......@@ -509,7 +518,7 @@ const NoReturn = struct {
509518};
510519
511520test "optional of noreturn used with if" {
512 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
521 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
513522 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
514523
515524 NoReturn.a = 64;
......@@ -521,7 +530,7 @@ test "optional of noreturn used with if" {
521530}
522531
523532test "optional of noreturn used with orelse" {
524 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
533 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
525534 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
526535
527536 NoReturn.a = 64;
......@@ -551,6 +560,7 @@ test "orelse on C pointer" {
551560}
552561
553562test "alignment of wrapping an optional payload" {
563 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
554564 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
555565 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
556566 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -571,7 +581,7 @@ test "alignment of wrapping an optional payload" {
571581test "Optional slice size is optimized" {
572582 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
573583 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
574 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
584 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
575585
576586 try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
577587 var a: ?[]const u8 = null;
......@@ -584,7 +594,7 @@ test "Optional slice passed to function" {
584594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
585595 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
586596 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
587 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
597 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
588598
589599 const S = struct {
590600 fn foo(a: ?[]const u8) !void {
......@@ -599,6 +609,7 @@ test "Optional slice passed to function" {
599609}
600610
601611test "peer type resolution in nested if expressions" {
612 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
602613 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
603614
604615 const Thing = struct { n: i32 };
......@@ -626,7 +637,7 @@ test "peer type resolution in nested if expressions" {
626637test "cast slice to const slice nested in error union and optional" {
627638 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
628639 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
629 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
640 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
630641 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
631642
632643 const S = struct {
......@@ -647,6 +658,7 @@ test "variable of optional of noreturn" {
647658}
648659
649660test "copied optional doesn't alias source" {
661 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
650662 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
651663 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
652664 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -664,7 +676,7 @@ test "result location initialization of optional with OPV payload" {
664676 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
665677 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
666678 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
667 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
679 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
668680 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
669681
670682 const S = struct {
......@@ -697,6 +709,8 @@ test "global comptime only optional" {
697709}
698710
699711test "optional ptr payload alignment" {
712 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
713
700714 const S = struct {
701715 fn doTheTest(p: *align(1) ?u32) !void {
702716 comptime assert(@TypeOf(&p.*.?) == *align(1) u32);
test/behavior/overlapping_assign.zig+1-1
......@@ -3,7 +3,7 @@ const std = @import("std");
33const expect = std.testing.expect;
44
55test "assignment to overlapping memory" {
6 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
6 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
77
88 try theTest();
99 try comptime theTest();
test/behavior/packed-struct.zig+30-16
......@@ -119,6 +119,7 @@ test "consistent size of packed structs" {
119119}
120120
121121test "correct sizeOf and offsets in packed structs" {
122 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
122123 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
123124 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
124125
......@@ -183,6 +184,7 @@ test "correct sizeOf and offsets in packed structs" {
183184}
184185
185186test "nested packed structs" {
187 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
186188 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
187189 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188190
......@@ -225,6 +227,7 @@ test "nested packed structs" {
225227}
226228
227229test "regular in irregular packed struct" {
230 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
228231 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
229232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
230233 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
......@@ -247,7 +250,8 @@ test "nested packed struct unaligned" {
247250 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
248251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
249252 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
250 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
253 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
254
251255 const S1 = packed struct {
252256 a: u4,
253257 b: u4,
......@@ -316,7 +320,7 @@ test "nested packed struct unaligned" {
316320test "byte-aligned field pointer offsets" {
317321 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
318322 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
319 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
323 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
320324 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
321325
322326 const S = struct {
......@@ -403,7 +407,7 @@ test "nested packed struct field pointers" {
403407 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
404408 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
405409 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
406 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
410 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
407411 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
408412 const S2 = packed struct {
409413 base: u8,
......@@ -438,7 +442,7 @@ test "nested packed struct field pointers" {
438442test "@intFromPtr on a packed struct field" {
439443 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
440444 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
441 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
445 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
442446
443447 const S = struct {
444448 const P = packed struct {
......@@ -459,7 +463,7 @@ test "@intFromPtr on a packed struct field" {
459463test "@intFromPtr on a packed struct field unaligned and nested" {
460464 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
461465 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
462 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
466 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
463467
464468 const S1 = packed struct {
465469 a: u4,
......@@ -555,7 +559,7 @@ test "packed struct fields modification" {
555559 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
556560
557561 // Originally reported at https://github.com/ziglang/zig/issues/16615
558 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
562 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
559563
560564 const Small = packed struct(u16) {
561565 val: u8 = 0,
......@@ -580,7 +584,7 @@ test "packed struct fields modification" {
580584test "nested packed struct field access test" {
581585 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
582586 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
583 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
587 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
584588 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
585589 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
586590
......@@ -698,7 +702,7 @@ test "nested packed struct field access test" {
698702
699703test "nested packed struct at non-zero offset" {
700704 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
701 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
705 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
702706 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
703707
704708 const Pair = packed struct(u24) {
......@@ -730,7 +734,7 @@ test "nested packed struct at non-zero offset 2" {
730734 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
731735 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
732736 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
733 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
737 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
734738 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
735739
736740 const S = struct {
......@@ -792,6 +796,7 @@ test "nested packed struct at non-zero offset 2" {
792796}
793797
794798test "runtime init of unnamed packed struct type" {
799 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
795800 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
796801 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
797802
......@@ -810,7 +815,7 @@ test "packed struct passed to callconv(.c) function" {
810815 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
811816 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
812817 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
813 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
818 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
814819
815820 const S = struct {
816821 const Packed = packed struct(u64) {
......@@ -835,7 +840,7 @@ test "packed struct passed to callconv(.c) function" {
835840test "overaligned pointer to packed struct" {
836841 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
837842 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
838 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
843 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
839844 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
840845
841846 const S = packed struct { a: u32, b: u32 };
......@@ -862,7 +867,7 @@ test "pointer to container level packed struct field" {
862867 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
863868 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
864869 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
865 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
870 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
866871 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
867872
868873 const S = packed struct(u32) {
......@@ -885,6 +890,7 @@ test "pointer to container level packed struct field" {
885890}
886891
887892test "store undefined to packed result location" {
893 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
888894 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
889895 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
890896 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -907,6 +913,7 @@ test "bitcast back and forth" {
907913
908914// Originally reported at https://github.com/ziglang/zig/issues/14200
909915test "field access of packed struct smaller than its abi size inside struct initialized with rls" {
916 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
910917 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
911918 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
912919
......@@ -929,7 +936,7 @@ test "modify nested packed struct aligned field" {
929936 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
930937 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
931938 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
932 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
939 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
933940
934941 const Options = packed struct {
935942 foo: bool = false,
......@@ -958,7 +965,7 @@ test "modify nested packed struct aligned field" {
958965test "assigning packed struct inside another packed struct" {
959966 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
960967 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
961 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
968 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
962969
963970 const S = struct {
964971 const Inner = packed struct {
......@@ -1001,6 +1008,7 @@ test "packed struct acts as a namespace" {
10011008}
10021009
10031010test "assignment to non-byte-aligned field in packed struct" {
1011 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10041012 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10051013 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10061014 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
......@@ -1023,7 +1031,7 @@ test "assignment to non-byte-aligned field in packed struct" {
10231031test "packed struct field pointer aligned properly" {
10241032 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10251033 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1026 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1034 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
10271035
10281036 const Foo = packed struct {
10291037 a: i32,
......@@ -1039,6 +1047,7 @@ test "packed struct field pointer aligned properly" {
10391047}
10401048
10411049test "load flag from packed struct in union" {
1050 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10421051 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10431052 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10441053 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -1116,7 +1125,7 @@ test "2-byte packed struct argument in C calling convention" {
11161125 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11171126 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
11181127 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1119 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1128 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11201129
11211130 const S = packed struct(u16) {
11221131 x: u15 = 0,
......@@ -1162,6 +1171,7 @@ test "packed struct equality" {
11621171}
11631172
11641173test "packed struct equality ignores padding bits" {
1174 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11651175 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11661176
11671177 const S = packed struct { b: bool };
......@@ -1172,6 +1182,7 @@ test "packed struct equality ignores padding bits" {
11721182}
11731183
11741184test "packed struct with signed field" {
1185 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11751186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11761187
11771188 var s: packed struct {
......@@ -1184,6 +1195,7 @@ test "packed struct with signed field" {
11841195}
11851196
11861197test "assign packed struct initialized with RLS to packed struct literal field" {
1198 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11871199 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11881200 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11891201
......@@ -1200,6 +1212,7 @@ test "assign packed struct initialized with RLS to packed struct literal field"
12001212}
12011213
12021214test "packed struct store of comparison result" {
1215 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12031216 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12041217 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
12051218
......@@ -1250,6 +1263,7 @@ test "convert from/to backing int" {
12501263}
12511264
12521265test "equality with wide backing integer" {
1266 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12531267 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/35982
12541268
12551269 const S = packed struct(i200) {
test/behavior/packed-union.zig+8-8
......@@ -8,7 +8,7 @@ test "flags in packed union" {
88 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
11 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1212 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
1313
1414 try testFlagsInPackedUnion();
......@@ -51,7 +51,7 @@ test "flags in packed union at offset" {
5151 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5252 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5353 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
54 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
54 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5555 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
5656
5757 try testFlagsInPackedUnionAtOffset();
......@@ -107,7 +107,7 @@ fn testFlagsInPackedUnionAtOffset() !void {
107107test "packed union in packed struct" {
108108 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
109109 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
110 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
110 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
111111
112112 try testPackedUnionInPackedStruct();
113113 try comptime testPackedUnionInPackedStruct();
......@@ -144,7 +144,7 @@ test "packed union initialized with a runtime value" {
144144 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
145145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146146 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
147 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
147 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
148148
149149 const Fields = packed struct {
150150 timestamp: u50,
......@@ -182,7 +182,7 @@ test "assigning to non-active field at comptime" {
182182test "packed union with explicit backing integer" {
183183 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
184184 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
185 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
185 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
186186
187187 const U = packed union(i32) {
188188 raw: i32,
......@@ -201,7 +201,7 @@ test "packed union with explicit backing integer" {
201201}
202202
203203test "packed union equality" {
204 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
204 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
205205
206206 const Foo = packed union {
207207 a: u4,
......@@ -229,7 +229,7 @@ test "initialize packed union field to undefined at comptime" {
229229}
230230
231231test "convert from/to backing int" {
232 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
232 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
233233
234234 const U = packed union(u10) {
235235 a: i10,
......@@ -246,7 +246,7 @@ test "convert from/to backing int" {
246246
247247test "equality with wide backing integer" {
248248 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/35982
249 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
249 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
250250
251251 const U = packed union(i200) {
252252 x: u200,
test/behavior/packed_struct_explicit_backing_int.zig+1
......@@ -5,6 +5,7 @@ const expectEqual = std.testing.expectEqual;
55const native_endian = builtin.cpu.arch.endian();
66
77test "packed struct explicit backing integer" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
910 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1011
test/behavior/pointers.zig+36-28
......@@ -20,7 +20,7 @@ fn testDerefPtr() !void {
2020test "pointer-integer arithmetic" {
2121 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2222 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
23 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2424
2525 var ptr: [*]const u8 = "abcd";
2626
......@@ -45,7 +45,7 @@ test "pointer-integer arithmetic" {
4545
4646test "pointer subtraction" {
4747 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
48 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
48 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
4949
5050 {
5151 const a: *u8 = @ptrFromInt(100);
......@@ -100,7 +100,7 @@ test "pointer subtraction" {
100100}
101101
102102test "pointer arithmetic with non-trivial RHS" {
103 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
103 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
104104
105105 var t: bool = undefined;
106106 t = true;
......@@ -126,7 +126,7 @@ fn PtrOf(comptime T: type) type {
126126
127127test "implicit cast single item pointer to C pointer and back" {
128128 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
129 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
129 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
130130
131131 var y: u8 = 11;
132132 const x: [*c]u8 = &y;
......@@ -143,7 +143,7 @@ test "initialize const optional C pointer to null" {
143143
144144test "assigning integer to C pointer" {
145145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
146 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
147147 var x: i32 = 0;
148148 var y: i32 = 1;
149149 var ptr: [*c]u8 = 0;
......@@ -160,7 +160,7 @@ test "assigning integer to C pointer" {
160160
161161test "C pointer comparison and arithmetic" {
162162 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
163 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
164164
165165 const S = struct {
166166 fn doTheTest() !void {
......@@ -204,7 +204,7 @@ fn testDerefPtrOneVal() !void {
204204}
205205
206206test "peer type resolution with C pointers" {
207 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
207 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
208208
209209 const ptr_one: *u8 = undefined;
210210 const ptr_many: [*]u8 = undefined;
......@@ -222,6 +222,7 @@ test "peer type resolution with C pointers" {
222222}
223223
224224test "peer type resolution with C pointer and const pointer" {
225 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
225226 var ptr_c: [*c]u8 = undefined;
226227 var ptr_const: *const u8 = &undefined;
227228 _ = .{ &ptr_c, &ptr_const };
......@@ -232,7 +233,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
232233 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
233234 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
234235 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
235 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
236 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
236237
237238 var slice: []const u8 = "aoeu";
238239 _ = &slice;
......@@ -247,7 +248,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
247248test "implicit cast error unions with non-optional to optional pointer" {
248249 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
249250 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
250 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
251 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
251252 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
252253
253254 const S = struct {
......@@ -276,7 +277,7 @@ test "allowzero pointer and slice" {
276277 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
277278 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
278279 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
279 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
280 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
280281
281282 var ptr: [*]allowzero i32 = @ptrFromInt(0);
282283 const opt_ptr: ?[*]allowzero i32 = ptr;
......@@ -295,7 +296,7 @@ test "allowzero pointer and slice" {
295296test "assign null directly to C pointer and test null equality" {
296297 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
297298 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
298 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
299 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
299300
300301 var x: [*c]i32 = null;
301302 _ = &x;
......@@ -353,6 +354,8 @@ test "assign null directly to C pointer and test null equality" {
353354}
354355
355356test "array initialization types" {
357 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
358
356359 const E = enum { A, B, C };
357360 try expect(@TypeOf([_]u8{}) == [0]u8);
358361 try expect(@TypeOf([_:0]u8{}) == [0:0]u8);
......@@ -362,7 +365,7 @@ test "array initialization types" {
362365
363366test "null terminated pointer" {
364367 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
365 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
368 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
366369
367370 const S = struct {
368371 fn doTheTest() !void {
......@@ -380,7 +383,7 @@ test "null terminated pointer" {
380383test "allow any sentinel" {
381384 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
382385 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
383 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
386 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
384387
385388 const S = struct {
386389 fn doTheTest() !void {
......@@ -396,7 +399,7 @@ test "allow any sentinel" {
396399test "pointer sentinel with enums" {
397400 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
398401 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
399 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
402 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
400403
401404 const S = struct {
402405 const Number = enum {
......@@ -419,7 +422,7 @@ test "pointer sentinel with optional element" {
419422 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
420423 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
421424 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
422 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
425 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
423426
424427 const S = struct {
425428 fn doTheTest() !void {
......@@ -436,7 +439,7 @@ test "pointer sentinel with +inf" {
436439 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
437440 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
438441 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
439 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
442 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
440443
441444 const S = struct {
442445 fn doTheTest() !void {
......@@ -458,7 +461,7 @@ test "pointer to array at fixed address" {
458461}
459462
460463test "pointer-integer arithmetic affects the alignment" {
461 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
464 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
462465
463466 {
464467 var ptr: [*]align(8) u32 = undefined;
......@@ -507,7 +510,7 @@ test "@intFromPtr on null optional at comptime" {
507510test "indexing array with sentinel returns correct type" {
508511 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
509512 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
510 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
513 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
511514
512515 var s: [:0]const u8 = "abc";
513516 try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
......@@ -515,7 +518,7 @@ test "indexing array with sentinel returns correct type" {
515518
516519test "element pointer to slice" {
517520 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
518 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
521 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
519522
520523 const S = struct {
521524 fn doTheTest() !void {
......@@ -537,7 +540,7 @@ test "element pointer to slice" {
537540
538541test "element pointer arithmetic to slice" {
539542 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
540 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
543 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
541544
542545 const S = struct {
543546 fn doTheTest() !void {
......@@ -562,7 +565,7 @@ test "element pointer arithmetic to slice" {
562565
563566test "array slicing to slice" {
564567 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
565 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
568 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
566569
567570 const S = struct {
568571 fn doTheTest() !void {
......@@ -592,7 +595,7 @@ test "pointer to constant decl preserves alignment" {
592595test "ptrCast comptime known slice to C pointer" {
593596 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
594597 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
595 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
598 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
596599
597600 const s: [:0]const u8 = "foo";
598601 var p: [*c]const u8 = @ptrCast(s);
......@@ -611,7 +614,7 @@ test "pointer alignment and element type include call expression" {
611614}
612615
613616test "pointer to array has explicit alignment" {
614 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
617 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
615618
616619 const S = struct {
617620 const Base = extern struct { a: u8 };
......@@ -636,6 +639,8 @@ test "result type preserved through multiple references" {
636639}
637640
638641test "result type found through optional pointer" {
642 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
643
639644 const ptr1: ?*const u32 = &@intCast(123);
640645 const ptr2: ?[]const u8 = &.{ @intCast(123), @truncate(0xABCD) };
641646 try expect(ptr1.?.* == 123);
......@@ -688,14 +693,15 @@ fn constant() !void {
688693
689694test "pointer-to-array constness for zero-size elements, var" {
690695 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
691 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
696 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
697
692698 try mutable();
693699 try comptime mutable();
694700}
695701
696702test "pointer-to-array constness for zero-size elements, const" {
697703 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
698 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
704 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
699705
700706 try constant();
701707 try comptime constant();
......@@ -735,7 +741,7 @@ test "comptime pointer equality through distinct fields with well-defined layout
735741}
736742
737743test "comptime pointer equality through distinct elements with well-defined layout" {
738 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
744 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
739745
740746 const buf: [2]u32 = .{ 123, 456 };
741747
......@@ -749,7 +755,7 @@ test "comptime pointer equality through distinct elements with well-defined layo
749755}
750756
751757test "pointers to elements of slice of zero-bit type" {
752 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
758 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
753759
754760 var slice: []const u0 = undefined;
755761 slice = &.{ 0, 0 };
......@@ -761,7 +767,7 @@ test "pointers to elements of slice of zero-bit type" {
761767}
762768
763769test "pointers to elements of many-ptr to zero-bit type" {
764 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
770 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
765771
766772 var many_ptr: [*]const u0 = undefined;
767773 many_ptr = &.{ 0, 0 };
......@@ -773,6 +779,8 @@ test "pointers to elements of many-ptr to zero-bit type" {
773779}
774780
775781test "comptime C pointer to optional pointer" {
782 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
783
776784 const opt: ?*u8 = @ptrFromInt(0x1000);
777785 const outer_ptr: [*c]const ?*u8 = &opt;
778786 const inner_ptr = &outer_ptr.*.?;
test/behavior/popcount.zig+3-3
......@@ -6,7 +6,7 @@ const expectEqual = std.testing.expectEqual;
66test "@popCount integers" {
77 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
88 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1010 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
1111
1212 try comptime testPopCountIntegers();
......@@ -17,7 +17,7 @@ test "@popCount 128bit integer" {
1717 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1818 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1919 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
20 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2121 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2222
2323 comptime {
......@@ -79,7 +79,7 @@ test "@popCount vectors" {
7979 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8080 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8181 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
82 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
82 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8383 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8484
8585 try comptime testPopCountVectors();
test/behavior/prefetch.zig+1-1
......@@ -2,7 +2,7 @@ const builtin = @import("builtin");
22const std = @import("std");
33
44test "@prefetch()" {
5 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
5 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
66
77 var a: [2]u32 = .{ 42, 42 };
88 var a_len = a.len;
test/behavior/ptrcast.zig+22-19
......@@ -6,7 +6,7 @@ const native_endian = builtin.target.cpu.arch.endian();
66
77test "reinterpret bytes as integer with nonzero offset" {
88 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1010
1111 try testReinterpretBytesAsInteger();
1212 try comptime testReinterpretBytesAsInteger();
......@@ -22,6 +22,7 @@ fn testReinterpretBytesAsInteger() !void {
2222}
2323
2424test "reinterpret an array over multiple elements, with no well-defined layout" {
25 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2526 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2627 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2728
......@@ -39,7 +40,7 @@ fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void {
3940
4041test "reinterpret bytes inside auto-layout struct as integer with nonzero offset" {
4142 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
43 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4344
4445 try testReinterpretStructWrappedBytesAsInteger();
4546 try comptime testReinterpretStructWrappedBytesAsInteger();
......@@ -57,7 +58,7 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
5758
5859test "reinterpret bytes of an array into an extern struct" {
5960 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
60 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
61 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6162
6263 try testReinterpretBytesAsExternStruct();
6364 try comptime testReinterpretBytesAsExternStruct();
......@@ -171,7 +172,7 @@ test "lower reinterpreted comptime field ptr" {
171172
172173test "reinterpret struct field at comptime" {
173174 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
174 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
175 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
175176
176177 const numNative = comptime Bytes.init(0x12345678);
177178 if (native_endian != .little) {
......@@ -194,7 +195,7 @@ const Bytes = struct {
194195
195196test "ptrcast of const integer has the correct object size" {
196197 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
197 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
198 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
198199
199200 const is_value = ~@as(isize, @intCast(std.math.minInt(isize)));
200201 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" {
229230test "implicit optional pointer to optional anyopaque pointer" {
230231 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
231232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
232 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
233 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
233234
234235 var buf: [4]u8 = "aoeu".*;
235236 const x: ?[*]u8 = &buf;
......@@ -241,7 +242,7 @@ test "implicit optional pointer to optional anyopaque pointer" {
241242test "@ptrCast slice to slice" {
242243 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
243244 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
244 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
245 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
245246
246247 const S = struct {
247248 fn foo(slice: []u32) []i32 {
......@@ -281,6 +282,8 @@ test "@ptrCast undefined value at comptime" {
281282}
282283
283284test "comptime @ptrCast with packed struct leaves value unmodified" {
285 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
286
284287 const S = packed struct { three: u3 };
285288 const st: S = .{ .three = 6 };
286289 try expect(st.three == 6);
......@@ -332,7 +335,7 @@ test "@ptrCast restructures comptime-only array" {
332335}
333336
334337test "@ptrCast restructures sliced comptime-only array" {
335 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
338 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
336339
337340 const a3a2: [4][2]comptime_int = .{
338341 .{ 1, 2 },
......@@ -351,7 +354,7 @@ test "@ptrCast restructures sliced comptime-only array" {
351354test "@ptrCast slice multiplying length" {
352355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
353356 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
354 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
357 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
355358
356359 const S = struct {
357360 fn doTheTest(zero: u32) !void {
......@@ -368,7 +371,7 @@ test "@ptrCast slice multiplying length" {
368371test "@ptrCast array pointer to slice multiplying length" {
369372 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
370373 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
371 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
374 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
372375
373376 const S = struct {
374377 fn doTheTest(zero: u32) !void {
......@@ -385,7 +388,7 @@ test "@ptrCast array pointer to slice multiplying length" {
385388test "@ptrCast slice dividing length" {
386389 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
387390 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
388 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
391 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
389392
390393 const S = struct {
391394 fn doTheTest(zero: u8) !void {
......@@ -402,7 +405,7 @@ test "@ptrCast slice dividing length" {
402405test "@ptrCast array pointer to slice dividing length" {
403406 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
404407 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
405 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
408 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
406409
407410 const S = struct {
408411 fn doTheTest(zero: u8) !void {
......@@ -419,7 +422,7 @@ test "@ptrCast array pointer to slice dividing length" {
419422test "@ptrCast slice with complex length increase" {
420423 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
421424 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
422 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
425 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
423426
424427 const TwoBytes = [2]u8;
425428 const ThreeBytes = [3]u8;
......@@ -439,7 +442,7 @@ test "@ptrCast slice with complex length increase" {
439442test "@ptrCast array pointer to slice with complex length increase" {
440443 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
441444 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
442 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
445 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
443446
444447 const TwoBytes = [2]u8;
445448 const ThreeBytes = [3]u8;
......@@ -459,7 +462,7 @@ test "@ptrCast array pointer to slice with complex length increase" {
459462test "@ptrCast slice with complex length decrease" {
460463 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
461464 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
462 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
465 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
463466
464467 const TwoBytes = [2]u8;
465468 const ThreeBytes = [3]u8;
......@@ -479,7 +482,7 @@ test "@ptrCast slice with complex length decrease" {
479482test "@ptrCast array pointer to slice with complex length decrease" {
480483 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
481484 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
482 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
485 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
483486
484487 const TwoBytes = [2]u8;
485488 const ThreeBytes = [3]u8;
......@@ -499,7 +502,7 @@ test "@ptrCast array pointer to slice with complex length decrease" {
499502test "@ptrCast slice of zero-bit type to different slice" {
500503 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
501504 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
502 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
505 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
503506
504507 const S = struct {
505508 fn doTheTest(comptime T: type, zero_bits: []const T) !void {
......@@ -518,7 +521,7 @@ test "@ptrCast slice of zero-bit type to different slice" {
518521test "@ptrCast single-item pointer to slice with length 1" {
519522 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
520523 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
521 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
524 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
522525
523526 const S = struct {
524527 fn doTheTest(comptime T: type, ptr: *const T) !void {
......@@ -538,7 +541,7 @@ test "@ptrCast single-item pointer to slice with length 1" {
538541test "@ptrCast single-item pointer to slice of bytes" {
539542 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
540543 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
541 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
544 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
542545
543546 const S = struct {
544547 fn doTheTest(comptime T: type, ptr: *const T) !void {
test/behavior/ptrfromint.zig+4-3
......@@ -3,7 +3,7 @@ const builtin = @import("builtin");
33const expectEqual = std.testing.expectEqual;
44
55test "casting integer address to function pointer" {
6 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
6 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
77
88 addressToFunction();
99 comptime addressToFunction();
......@@ -18,7 +18,7 @@ fn addressToFunction() void {
1818test "mutate through ptr initialized with constant ptrFromInt value" {
1919 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2020 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2222
2323 forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
2424}
......@@ -35,13 +35,14 @@ fn forceCompilerAnalyzeBranchHardCodedPtrDereference(x: bool) void {
3535test "@ptrFromInt creates null pointer" {
3636 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3737 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
38 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
38 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3939
4040 const ptr = @as(?*u32, @ptrFromInt(0));
4141 try expectEqual(@as(?*u32, null), ptr);
4242}
4343
4444test "@ptrFromInt creates allowzero zero pointer" {
45 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4546 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4647 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4748
test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+1-1
......@@ -7,7 +7,7 @@ var ok: bool = false;
77test "reference a variable in an if after an if in the 2nd switch prong" {
88 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1111
1212 try foo(true, Num.Two, false, "aoeu");
1313 try expect(!ok);
test/behavior/reflection.zig+1
......@@ -26,6 +26,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
2626}
2727
2828test "reflection: @field" {
29 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2930 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3031
3132 var f = Foo{
test/behavior/return_address.zig+1-1
......@@ -8,7 +8,7 @@ fn retAddr() usize {
88test "return address" {
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1212
1313 _ = retAddr();
1414 // TODO: #14938
test/behavior/saturating_arithmetic.zig+14-14
......@@ -16,7 +16,7 @@ test "saturating add" {
1616 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1717 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1818 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
19 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2020 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2121
2222 const S = struct {
......@@ -55,7 +55,7 @@ test "saturating add 128bit" {
5555 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5656 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5757 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
58 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5959 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6060
6161 const S = struct {
......@@ -82,7 +82,7 @@ test "saturating subtraction" {
8282 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8383 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8484 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
85 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
85 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8686 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8787
8888 const S = struct {
......@@ -120,7 +120,7 @@ test "saturating subtraction 128bit" {
120120 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
121121 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
122122 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
123 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
123 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
124124 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
125125
126126 const S = struct {
......@@ -143,7 +143,7 @@ fn testSatMul(comptime T: type, a: T, b: T, expected: T) !void {
143143test "saturating multiplication <= 32 bits" {
144144 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
145145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
146 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
147147 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
148148
149149 try testSatMul(u8, 0, maxInt(u8), 0);
......@@ -207,7 +207,7 @@ test "saturating multiplication <= 32 bits" {
207207test "saturating mul i64, i128" {
208208 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
209209 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
210 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
210 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
211211
212212 try testSatMul(i64, 0, maxInt(i64), 0);
213213 try testSatMul(i64, 0, minInt(i64), 0);
......@@ -236,7 +236,7 @@ test "saturating multiplication" {
236236 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
237237 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
238238 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
239 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
239 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
240240 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
241241
242242 const S = struct {
......@@ -276,7 +276,7 @@ test "saturating shift-left" {
276276 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277277 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
278278 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
279 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
279 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
280280 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
281281
282282 const S = struct {
......@@ -312,7 +312,7 @@ test "saturating shift-left" {
312312test "saturating shift-left large rhs" {
313313 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
314314 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
315 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
315 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
316316 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
317317
318318 {
......@@ -330,7 +330,7 @@ test "saturating shl uses the LHS type" {
330330 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
331331 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
332332 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
333 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
333 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
334334 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
335335
336336 const lhs_const: u8 = 1;
......@@ -358,7 +358,7 @@ test "saturating shl uses the LHS type" {
358358
359359test "sat add > 128 bits" {
360360 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
361 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
361 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
362362
363363 try testSatAdd(u140, 0, 0, 0);
364364 try testSatAdd(u140, maxInt(u140), 1, maxInt(u140));
......@@ -373,7 +373,7 @@ test "sat add > 128 bits" {
373373
374374test "sat sub > 128 bits" {
375375 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
376 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
376 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
377377
378378 try testSatSub(u140, 0, 1, 0);
379379 try testSatSub(u140, maxInt(u140), maxInt(u140), 0);
......@@ -388,7 +388,7 @@ test "sat sub > 128 bits" {
388388
389389test "sat mul > 128 bits" {
390390 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
391 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
391 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
392392
393393 try testSatMul(u140, 0, maxInt(u140), 0);
394394 try testSatMul(u140, 1 << 70, 1 << 69, 1 << 139);
......@@ -403,7 +403,7 @@ test "sat mul > 128 bits" {
403403
404404test "sat shl > 128 bits" {
405405 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
406 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
406 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
407407
408408 try testSatShl(u140, 0, u8, 17, 0);
409409 try testSatShl(u140, 1 << 100, u8, 20, 1 << 120);
test/behavior/select.zig+2-2
......@@ -8,7 +8,7 @@ test "@select vectors" {
88 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
99 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1212
1313 try comptime selectVectors();
1414 try selectVectors();
......@@ -52,7 +52,7 @@ test "@select arrays" {
5252 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5353 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5454 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
55 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
55 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5656
5757 try comptime selectArrays();
5858 try selectArrays();
test/behavior/shuffle.zig+5-3
......@@ -9,7 +9,7 @@ test "@shuffle int" {
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1111 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
12 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1313
1414 const S = struct {
1515 fn doTheTest() !void {
......@@ -50,6 +50,7 @@ test "@shuffle int" {
5050}
5151
5252test "@shuffle int strange sizes" {
53 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
5354 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5455 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5556 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -133,7 +134,8 @@ test "@shuffle bool 1" {
133134 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
134135 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
135136 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
136 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
137 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
138
137139 const S = struct {
138140 fn doTheTest() !void {
139141 var x: @Vector(4, bool) = [4]bool{ false, true, false, true };
......@@ -154,7 +156,7 @@ test "@shuffle bool 2" {
154156 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155157 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156158 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
157 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
159 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
158160
159161 const S = struct {
160162 fn doTheTest() !void {
test/behavior/sizeof_and_typeof.zig+16-6
......@@ -12,6 +12,8 @@ const x: u16 = 13;
1212const z: @TypeOf(x) = 19;
1313
1414test "@TypeOf() with multiple arguments" {
15 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
16
1517 {
1618 var var_1: u32 = undefined;
1719 var var_2: u8 = undefined;
......@@ -73,7 +75,7 @@ const P = packed struct {
7375
7476test "@offsetOf" {
7577 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
76 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
78 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7779
7880 // Packed structs have fixed memory layout
7981 try expect(@offsetOf(P, "a") == 0);
......@@ -100,6 +102,7 @@ test "@offsetOf" {
100102}
101103
102104test "@bitOffsetOf" {
105 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
103106 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
104107
105108 // Packed structs have fixed memory layout
......@@ -134,7 +137,7 @@ test "@TypeOf() has no runtime side effects" {
134137}
135138
136139test "branching logic inside @TypeOf" {
137 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
140 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
138141 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
139142
140143 const S = struct {
......@@ -150,6 +153,8 @@ test "branching logic inside @TypeOf" {
150153}
151154
152155test "@bitSizeOf" {
156 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
157
153158 try expect(@bitSizeOf(u2) == 2);
154159 try expect(@bitSizeOf(u8) == @sizeOf(u8) * 8);
155160 try expect(@bitSizeOf(packed struct {
......@@ -158,6 +163,8 @@ test "@bitSizeOf" {
158163}
159164
160165test "@sizeOf comparison against zero" {
166 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
167
161168 const S0 = struct {
162169 f: *@This(),
163170 };
......@@ -240,6 +247,7 @@ test "lazy size cast to float" {
240247}
241248
242249test "runtime instructions inside typeof in comptime only scope" {
250 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
243251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
244252 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
245253
......@@ -288,7 +296,8 @@ test "lazy abi size used in comparison" {
288296
289297test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
290298 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
291 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
299 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
300
292301 const T = struct {
293302 next: @TypeOf(null, @as(*const @This(), undefined)),
294303 };
......@@ -327,11 +336,11 @@ const exp = struct {
327336 }
328337};
329338comptime {
330 if (builtin.zig_backend != .stage2_spirv) _ = exp;
339 if (!builtin.cpu.arch.isSpirv()) _ = exp;
331340}
332341
333342test "Extern function calls in @TypeOf" {
334 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
343 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
335344
336345 const S = extern struct {
337346 state: c_short,
......@@ -382,6 +391,7 @@ test "Peer resolution of extern function calls in @TypeOf" {
382391}
383392
384393test "Extern function calls, dereferences and field access in @TypeOf" {
394 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
385395 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
386396
387397 const Test = struct {
......@@ -406,7 +416,7 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
406416}
407417
408418test "@sizeOf struct is resolved when used as operand of slicing" {
409 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
419 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
410420
411421 const dummy = struct {};
412422 const S = struct {
test/behavior/slice.zig+55-43
......@@ -30,7 +30,7 @@ comptime {
3030
3131test "slicing" {
3232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
33 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3434
3535 var array: [20]i32 = undefined;
3636
......@@ -59,7 +59,7 @@ test "const slice" {
5959}
6060
6161test "comptime slice of undefined pointer of length 0" {
62 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
62 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6363
6464 const slice1 = @as([*]i32, undefined)[0..0];
6565 try expect(slice1.len == 0);
......@@ -69,7 +69,7 @@ test "comptime slice of undefined pointer of length 0" {
6969
7070test "implicitly cast array of size 0 to slice" {
7171 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
72 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
72 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7373
7474 var msg = [_]u8{};
7575 try assertLenIsZero(&msg);
......@@ -81,7 +81,7 @@ fn assertLenIsZero(msg: []const u8) !void {
8181
8282test "access len index of sentinel-terminated slice" {
8383 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
84 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8585
8686 const S = struct {
8787 fn doTheTest() !void {
......@@ -105,7 +105,7 @@ test "comptime slice of slice preserves comptime var" {
105105
106106test "open slice of open slice with sentinel" {
107107 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
108 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
109109
110110 var slice: [:0]const u8 = "hello";
111111 _ = &slice;
......@@ -123,7 +123,7 @@ test "open slice of open slice with sentinel" {
123123
124124test "open slice with sentinel of slice with end index" {
125125 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
126 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
126 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
127127
128128 var slice: [:0]const u8 = "hello";
129129 _ = &slice;
......@@ -162,6 +162,8 @@ test "slice of type" {
162162}
163163
164164test "pass a slice of types to a function" {
165 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
166
165167 const S = struct {
166168 fn checkTypesSlice(comptime types_slice: []const type) !void {
167169 try expect(types_slice.len == 2);
......@@ -175,7 +177,7 @@ test "pass a slice of types to a function" {
175177
176178test "generic malloc free" {
177179 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
178 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
180 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
179181
180182 const a = memAlloc(u8, 10) catch unreachable;
181183 memFree(u8, a);
......@@ -189,7 +191,8 @@ fn memFree(comptime T: type, memory: []T) void {
189191}
190192
191193test "slice of hardcoded address to pointer" {
192 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
194 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
195
193196 const S = struct {
194197 fn doTheTest() !void {
195198 const pointer = @as([*]u8, @ptrFromInt(0x04))[0..2];
......@@ -213,7 +216,7 @@ test "comptime slice of pointer preserves comptime var" {
213216}
214217
215218test "comptime pointer cast array and then slice" {
216 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
219 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
217220
218221 const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
219222
......@@ -229,7 +232,8 @@ test "comptime pointer cast array and then slice" {
229232
230233test "slicing zero length array" {
231234 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
232 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
235 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
236
233237 const s1 = ""[0..];
234238 const s2 = ([_]u32{})[0..];
235239 try expect(s1.len == 0);
......@@ -239,7 +243,7 @@ test "slicing zero length array" {
239243}
240244
241245test "slicing pointer by length" {
242 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
246 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
243247
244248 const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
245249 const ptr: [*]const u8 = @as([*]const u8, @ptrCast(&array));
......@@ -254,6 +258,8 @@ test "slicing pointer by length" {
254258const x = @as([*]i32, @ptrFromInt(0x1000))[0..0x500];
255259const y = x[0x100..];
256260test "compile time slice of pointer to hard coded address" {
261 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
262
257263 try expect(@intFromPtr(x) == 0x1000);
258264 try expect(x.len == 0x500);
259265
......@@ -262,7 +268,7 @@ test "compile time slice of pointer to hard coded address" {
262268}
263269
264270test "slice string literal has correct type" {
265 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
271 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
266272
267273 comptime {
268274 try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
......@@ -278,7 +284,7 @@ test "slice string literal has correct type" {
278284
279285test "result location zero sized array inside struct field implicit cast to slice" {
280286 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
281 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
287 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
282288
283289 const E = struct {
284290 entries: []u32,
......@@ -291,7 +297,7 @@ test "result location zero sized array inside struct field implicit cast to slic
291297test "runtime safety lets us slice from len..len" {
292298 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
293299 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
294 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
300 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
295301
296302 var an_array = [_]u8{ 1, 2, 3 };
297303 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 {
303309
304310test "C pointer" {
305311 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
306 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
312 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
307313
308314 var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
309315 var len: u32 = 10;
......@@ -315,7 +321,7 @@ test "C pointer" {
315321test "C pointer slice access" {
316322 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
317323 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
318 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
324 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
319325
320326 var buf: [10]u32 = @splat(42);
321327 const c_ptr = @as([*c]const u32, @ptrCast(&buf));
......@@ -345,7 +351,7 @@ fn sliceSum(comptime q: []const u8) i32 {
345351
346352test "slice type with custom alignment" {
347353 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
348 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
354 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
349355
350356 const LazilyResolvedType = struct {
351357 anything: i32,
......@@ -359,7 +365,7 @@ test "slice type with custom alignment" {
359365
360366test "obtaining a null terminated slice" {
361367 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
362 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
368 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
363369
364370 // here we have a normal array
365371 var buf: [50]u8 = undefined;
......@@ -385,6 +391,8 @@ test "obtaining a null terminated slice" {
385391}
386392
387393test "empty array to slice" {
394 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
395
388396 const S = struct {
389397 fn doTheTest() !void {
390398 const empty: []align(16) u8 = &[_]u8{};
......@@ -422,7 +430,7 @@ test "comptime-known slice of a global constant" {
422430
423431test "@ptrCast slice to pointer" {
424432 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
425 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
433 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
426434
427435 const S = struct {
428436 fn doTheTest() !void {
......@@ -439,7 +447,7 @@ test "@ptrCast slice to pointer" {
439447
440448test "slice multi-pointer without end" {
441449 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
442 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
450 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
443451
444452 const S = struct {
445453 fn doTheTest() !void {
......@@ -477,7 +485,7 @@ test "slice multi-pointer without end" {
477485test "slice syntax resulting in pointer-to-array" {
478486 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
479487 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
480 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
488 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
481489
482490 const S = struct {
483491 fn doTheTest() !void {
......@@ -692,7 +700,7 @@ test "slice syntax resulting in pointer-to-array" {
692700
693701test "slice pointer-to-array null terminated" {
694702 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
695 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
703 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
696704
697705 comptime {
698706 var array = [5:0]u8{ 1, 2, 3, 4, 5 };
......@@ -711,7 +719,7 @@ test "slice pointer-to-array null terminated" {
711719
712720test "slice pointer-to-array zero length" {
713721 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
714 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
722 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
715723
716724 comptime {
717725 {
......@@ -745,7 +753,7 @@ test "slice pointer-to-array zero length" {
745753test "type coercion of pointer to anon struct literal to pointer to slice" {
746754 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
747755 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
748 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
756 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
749757
750758 const S = struct {
751759 const U = union {
......@@ -792,7 +800,7 @@ test "array concat of slices gives ptr to array" {
792800
793801test "slice bounds in comptime concatenation" {
794802 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
795 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
803 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
796804
797805 const bs = comptime blk: {
798806 const b = "........1........";
......@@ -808,6 +816,8 @@ test "slice bounds in comptime concatenation" {
808816}
809817
810818test "slice sentinel access at comptime" {
819 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
820
811821 {
812822 const str0 = &[_:0]u8{ '1', '2', '3' };
813823 const slice0: [:0]const u8 = str0;
......@@ -833,7 +843,8 @@ test "slice sentinel access at comptime" {
833843
834844test "slicing array with sentinel as end index" {
835845 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
836 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
846 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
847
837848 const S = struct {
838849 fn do() !void {
839850 var array = [_:0]u8{ 1, 2, 3, 4 };
......@@ -850,7 +861,7 @@ test "slicing array with sentinel as end index" {
850861
851862test "slicing slice with sentinel as end index" {
852863 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
853 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
864 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
854865
855866 const S = struct {
856867 fn do() !void {
......@@ -879,7 +890,8 @@ test "slice len modification at comptime" {
879890}
880891
881892test "slice field ptr const" {
882 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
893 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
894
883895 const const_slice: []const u8 = "string";
884896
885897 const const_ptr_const_slice = &const_slice;
......@@ -909,7 +921,7 @@ test "global slice field access" {
909921 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
910922 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
911923 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
912 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
924 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
913925
914926 const S = struct {
915927 var slice: []const u8 = undefined;
......@@ -921,7 +933,7 @@ test "global slice field access" {
921933}
922934
923935test "slice of void" {
924 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
936 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
925937
926938 var n: usize = 10;
927939 _ = &n;
......@@ -931,7 +943,7 @@ test "slice of void" {
931943}
932944
933945test "slice with dereferenced value" {
934 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
946 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
935947
936948 var a: usize = 0;
937949 const idx: *usize = &a;
......@@ -947,7 +959,7 @@ test "slice with dereferenced value" {
947959}
948960
949961test "empty slice ptr is non null" {
950 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // Test assumes `undefined` is non-zero
962 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // Test assumes `undefined` is non-zero
951963
952964 {
953965 const empty_slice: []u8 = &[_]u8{};
......@@ -965,7 +977,7 @@ test "empty slice ptr is non null" {
965977
966978test "slice decays to many pointer" {
967979 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
968 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
980 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
969981
970982 var buf: [8]u8 = "abcdefg\x00".*;
971983 const p: [*:0]const u8 = buf[0..7 :0];
......@@ -975,7 +987,7 @@ test "slice decays to many pointer" {
975987test "write through pointer to optional slice arg" {
976988 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
977989 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
978 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
990 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
979991
980992 const S = struct {
981993 fn bar(foo: *?[]const u8) !void {
......@@ -994,7 +1006,7 @@ test "write through pointer to optional slice arg" {
9941006test "modify slice length at comptime" {
9951007 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9961008 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
997 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1009 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9981010
9991011 const arr: [2]u8 = .{ 10, 20 };
10001012 comptime var s: []const u8 = arr[0..0];
......@@ -1009,7 +1021,7 @@ test "modify slice length at comptime" {
10091021
10101022test "slicing zero length array field of struct" {
10111023 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1012 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1024 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10131025 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10141026
10151027 const S = struct {
......@@ -1024,7 +1036,7 @@ test "slicing zero length array field of struct" {
10241036
10251037test "slicing slices gives correct result" {
10261038 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1027 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1039 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10281040
10291041 const foo = "1234";
10301042 const bar = foo[0..4];
......@@ -1037,7 +1049,7 @@ test "slicing slices gives correct result" {
10371049
10381050test "get address of element of zero-sized slice" {
10391051 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1040 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1052 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10411053
10421054 const S = struct {
10431055 fn destroy(_: *void) void {}
......@@ -1049,7 +1061,7 @@ test "get address of element of zero-sized slice" {
10491061
10501062test "sentinel-terminated 0-length slices" {
10511063 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1052 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1064 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10531065
10541066 const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
10551067
......@@ -1068,7 +1080,7 @@ test "sentinel-terminated 0-length slices" {
10681080}
10691081
10701082test "peer slices keep abi alignment with empty struct" {
1071 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1083 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10721084
10731085 var cond: bool = undefined;
10741086 cond = false;
......@@ -1078,7 +1090,7 @@ test "peer slices keep abi alignment with empty struct" {
10781090}
10791091
10801092test "sentinel expression in slice operation has result type" {
1081 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1093 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10821094
10831095 const sentinel = std.math.maxInt(u16);
10841096
......@@ -1101,7 +1113,7 @@ test "sentinel expression in slice operation has result type" {
11011113}
11021114
11031115test "conditionally return second argument slice" {
1104 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1116 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11051117
11061118 const S = struct {
11071119 fn foo(cond: bool, slice: []const u8) []const u8 {
......@@ -1115,7 +1127,7 @@ test "conditionally return second argument slice" {
11151127}
11161128
11171129test "slice field alignment" {
1118 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1130 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11191131
11201132 const S = struct {
11211133 fn doTheTest(p: *align(1) const []u8) !void {
test/behavior/spirv.zig+5
......@@ -1,4 +1,5 @@
11const std = @import("std");
2const builtin = @import("builtin");
23const expect = std.testing.expect;
34
45const Sampler = @SpirvType(.sampler);
......@@ -50,6 +51,8 @@ test "@SpirvType" {
5051}
5152
5253test "@ptrCast to first field type" {
54 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
55
5356 const Inner = extern struct { a: u32 };
5457 const Outer = extern struct { a: Inner, b: u32 };
5558 var outer: Outer = undefined;
......@@ -58,6 +61,8 @@ test "@ptrCast to first field type" {
5861}
5962
6063test "@SpirvType equality" {
64 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
65
6166 try expect(@SpirvType(.sampler) == Sampler);
6267 try expect(@SpirvType(.{ .runtime_array = u32 }) == RuntimeArray);
6368 try expect(@SpirvType(.{ .sampled_image = Image }) == SampledImage);
test/behavior/splat.zig+6-3
......@@ -5,6 +5,7 @@ const expect = std.testing.expect;
55const assert = std.debug.assert;
66
77test "@splat array" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
910 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1011
......@@ -33,7 +34,7 @@ test "@splat array" {
3334}
3435
3536test "@splat array with sentinel" {
36 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
37 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3738 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3839 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3940
......@@ -56,7 +57,7 @@ test "@splat array with sentinel" {
5657}
5758
5859test "@splat zero-length array" {
59 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
60 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6061 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6162 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6263
......@@ -79,6 +80,7 @@ test "@splat zero-length array" {
7980}
8081
8182test "splat with an error union or optional result type" {
83 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
8284 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8385
8486 const S = struct {
......@@ -92,7 +94,7 @@ test "splat with an error union or optional result type" {
9294}
9395
9496test "read/write through global variable array of struct fields initialized via splat" {
95 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
97 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9698 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9799 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98100
......@@ -113,6 +115,7 @@ test "read/write through global variable array of struct fields initialized via
113115}
114116
115117test "vector @splat" {
118 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
116119 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
117120 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
118121 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/src.zig+1-1
......@@ -18,7 +18,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
1818test "@src" {
1919 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2020 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2222
2323 try doTheTest();
2424}
test/behavior/string_literals.zig+8-7
......@@ -7,7 +7,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
77
88test "@tagName() returns a string literal" {
99 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1111
1212 try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
1313 try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
......@@ -20,7 +20,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
2020
2121test "@errorName() returns a string literal" {
2222 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
23 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2424
2525 try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
2626 try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
......@@ -33,7 +33,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
3333
3434test "@typeName() returns a string literal" {
3535 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
36 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
36 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3737
3838 try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
3939 try std.testing.expect(std.mem.eql(u8, "behavior.string_literals.TestType", type_name));
......@@ -47,7 +47,7 @@ const expected_contents = "hello zig\n";
4747test "@embedFile() returns a string literal" {
4848 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4949 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
50 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
50 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5151
5252 try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
5353 try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
......@@ -62,7 +62,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
6262test "@src() returns a struct containing 0-terminated string slices" {
6363 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6464 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
65 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
65 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6666
6767 const src = testFnForSrc();
6868 try std.testing.expect([:0]const u8 == @TypeOf(src.file));
......@@ -84,7 +84,7 @@ test "string literal pointer sentinel" {
8484}
8585
8686test "sentinel slice of string literal" {
87 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
87 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8888
8989 const string = "Hello!\x00World!";
9090 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"
102102}
103103
104104test "including the sentinel when dereferencing a string literal" {
105 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
105 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
106
106107 var var_str = "abc";
107108 const var_derefed = var_str[0 .. var_str.len + 1].*;
108109
test/behavior/struct.zig+105-42
......@@ -10,6 +10,7 @@ const maxInt = std.math.maxInt;
1010top_level_field: i32,
1111
1212test "top level fields" {
13 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1314 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1415
1516 var instance = @This(){
......@@ -43,6 +44,7 @@ const StructWithFields = struct {
4344};
4445
4546test "non-packed struct has fields padded out to the required alignment" {
47 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4648 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4749
4850 const foo = StructWithFields{ .a = 5, .b = 1, .c = 10, .d = 2 };
......@@ -66,6 +68,7 @@ const SmallStruct = struct {
6668};
6769
6870test "lower unnamed constants" {
71 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
6972 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7073
7174 var foo = SmallStruct{ .a = 1, .b = 255 };
......@@ -88,7 +91,7 @@ const StructFoo = struct {
8891test "structs" {
8992 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9093 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
91 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
94 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9295
9396 var foo: StructFoo = undefined;
9497 @memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0);
......@@ -106,6 +109,7 @@ fn testMutation(foo: *StructFoo) void {
106109}
107110
108111test "struct byval assign" {
112 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
109113 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
110114
111115 var foo1: StructFoo = undefined;
......@@ -170,6 +174,7 @@ const MemberFnTestFoo = struct {
170174};
171175
172176test "call member function directly" {
177 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
173178 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
174179
175180 const instance = MemberFnTestFoo{ .x = 1234 };
......@@ -178,6 +183,7 @@ test "call member function directly" {
178183}
179184
180185test "store member function in variable" {
186 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
181187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
182188
183189 const instance = MemberFnTestFoo{ .x = 1234 };
......@@ -187,6 +193,7 @@ test "store member function in variable" {
187193}
188194
189195test "member functions" {
196 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
190197 const r = MemberFnRand{ .seed = 1234 };
191198 try expect(r.getSeed() == 1234);
192199}
......@@ -198,6 +205,7 @@ const MemberFnRand = struct {
198205};
199206
200207test "return struct byval from function" {
208 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
201209 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
202210
203211 const Bar = struct {
......@@ -215,6 +223,7 @@ test "return struct byval from function" {
215223}
216224
217225test "call method with mutable reference to struct with no fields" {
226 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
218227 const S = struct {
219228 fn doC(s: *const @This()) bool {
220229 _ = s;
......@@ -234,6 +243,7 @@ test "call method with mutable reference to struct with no fields" {
234243}
235244
236245test "struct field init with catch" {
246 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
237247 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
238248
239249 const S = struct {
......@@ -277,7 +287,7 @@ const Val = struct {
277287
278288test "struct point to self" {
279289 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
280 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
290 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
281291
282292 var root: Node = undefined;
283293 root.val.x = 1;
......@@ -320,7 +330,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
320330
321331test "pass slice of empty struct to fn" {
322332 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
323 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
333 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
324334
325335 try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
326336}
......@@ -331,7 +341,7 @@ fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize {
331341test "self-referencing struct via array member" {
332342 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
333343 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
334 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
344 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
335345
336346 const T = struct {
337347 children: [1]*@This(),
......@@ -342,6 +352,8 @@ test "self-referencing struct via array member" {
342352}
343353
344354test "empty struct method call" {
355 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
356
345357 const es = EmptyStruct{};
346358 try expect(es.method() == 1234);
347359}
......@@ -355,7 +367,7 @@ const EmptyStruct = struct {
355367test "align 1 field before self referential align 8 field as slice return type" {
356368 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
357369 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
358 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
370 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
359371
360372 const result = alloc(Expr);
361373 try expect(result.len == 0);
......@@ -376,6 +388,7 @@ const APackedStruct = packed struct {
376388};
377389
378390test "packed struct" {
391 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
379392 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
380393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
381394 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
......@@ -401,7 +414,7 @@ const Foo96Bits = packed struct {
401414
402415test "packed struct 24bits" {
403416 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
404 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
417 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
405418 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
406419 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
407420 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
......@@ -443,7 +456,7 @@ test "packed struct 24bits" {
443456}
444457
445458test "runtime struct initialization of bitfield" {
446 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
459 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
447460 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
448461 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
449462 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -486,7 +499,8 @@ test "packed struct fields are ordered from LSB to MSB" {
486499 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
487500 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488501 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
489 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
502 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
503
490504 var all: u64 = 0x7765443322221111;
491505 var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;
492506 @memcpy(bytes[0..8], @as([*]u8, @ptrCast(&all)));
......@@ -502,6 +516,7 @@ test "packed struct fields are ordered from LSB to MSB" {
502516}
503517
504518test "implicit cast packed struct field to const ptr" {
519 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
505520 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
506521 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
507522 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -523,6 +538,7 @@ test "implicit cast packed struct field to const ptr" {
523538}
524539
525540test "zero-bit field in packed struct" {
541 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
526542 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
527543
528544 const S = packed struct {
......@@ -537,7 +553,7 @@ test "packed struct with non-ABI-aligned field" {
537553 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
538554 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
539555 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
540 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
556 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
541557 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
542558
543559 const S = packed struct {
......@@ -564,6 +580,7 @@ const bit_field_1 = BitField1{
564580};
565581
566582test "bit field access" {
583 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
567584 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
568585 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
569586 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -596,6 +613,7 @@ fn getC(data: *const BitField1) u2 {
596613}
597614
598615test "default struct initialization fields" {
616 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
599617 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
600618
601619 const S = struct {
......@@ -622,7 +640,7 @@ test "packed array 24bits" {
622640 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
623641 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
624642 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
625 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
643 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
626644
627645 comptime {
628646 try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
......@@ -686,6 +704,7 @@ const FooArrayOfAligned = packed struct {
686704};
687705
688706test "pointer to packed struct member in a stack variable" {
707 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
689708 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
690709 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
691710 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -715,7 +734,7 @@ test "packed struct with u0 field access" {
715734}
716735
717736test "access to global struct fields" {
718 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
737 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
719738 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
720739
721740 g_foo.bar.value = 42;
......@@ -739,7 +758,7 @@ var g_foo: S0 = S0.init();
739758test "packed struct with fp fields" {
740759 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
741760 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
742 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
761 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
743762 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
744763 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
745764
......@@ -766,6 +785,7 @@ test "packed struct with fp fields" {
766785}
767786
768787test "fn with C calling convention returns struct by value" {
788 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
769789 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
770790 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
771791
......@@ -792,7 +812,7 @@ test "fn with C calling convention returns struct by value" {
792812test "non-packed struct with u128 entry in union" {
793813 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
794814 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
795 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
815 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
796816 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
797817
798818 const U = union(enum) {
......@@ -815,6 +835,7 @@ test "non-packed struct with u128 entry in union" {
815835}
816836
817837test "packed struct field passed to generic function" {
838 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
818839 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
819840 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
820841 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -839,6 +860,7 @@ test "packed struct field passed to generic function" {
839860}
840861
841862test "anonymous struct literal syntax" {
863 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
842864 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
843865
844866 const S = struct {
......@@ -862,6 +884,8 @@ test "anonymous struct literal syntax" {
862884}
863885
864886test "fully anonymous struct" {
887 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
888
865889 const S = struct {
866890 fn doTheTest() !void {
867891 try dump(.{
......@@ -884,6 +908,8 @@ test "fully anonymous struct" {
884908}
885909
886910test "fully anonymous list literal" {
911 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
912
887913 const S = struct {
888914 fn doTheTest() !void {
889915 try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
......@@ -901,6 +927,8 @@ test "fully anonymous list literal" {
901927}
902928
903929test "tuple assigned to variable" {
930 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
931
904932 var vec = .{ @as(i32, 22), @as(i32, 55), @as(i32, 99) };
905933 _ = &vec;
906934 try expect(vec.@"0" == 22);
......@@ -912,6 +940,7 @@ test "tuple assigned to variable" {
912940}
913941
914942test "comptime struct field" {
943 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
915944 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
916945
917946 const T = struct {
......@@ -927,7 +956,7 @@ test "comptime struct field" {
927956}
928957
929958test "tuple element initialized with fn call" {
930 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
959 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
931960 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
932961 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
933962
......@@ -945,6 +974,7 @@ test "tuple element initialized with fn call" {
945974}
946975
947976test "struct with union field" {
977 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
948978 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
949979 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
950980
......@@ -965,6 +995,7 @@ test "struct with union field" {
965995}
966996
967997test "struct with 0-length union array field" {
998 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
968999 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9691000 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9701001
......@@ -983,7 +1014,7 @@ test "struct with 0-length union array field" {
9831014}
9841015
9851016test "packed struct with undefined initializers" {
986 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1017 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9871018 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9881019 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9891020 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1014,7 +1045,7 @@ test "packed struct with undefined initializers" {
10141045}
10151046
10161047test "for loop over pointers to struct, getting field from struct pointer" {
1017 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1048 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10181049 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10191050 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10201051
......@@ -1056,7 +1087,7 @@ test "anon init through error unions and optionals" {
10561087 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10571088 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10581089 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1059 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1090 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10601091
10611092 const S = struct {
10621093 a: u32,
......@@ -1080,6 +1111,7 @@ test "anon init through error unions and optionals" {
10801111}
10811112
10821113test "anon init through optional" {
1114 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10831115 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10841116 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10851117
......@@ -1100,7 +1132,7 @@ test "anon init through optional" {
11001132test "anon init through error union" {
11011133 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11021134 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1103 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1135 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11041136
11051137 const S = struct {
11061138 a: u32,
......@@ -1117,6 +1149,7 @@ test "anon init through error union" {
11171149}
11181150
11191151test "typed init through error unions and optionals" {
1152 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11201153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11211154 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11221155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1143,6 +1176,7 @@ test "typed init through error unions and optionals" {
11431176}
11441177
11451178test "initialize struct with empty literal" {
1179 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11461180 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11471181
11481182 const S = struct { x: i32 = 1234 };
......@@ -1152,6 +1186,7 @@ test "initialize struct with empty literal" {
11521186}
11531187
11541188test "loading a struct pointer perfoms a copy" {
1189 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11551190 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11561191
11571192 const S = struct {
......@@ -1197,6 +1232,7 @@ test "packed struct aggregate init" {
11971232}
11981233
11991234test "packed struct field access via pointer" {
1235 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12001236 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12011237 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12021238 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1237,6 +1273,7 @@ test "store to comptime field" {
12371273}
12381274
12391275test "struct field init value is size of the struct" {
1276 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12401277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12411278
12421279 const namespace = struct {
......@@ -1253,7 +1290,7 @@ test "struct field init value is size of the struct" {
12531290test "under-aligned struct field" {
12541291 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12551292 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1256 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1293 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12571294 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12581295
12591296 const U = extern union {
......@@ -1275,7 +1312,7 @@ test "under-aligned struct field" {
12751312
12761313test "fieldParentPtr of a zero-bit field" {
12771314 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1278 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1315 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12791316 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12801317
12811318 const S = struct {
......@@ -1323,7 +1360,7 @@ test "fieldParentPtr of a zero-bit field" {
13231360}
13241361
13251362test "struct field has a pointer to an aligned version of itself" {
1326 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1363 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13271364
13281365 const E = struct {
13291366 next: *align(1) @This(),
......@@ -1335,7 +1372,7 @@ test "struct field has a pointer to an aligned version of itself" {
13351372}
13361373
13371374test "struct has only one reference" {
1338 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1375 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13391376
13401377 const S = struct {
13411378 fn optionalStructParam(_: ?struct { x: u8 }) void {}
......@@ -1384,7 +1421,7 @@ test "struct has only one reference" {
13841421
13851422test "no dependency loop on pointer to optional struct" {
13861423 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1387 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1424 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13881425
13891426 const S = struct {
13901427 const A = struct { b: B };
......@@ -1404,7 +1441,7 @@ test "discarded struct initialization works as expected" {
14041441}
14051442
14061443test "function pointer in struct returns the struct" {
1407 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1444 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14081445
14091446 const A = struct {
14101447 const A = @This();
......@@ -1420,7 +1457,7 @@ test "function pointer in struct returns the struct" {
14201457}
14211458
14221459test "no dependency loop on optional field wrapped in generic function" {
1423 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1460 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14241461
14251462 const S = struct {
14261463 fn Atomic(comptime T: type) type {
......@@ -1438,6 +1475,7 @@ test "no dependency loop on optional field wrapped in generic function" {
14381475}
14391476
14401477test "optional field init with tuple" {
1478 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14411479 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14421480
14431481 const S = struct {
......@@ -1452,6 +1490,8 @@ test "optional field init with tuple" {
14521490}
14531491
14541492test "if inside struct init inside if" {
1493 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1494
14551495 const MyStruct = struct { x: u32 };
14561496 const b: u32 = 5;
14571497 var i: u32 = 1;
......@@ -1478,7 +1518,7 @@ test "optional generic function label struct field" {
14781518}
14791519
14801520test "struct fields get automatically reordered" {
1481 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1521 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14821522 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
14831523
14841524 const S1 = struct {
......@@ -1539,7 +1579,7 @@ test "instantiate struct with comptime field" {
15391579test "struct field pointer has correct alignment" {
15401580 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15411581 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1542 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1582 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15431583
15441584 const S = struct {
15451585 fn doTheTest() !void {
......@@ -1568,7 +1608,7 @@ test "struct field pointer has correct alignment" {
15681608test "extern struct field pointer has correct alignment" {
15691609 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15701610 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1571 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1611 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15721612
15731613 const S = struct {
15741614 fn doTheTest() !void {
......@@ -1617,6 +1657,8 @@ fn countFields(v: anytype) usize {
16171657}
16181658
16191659test "struct init with no result pointer sets field result types" {
1660 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1661
16201662 const S = struct {
16211663 // A function parameter has a result type, but no result pointer.
16221664 fn f(s: struct { x: u32 }) u32 {
......@@ -1631,6 +1673,8 @@ test "struct init with no result pointer sets field result types" {
16311673}
16321674
16331675test "runtime side-effects in comptime-known struct init" {
1676 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1677
16341678 var side_effects: u4 = 0;
16351679 const S = struct { a: u4, b: u4, c: u4, d: u4 };
16361680 const init = S{
......@@ -1656,7 +1700,7 @@ test "runtime side-effects in comptime-known struct init" {
16561700}
16571701
16581702test "pointer to struct initialized through reference to anonymous initializer provides result types" {
1659 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1703 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16601704
16611705 const S = struct { a: u8, b: u16, c: *const anyopaque };
16621706 var my_u16: u16 = 0xABCD;
......@@ -1693,6 +1737,8 @@ test "comptimeness of optional and error union payload is analyzed properly" {
16931737}
16941738
16951739test "initializer uses own alignment" {
1740 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1741
16961742 const S = struct {
16971743 x: u32 = @alignOf(@This()) + 1,
16981744 };
......@@ -1704,6 +1750,8 @@ test "initializer uses own alignment" {
17041750}
17051751
17061752test "initializer uses own size" {
1753 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1754
17071755 const S = struct {
17081756 x: u32 = @sizeOf(@This()) + 1,
17091757 };
......@@ -1715,7 +1763,7 @@ test "initializer uses own size" {
17151763}
17161764
17171765test "initializer takes a pointer to a variable inside its struct" {
1718 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1766 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17191767
17201768 const namespace = struct {
17211769 const S = struct {
......@@ -1735,7 +1783,7 @@ test "initializer takes a pointer to a variable inside its struct" {
17351783}
17361784
17371785test "circular dependency through pointer field of a struct" {
1738 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1786 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17391787
17401788 const S = struct {
17411789 const StructInner = extern struct {
......@@ -1758,7 +1806,7 @@ test "circular dependency through pointer field of a struct" {
17581806}
17591807
17601808test "field calls do not force struct field init resolution" {
1761 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1809 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17621810
17631811 const S = struct {
17641812 x: u32 = blk: {
......@@ -1787,6 +1835,7 @@ test "tuple with comptime-only field" {
17871835}
17881836
17891837test "extern struct fields are aligned to 1" {
1838 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
17901839 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17911840
17921841 const Foo = extern struct {
......@@ -1806,7 +1855,7 @@ test "assign to slice.len of global variable" {
18061855 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
18071856 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18081857 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1809 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1858 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18101859 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
18111860
18121861 const S = struct {
......@@ -1819,6 +1868,8 @@ test "assign to slice.len of global variable" {
18191868}
18201869
18211870test "pointers to fields of volatile pointer to struct are also volatile" {
1871 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1872
18221873 const B = extern struct {
18231874 a: u32,
18241875 b: i32,
......@@ -1833,6 +1884,8 @@ test "pointers to fields of volatile pointer to struct are also volatile" {
18331884}
18341885
18351886test "pointers to fields of volatile pointer to union are also volatile" {
1887 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1888
18361889 const D = extern union {
18371890 a: u32,
18381891 b: i32,
......@@ -1856,7 +1909,7 @@ test "array of structs inside struct initialized with undefined" {
18561909
18571910test "runtime call in nested initializer" {
18581911 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1859 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1912 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18601913
18611914 const Holder = struct {
18621915 array: []const u8,
......@@ -1886,6 +1939,7 @@ test "runtime call in nested initializer" {
18861939}
18871940
18881941test "runtime value in nested initializer passed as pointer to function" {
1942 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
18891943 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18901944
18911945 const Bar = struct {
......@@ -1909,7 +1963,7 @@ test "runtime value in nested initializer passed as pointer to function" {
19091963}
19101964
19111965test "struct field default value is a call" {
1912 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1966 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19131967 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19141968 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19151969
......@@ -1943,6 +1997,8 @@ test "struct field default value is a call" {
19431997}
19441998
19451999test "aggregate initializers should allow initializing comptime fields, verifying equality" {
2000 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2001
19462002 var x: u32 = 15;
19472003 _ = &x;
19482004 const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
......@@ -1954,6 +2010,7 @@ test "aggregate initializers should allow initializing comptime fields, verifyin
19542010}
19552011
19562012test "assignment of field with padding" {
2013 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
19572014 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19582015 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19592016
......@@ -1983,7 +2040,7 @@ test "assignment of field with padding" {
19832040}
19842041
19852042test "initiate global variable with runtime value" {
1986 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2043 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19872044 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19882045 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19892046
......@@ -2002,7 +2059,7 @@ test "initiate global variable with runtime value" {
20022059}
20032060
20042061test "struct containing optional pointer to array of @This()" {
2005 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2062 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
20062063
20072064 const S = struct {
20082065 x: ?*const [1]@This(),
......@@ -2075,6 +2132,7 @@ test "anonymous struct equivalence" {
20752132}
20762133
20772134test "field access through mem ptr arg" {
2135 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
20782136 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20792137 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20802138
......@@ -2118,7 +2176,7 @@ test "field access through mem ptr arg" {
21182176}
21192177
21202178test "align 1 struct parameter dereferenced and returned" {
2121 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2179 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
21222180
21232181 const S = extern struct {
21242182 a: u32,
......@@ -2169,7 +2227,8 @@ test "pass a pointer to a comptime-only struct field to a function" {
21692227}
21702228
21712229test "overaligned extern struct fields" {
2172 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2230 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2231
21732232 const A = struct {
21742233 a: *anyopaque,
21752234 b: u64,
......@@ -2219,7 +2278,8 @@ test "overaligned extern struct fields" {
22192278}
22202279
22212280test "runtime-known slice of comptime-only struct" {
2222 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2281 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2282
22232283 const Mixed = struct { index: u32, T: type };
22242284
22252285 const static = struct {
......@@ -2241,7 +2301,8 @@ test "runtime-known slice of comptime-only struct" {
22412301}
22422302
22432303test "struct contains aligned pointer to itself through type decl" {
2244 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2304 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2305
22452306 const Slab = struct {
22462307 const Ptr = *align(64) const @This();
22472308 next: Ptr,
......@@ -2259,7 +2320,7 @@ test "struct contains aligned pointer to itself through type decl" {
22592320}
22602321
22612322test "struct contains underaligned field with overaligned pointer to itself" {
2262 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2323 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
22632324 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
22642325
22652326 const S = struct {
......@@ -2295,6 +2356,8 @@ test "struct queries typeinfo of struct containing pointer back to first struct"
22952356}
22962357
22972358test "pointer to runtime field of struct containing struct containing comptime-only optional" {
2359 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2360
22982361 const Foo = struct {
22992362 padding: struct { a: u8, b: ?comptime_int },
23002363 number: u8,
test/behavior/struct_contains_null_ptr_itself.zig+1-1
......@@ -4,7 +4,7 @@ const builtin = @import("builtin");
44
55test "struct contains null pointer which contains original struct" {
66 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
88
99 var x: ?*NodeLineComment = null;
1010 _ = &x;
test/behavior/struct_contains_slice_of_itself.zig+2-2
......@@ -13,7 +13,7 @@ const NodeAligned = struct {
1313
1414test "struct contains slice of itself" {
1515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
16 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1717
1818 var other_nodes = [_]Node{
1919 Node{
......@@ -53,7 +53,7 @@ test "struct contains slice of itself" {
5353
5454test "struct contains aligned slice of itself" {
5555 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
56 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5757
5858 var other_nodes = [_]NodeAligned{
5959 NodeAligned{
test/behavior/switch.zig+52-13
......@@ -23,6 +23,7 @@ fn testSwitchWithNumbers(x: u32) !void {
2323}
2424
2525test "switch with all ranges" {
26 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2627 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2728
2829 try expect(testSwitchWithAllRanges(50, 3) == 1);
......@@ -44,7 +45,7 @@ test "switch arbitrary int size" {
4445 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4546 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4647 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
48 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
4849 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
4950
5051 const S = struct {
......@@ -258,6 +259,7 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
258259}
259260
260261test "switching on booleans" {
262 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
261263 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
262264
263265 try testSwitchOnBools();
......@@ -313,6 +315,7 @@ test "undefined.u0" {
313315}
314316
315317test "switch with disjoint range" {
318 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
316319 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
317320 var q: u8 = 0;
318321 _ = &q;
......@@ -324,6 +327,8 @@ test "switch with disjoint range" {
324327}
325328
326329test "switch variable for range and multiple prongs" {
330 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
331
327332 const S = struct {
328333 fn doTheTest() !void {
329334 try doTheSwitch(16);
......@@ -354,7 +359,7 @@ fn poll() void {
354359}
355360
356361test "switch on global mutable var isn't constant-folded" {
357 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
362 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
358363 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
359364
360365 while (state < 2) {
......@@ -369,6 +374,7 @@ const SwitchProngWithVarEnum = union(enum) {
369374};
370375
371376test "switch prong with variable" {
377 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
372378 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
373379 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
374380 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -394,6 +400,7 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void {
394400}
395401
396402test "switch on enum using pointer capture" {
403 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
397404 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
398405 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
399406
......@@ -414,6 +421,7 @@ fn testSwitchEnumPtrCapture() !void {
414421}
415422
416423test "switch handles all cases of number" {
424 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
417425 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
418426
419427 try testSwitchHandleAllCases();
......@@ -453,6 +461,7 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 {
453461}
454462
455463test "switch on union with some prongs capturing" {
464 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
456465 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
457466 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
458467
......@@ -490,6 +499,7 @@ test "switch on const enum with var" {
490499}
491500
492501test "anon enum literal used in switch on union enum" {
502 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
493503 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
494504
495505 const Foo = union(enum) {
......@@ -506,6 +516,7 @@ test "anon enum literal used in switch on union enum" {
506516}
507517
508518test "switch all prongs unreachable" {
519 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
509520 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
510521
511522 try testAllProngsUnreachable();
......@@ -529,6 +540,7 @@ fn switchWithUnreachable(x: i32) i32 {
529540}
530541
531542test "capture value of switch with all unreachable prongs" {
543 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
532544 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
533545
534546 const x = return_a_number() catch |err| switch (err) {
......@@ -562,7 +574,7 @@ test "switch on integer with else capturing expr" {
562574test "else prong of switch on error set excludes other cases" {
563575 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
564576 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
565 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
577 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
566578 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
567579
568580 const S = struct {
......@@ -597,7 +609,7 @@ test "else prong of switch on error set excludes other cases" {
597609test "switch prongs with error set cases make a new error set type for capture value" {
598610 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
599611 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
600 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
612 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
601613 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
602614
603615 const S = struct {
......@@ -632,6 +644,7 @@ test "switch prongs with error set cases make a new error set type for capture v
632644}
633645
634646test "return result loc and then switch with range implicit casted to error union" {
647 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
635648 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
636649
637650 const S = struct {
......@@ -650,6 +663,7 @@ test "return result loc and then switch with range implicit casted to error unio
650663}
651664
652665test "switch with null and T peer types and inferred result location type" {
666 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
653667 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
654668 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
655669
......@@ -669,6 +683,7 @@ test "switch with null and T peer types and inferred result location type" {
669683}
670684
671685test "switch prongs with cases with identical payload types" {
686 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
672687 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
673688 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
674689
......@@ -777,7 +792,7 @@ test "switch prong pointer capture alignment" {
777792test "switch on pointer type" {
778793 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
779794 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
780 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
795 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
781796 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/176634
782797
783798 const S = struct {
......@@ -824,6 +839,7 @@ test "switch on error set with single else" {
824839}
825840
826841test "switch capture copies its payload" {
842 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
827843 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
828844 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
829845
......@@ -915,6 +931,8 @@ test "comptime inline switch" {
915931}
916932
917933test "switch capture peer type resolution" {
934 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
935
918936 const U = union(enum) {
919937 a: u32,
920938 b: u64,
......@@ -930,6 +948,7 @@ test "switch capture peer type resolution" {
930948}
931949
932950test "switch capture peer type resolution for in-memory coercible payloads" {
951 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
933952 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
934953
935954 const T1 = c_int;
......@@ -954,7 +973,7 @@ test "switch capture peer type resolution for in-memory coercible payloads" {
954973
955974test "switch pointer capture peer type resolution" {
956975 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
957 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
976 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
958977
959978 const T1 = c_int;
960979 const t1_info = @typeInfo(T1).int;
......@@ -983,6 +1002,8 @@ test "switch pointer capture peer type resolution" {
9831002}
9841003
9851004test "inline switch range that includes the maximum value of the switched type" {
1005 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1006
9861007 const inputs: [3]u8 = .{ 0, 254, 255 };
9871008 for (inputs) |input| {
9881009 switch (input) {
......@@ -995,7 +1016,7 @@ test "inline switch range that includes the maximum value of the switched type"
9951016test "nested break ignores switch conditions and breaks instead" {
9961017 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9971018 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
998 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1019 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9991020
10001021 const S = struct {
10011022 fn register_to_address(ident: []const u8) !u8 {
......@@ -1016,7 +1037,7 @@ test "nested break ignores switch conditions and breaks instead" {
10161037}
10171038
10181039test "peer type resolution on switch captures ignores unused payload bits" {
1019 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1040 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10201041 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10211042
10221043 const Foo = union(enum) {
......@@ -1042,7 +1063,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
10421063
10431064test "switch prong captures range" {
10441065 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1045 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1066 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
10461067
10471068 const S = struct {
10481069 fn a(b: []u3, c: u3) void {
......@@ -1060,6 +1081,8 @@ test "switch prong captures range" {
10601081}
10611082
10621083test "prong with inline call to unreachable" {
1084 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1085
10631086 const U = union(enum) {
10641087 void: void,
10651088 bool: bool,
......@@ -1077,6 +1100,8 @@ test "prong with inline call to unreachable" {
10771100}
10781101
10791102test "block error return trace index is reset between prongs" {
1103 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1104
10801105 const S = struct {
10811106 fn returnError() error{TestFailed} {
10821107 return error.TestFailed;
......@@ -1105,6 +1130,8 @@ test "block error return trace index is reset between prongs" {
11051130}
11061131
11071132test "labeled switch with break" {
1133 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1134
11081135 var six: u32 = undefined;
11091136 six = 6;
11101137
......@@ -1144,6 +1171,8 @@ test "unlabeled break ignores switch" {
11441171}
11451172
11461173test "switch on a signed value smaller than the smallest prong value" {
1174 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1175
11471176 var v: i32 = undefined;
11481177 v = -1;
11491178 switch (v) {
......@@ -1153,6 +1182,8 @@ test "switch on a signed value smaller than the smallest prong value" {
11531182}
11541183
11551184test "switch on 8-bit mod result" {
1185 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1186
11561187 var x: u8 = undefined;
11571188 x = 16;
11581189 switch (x % 4) {
......@@ -1261,6 +1292,8 @@ test "switch with uninstantiable union fields" {
12611292}
12621293
12631294test "switch with tag capture" {
1295 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1296
12641297 const U = union(enum) {
12651298 a,
12661299 b: i32,
......@@ -1312,6 +1345,8 @@ test "switch with tag capture" {
13121345}
13131346
13141347test "switch with complex item expressions" {
1348 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1349
13151350 const S = struct {
13161351 fn doTheTest() !void {
13171352 try doTheSwitch(2000, 20);
......@@ -1414,7 +1449,7 @@ test "single range switch prong capture" {
14141449}
14151450
14161451test "switch on packed struct" {
1417 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1452 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14181453
14191454 const P = packed struct {
14201455 a: u1,
......@@ -1446,7 +1481,7 @@ test "switch on packed struct" {
14461481}
14471482
14481483test "switch on packed union" {
1449 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1484 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14501485
14511486 const P = packed union(u2) {
14521487 a: u2,
......@@ -1495,7 +1530,7 @@ test "switch on packed union" {
14951530}
14961531
14971532test "switch on nested packed containers" {
1498 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1533 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14991534
15001535 const P = packed struct {
15011536 iu: u17,
......@@ -1550,7 +1585,7 @@ test "switch on nested packed containers" {
15501585}
15511586
15521587test "switch on large types" {
1553 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1588 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15541589
15551590 const S = struct {
15561591 fn doTheTest(a: u128, b: i500) !void {
......@@ -1652,6 +1687,8 @@ test "repeated switch analysis overrides previous analysis results" {
16521687}
16531688
16541689test "union field pointer capture preserves alignment in inline prong" {
1690 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1691
16551692 const U = union(enum) {
16561693 a: u32,
16571694 b: u32,
......@@ -1671,6 +1708,8 @@ test "union field pointer capture preserves alignment in inline prong" {
16711708}
16721709
16731710test "switch on expression" {
1711 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1712
16741713 var a: []const []const u8 = &.{ "b", "b", "A", "A", "b" };
16751714 _ = &a;
16761715 var c: isize = 0;
test/behavior/switch_loop.zig+19-7
......@@ -4,6 +4,7 @@ const assert = std.debug.assert;
44const expect = std.testing.expect;
55
66test "simple switch loop" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
910 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -27,6 +28,7 @@ test "simple switch loop" {
2728}
2829
2930test "switch loop with ranges" {
31 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3032 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3133 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3234 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -47,6 +49,7 @@ test "switch loop with ranges" {
4749}
4850
4951test "switch loop on enum" {
52 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
5053 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5154 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5255 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -70,6 +73,7 @@ test "switch loop on enum" {
7073}
7174
7275test "switch loop with error set" {
76 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7377 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7478 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7579 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -93,6 +97,7 @@ test "switch loop with error set" {
9397}
9498
9599test "switch loop on tagged union" {
100 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
96101 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
97102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
98103 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -128,7 +133,7 @@ test "switch loop dispatching instructions" {
128133 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
129134 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
130135 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
131 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
136 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
132137
133138 const S = struct {
134139 const Inst = union(enum) {
......@@ -175,6 +180,7 @@ test "switch loop dispatching instructions" {
175180}
176181
177182test "switch loop with pointer capture" {
183 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
178184 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
179185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
180186 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -222,7 +228,7 @@ test "unanalyzed continue with operand" {
222228
223229test "switch loop on larger than pointer integer" {
224230 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
225 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
231 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
226232
227233 var entry: @Int(.unsigned, @bitSizeOf(usize) + 1) = undefined;
228234 entry = 0;
......@@ -242,6 +248,7 @@ test "switch loop on larger than pointer integer" {
242248}
243249
244250test "switch loop on non-exhaustive enum" {
251 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
245252 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
246253 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
247254 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -290,6 +297,8 @@ test "switch loop with discarded tag capture" {
290297}
291298
292299test "switch loop with single catch-all prong" {
300 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
301
293302 const S = struct {
294303 const E = enum { a, b, c };
295304 const U = union(E) { a: u32, b: u16, c: u8 };
......@@ -337,7 +346,7 @@ test "switch loop with single catch-all prong" {
337346}
338347
339348test "switch loop on type with opv" {
340 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
349 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
341350
342351 const S = struct {
343352 const E = enum { opv };
......@@ -385,7 +394,7 @@ test "switch loop on type with opv" {
385394}
386395
387396test "switch loop with tag capture" {
388 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
397 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
389398
390399 const U = union(enum) {
391400 a,
......@@ -456,6 +465,8 @@ test "switch loop with tag capture" {
456465}
457466
458467test "switch loop for error handling" {
468 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
469
459470 const Error = error{ MyError, MyOtherError };
460471 const S = struct {
461472 fn doTheTest() !void {
......@@ -500,7 +511,8 @@ test "switch loop for error handling" {
500511}
501512
502513test "switch loop with packed structs" {
503 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
514 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
515
504516 const P = packed struct {
505517 a: u7,
506518 b: u20,
......@@ -518,7 +530,7 @@ test "switch loop with packed structs" {
518530}
519531
520532test "switch loop with packed unions" {
521 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
533 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
522534
523535 const P = packed union {
524536 a: u7,
......@@ -558,7 +570,7 @@ test "switch loop with packed unions with OPV" {
558570}
559571
560572test "switch loop on large types" {
561 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
573 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
562574
563575 const S = struct {
564576 fn doTheTest(a: u128, b: i500) !void {
test/behavior/switch_on_captured_error.zig+2-2
......@@ -6,7 +6,7 @@ const expectEqual = std.testing.expectEqual;
66const builtin = @import("builtin");
77
88test "switch on error union catch capture" {
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1010 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1111
1212 const S = struct {
......@@ -370,7 +370,7 @@ test "switch on error union catch capture" {
370370}
371371
372372test "switch on error union if else capture" {
373 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
373 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
374374 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
375375
376376 const S = struct {
test/behavior/switch_prong_err_enum.zig+1-1
......@@ -24,7 +24,7 @@ test "switch prong returns error enum" {
2424 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2525 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2626 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
27 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
27 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2828
2929 switch (doThing(17) catch unreachable) {
3030 FormValue.Address => |payload| {
test/behavior/switch_prong_implicit_cast.zig+1
......@@ -15,6 +15,7 @@ fn foo(id: u64) !FormValue {
1515}
1616
1717test "switch prong implicit cast" {
18 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1819 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1920 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2021 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/this.zig+2-1
......@@ -26,6 +26,7 @@ test "this refer to module call private fn" {
2626}
2727
2828test "this refer to container" {
29 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2930 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3031
3132 var pt: Point(i32) = undefined;
......@@ -48,7 +49,7 @@ fn prev(p: ?State) void {
4849test "this used as optional function parameter" {
4950 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5051 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
52 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5253
5354 var global: State = undefined;
5455 global.enter = prev;
test/behavior/threadlocal.zig+2-2
......@@ -19,7 +19,7 @@ test "pointer to thread local array" {
1919 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2020 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2121 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
22 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
22 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2323
2424 const s = "Hello world";
2525 @memcpy(buffer[0..s.len], s);
......@@ -32,7 +32,7 @@ test "reference a global threadlocal variable" {
3232 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
3333 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3434 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
35 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
35 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3636
3737 try nrfx_uart_rx(&g_uart0);
3838}
test/behavior/truncate.zig+4-2
......@@ -32,6 +32,8 @@ test "truncate.u0.var" {
3232}
3333
3434test "truncate on comptime integer" {
35 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
36
3537 const x: u16 = @truncate(9999);
3638 try expect(x == 9999);
3739 const y: u16 = @truncate(-21555);
......@@ -49,7 +51,7 @@ fn testTruncate(comptime S: type, a: S, comptime D: type, expected: D) !void {
4951
5052test "@truncate > 128 bits" {
5153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
52 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
54 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5355
5456 try testTruncate(u140, 0, u128, 0);
5557 try testTruncate(u140, maxInt(u140), u128, maxInt(u128));
......@@ -90,7 +92,7 @@ test "truncate on vectors" {
9092 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9193 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9294 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
93 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
95 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9496
9597 const S = struct {
9698 fn doTheTest() !void {
test/behavior/try.zig+9-3
......@@ -4,6 +4,7 @@ const assert = std.debug.assert;
44const expect = std.testing.expect;
55
66test "try on error union" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
89
910 try tryOnErrorUnionImpl();
......@@ -49,7 +50,7 @@ test "try then not executed with assignment" {
4950
5051test "`try`ing an if/else expression" {
5152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
52 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
53 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
5354 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
5455
5556 const S = struct {
......@@ -68,6 +69,7 @@ test "`try`ing an if/else expression" {
6869}
6970
7071test "'return try' of empty error set in function returning non-error" {
72 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
7173 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7274 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7375
......@@ -102,6 +104,8 @@ test "'return try' of empty error set in function returning non-error" {
102104}
103105
104106test "'return try' through conditional" {
107 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
108
105109 const S = struct {
106110 fn get(t: bool) !u32 {
107111 return try if (t) inner() else error.TestFailed;
......@@ -124,7 +128,7 @@ test "'return try' through conditional" {
124128
125129test "try ptr propagation const" {
126130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
131 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
128132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
129133 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
130134
......@@ -156,7 +160,7 @@ test "try ptr propagation const" {
156160
157161test "try ptr propagation mutate" {
158162 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
159 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
163 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
160164 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
161165 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
162166
......@@ -200,6 +204,8 @@ test "try ptr propagation mutate" {
200204}
201205
202206test "try pointer expression alignment" {
207 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
208
203209 const S = struct {
204210 fn doTheTest(p: *align(1) (anyerror!u32)) !void {
205211 comptime assert(@TypeOf(&(try p.*)) == *align(1) u32);
test/behavior/tuple.zig+21-11
......@@ -7,6 +7,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
77const expectEqual = std.testing.expectEqual;
88
99test "tuple concatenation" {
10 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1011 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1112 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1213
......@@ -29,7 +30,7 @@ test "tuple concatenation" {
2930test "more tuple concatenation" {
3031 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
33 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3334
3435 const T = struct {
3536 fn consume_tuple(tuple: anytype, len: usize) !void {
......@@ -104,7 +105,9 @@ test "tuple initializer for var" {
104105}
105106
106107test "array-like initializer for tuple types" {
108 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
107109 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
110
108111 const T = @Tuple(&.{ i32, u8 });
109112 const S = struct {
110113 fn doTheTest() !void {
......@@ -169,7 +172,8 @@ test "fieldParentPtr of tuple" {
169172 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
170173 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171174 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
172 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
175 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
176
173177 var x: u32 = 0;
174178 _ = &x;
175179 const tuple = .{ x, x };
......@@ -180,7 +184,7 @@ test "fieldParentPtr of anon struct" {
180184 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
181185 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
182186 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
183 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
187 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
184188
185189 var x: u32 = 0;
186190 _ = &x;
......@@ -238,6 +242,7 @@ test "tuple in tuple passed to generic function" {
238242}
239243
240244test "coerce tuple to tuple" {
245 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
241246 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
242247 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243248
......@@ -285,6 +290,7 @@ test "tuple type with void field and a runtime field" {
285290}
286291
287292test "branching inside tuple literal" {
293 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
288294 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
289295 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
290296
......@@ -303,7 +309,7 @@ test "tuple initialized with a runtime known value" {
303309 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
304310 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
305311 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
306 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
312 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
307313
308314 const E = union(enum) { e: []const u8 };
309315 const W = union(enum) { w: E };
......@@ -317,7 +323,7 @@ test "tuple of struct concatenation and coercion to array" {
317323 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
318324 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
319325 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
320 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
326 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
321327
322328 const StructWithDefault = struct { value: f32 = 42 };
323329 const SomeStruct = struct { array: [4]StructWithDefault };
......@@ -331,7 +337,7 @@ test "tuple of struct concatenation and coercion to array" {
331337test "nested runtime conditionals in tuple initializer" {
332338 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
333339 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
334 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
340 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
335341
336342 var data: u8 = 0;
337343 _ = &data;
......@@ -364,6 +370,7 @@ test "sentinel slice in tuple" {
364370}
365371
366372test "tuple pointer is indexable" {
373 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
367374 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
368375 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
369376
......@@ -386,6 +393,7 @@ test "tuple pointer is indexable" {
386393}
387394
388395test "coerce anon tuple to tuple" {
396 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
389397 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
390398 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
391399
......@@ -423,7 +431,7 @@ test "tuple with runtime value coerced into a slice with a sentinel" {
423431 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
424432 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
425433 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
426 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
434 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
427435
428436 const S = struct {
429437 fn f(a: [:null]const ?u8) !void {
......@@ -442,6 +450,8 @@ test "tuple with runtime value coerced into a slice with a sentinel" {
442450}
443451
444452test "tuple implicitly coerced to optional/error union struct/union" {
453 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
454
445455 const SomeUnion = union(enum) {
446456 variant: u8,
447457 };
......@@ -495,7 +505,7 @@ test "comptime fields in tuple can be initialized" {
495505test "empty struct in tuple" {
496506 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
497507 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
498 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
508 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
499509
500510 const T = struct { struct {} };
501511 const info = @typeInfo(T);
......@@ -507,7 +517,7 @@ test "empty struct in tuple" {
507517test "empty union in tuple" {
508518 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
509519 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
510 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
520 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
511521
512522 const T = struct { union {} };
513523 const info = @typeInfo(T);
......@@ -517,7 +527,7 @@ test "empty union in tuple" {
517527}
518528
519529test "field pointer of underaligned tuple" {
520 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
530 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
521531
522532 const S = struct {
523533 fn doTheTest() !void {
......@@ -546,7 +556,7 @@ test "OPV tuple fields aren't comptime" {
546556}
547557
548558test "array of tuples that end with a zero-bit field followed by padding" {
549 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
559 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
550560
551561 const S = struct {
552562 var foo: [2]struct { u32, u8, void } = .{ .{ 1, 2, {} }, .{ 3, 4, {} } };
test/behavior/tuple_declarations.zig+2-2
......@@ -6,7 +6,7 @@ const expectEqualStrings = testing.expectEqualStrings;
66
77test "tuple declaration type info" {
88 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1010
1111 {
1212 const T = struct { comptime u32 = 1, []const u8 };
......@@ -34,7 +34,7 @@ test "tuple declaration type info" {
3434
3535test "tuple declaration usage" {
3636 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
37 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
37 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3838
3939 const T = struct { u32, []const u8 };
4040 var t: T = .{ 1, "foo" };
test/behavior/type.zig+17-5
......@@ -5,6 +5,8 @@ const testing = std.testing;
55const assert = std.debug.assert;
66
77test "Type.Int" {
8 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9
810 try testing.expect(u1 == @Int(.unsigned, 1));
911 try testing.expect(i1 == @Int(.signed, 1));
1012 try testing.expect(u8 == @Int(.unsigned, 8));
......@@ -14,6 +16,8 @@ test "Type.Int" {
1416}
1517
1618test "Type.Pointer" {
19 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
20
1721 inline for (&[_]type{
1822 // One Value Pointer Types
1923 *u8, *const u8,
......@@ -72,6 +76,8 @@ test "@Pointer create slice with null sentinel" {
7276}
7377
7478test "@Pointer on @typeInfo round-trips sentinels" {
79 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
80
7581 inline for (&[_]type{
7682 [*:0]u8, [*:0]const u8,
7783 [*:0]volatile u8, [*:0]const volatile u8,
......@@ -105,7 +111,7 @@ test "Type.Opaque" {
105111 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
106112 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
107113 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
114 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
109115
110116 const Opaque = opaque {};
111117 try testing.expect(Opaque != opaque {});
......@@ -124,7 +130,7 @@ test "Type.Struct" {
124130 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
125131 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
126132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
133 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
128134
129135 const A = @Struct(.auto, null, &.{ "x", "y" }, &.{ u8, u32 }, &@splat(.{}));
130136 const infoA = @typeInfo(A).@"struct";
......@@ -193,7 +199,7 @@ test "Type.Struct" {
193199
194200test "Type.Enum" {
195201 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
196 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
202 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
197203
198204 const Foo = @Enum(u8, .exhaustive, &.{ "a", "b" }, &.{ 1, 5 });
199205 try testing.expectEqual(std.builtin.Type.Enum.Mode.exhaustive, @typeInfo(Foo).@"enum".mode);
......@@ -229,7 +235,7 @@ test "Type.Enum" {
229235
230236test "Type.Union" {
231237 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
232 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
238 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
233239
234240 const Untagged = @Union(.@"extern", null, &.{ "int", "float" }, &.{ i32, f32 }, &.{ .{}, .{} });
235241 var untagged = Untagged{ .int = 1 };
......@@ -264,6 +270,8 @@ test "Type.Union from regular enum" {
264270}
265271
266272test "Type.Union from empty regular enum" {
273 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
274
267275 const E = enum {};
268276 const U = @Union(.auto, E, &.{}, &.{}, &.{});
269277
......@@ -274,6 +282,8 @@ test "Type.Union from empty regular enum" {
274282}
275283
276284test "Type.Union from empty Type.Enum" {
285 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
286
277287 const E = @Enum(noreturn, .exhaustive, &.{}, &.{});
278288 const U = @Union(.auto, E, &.{}, &.{}, &.{});
279289
......@@ -285,7 +295,7 @@ test "Type.Union from empty Type.Enum" {
285295
286296test "Type.Fn" {
287297 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
288 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
298 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
289299
290300 const some_opaque = opaque {};
291301 const some_ptr = *some_opaque;
......@@ -406,6 +416,8 @@ test "matching captures causes opaque equivalence" {
406416}
407417
408418test "reify enum where fields refers to part of array" {
419 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
420
409421 const field_names: [3][]const u8 = .{ "foo", "bar", undefined };
410422 const field_values: [3]u8 = .{ undefined, 0, 1 };
411423 const E = @Enum(u8, .exhaustive, field_names[0..2], field_values[1..3]);
test/behavior/type_info.zig+35-10
......@@ -10,6 +10,8 @@ const expect = std.testing.expect;
1010const expectEqualStrings = std.testing.expectEqualStrings;
1111
1212test "type info: integer, floating point type info" {
13 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
14
1315 try testIntFloat();
1416 try comptime testIntFloat();
1517}
......@@ -37,6 +39,8 @@ fn testOptional() !void {
3739}
3840
3941test "type info: C pointer type info" {
42 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
43
4044 try testCPtr();
4145 try comptime testCPtr();
4246}
......@@ -60,6 +64,8 @@ test "type info: value is correctly copied" {
6064}
6165
6266test "type info: tag type, void info" {
67 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
68
6369 try testBasic();
6470 try comptime testBasic();
6571}
......@@ -72,6 +78,8 @@ fn testBasic() !void {
7278}
7379
7480test "type info: pointer type info" {
81 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
82
7583 try testPointer();
7684 try comptime testPointer();
7785}
......@@ -88,6 +96,8 @@ fn testPointer() !void {
8896}
8997
9098test "type info: unknown length pointer type info" {
99 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
100
91101 try testUnknownLenPtr();
92102 try comptime testUnknownLenPtr();
93103}
......@@ -104,6 +114,8 @@ fn testUnknownLenPtr() !void {
104114}
105115
106116test "type info: null terminated pointer type info" {
117 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
118
107119 try testNullTerminatedPtr();
108120 try comptime testNullTerminatedPtr();
109121}
......@@ -120,6 +132,8 @@ fn testNullTerminatedPtr() !void {
120132}
121133
122134test "type info: slice type info" {
135 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
136
123137 try testSlice();
124138 try comptime testSlice();
125139}
......@@ -135,6 +149,8 @@ fn testSlice() !void {
135149}
136150
137151test "type info: array type info" {
152 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
153
138154 try testArray();
139155 try comptime testArray();
140156}
......@@ -160,7 +176,7 @@ fn testArray() !void {
160176test "type info: error set, error union info, anyerror" {
161177 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162178 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
179 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
164180
165181 try testErrorSet();
166182 try comptime testErrorSet();
......@@ -191,7 +207,7 @@ fn testErrorSet() !void {
191207test "type info: error set single value" {
192208 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
193209 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
194 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
210 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
195211
196212 const TestSet = error.One;
197213
......@@ -204,7 +220,7 @@ test "type info: error set single value" {
204220test "type info: error set merged" {
205221 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
206222 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
207 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
223 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
208224
209225 const TestSet = error{ One, Two } || error{Three};
210226
......@@ -219,7 +235,7 @@ test "type info: error set merged" {
219235test "type info: enum info" {
220236 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221237 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
238 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
223239
224240 try testEnum();
225241 try comptime testEnum();
......@@ -244,6 +260,8 @@ fn testEnum() !void {
244260}
245261
246262test "type info: union info" {
263 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
264
247265 try testUnion();
248266 try comptime testUnion();
249267}
......@@ -287,7 +305,7 @@ fn testUnion() !void {
287305
288306test "type info: struct info" {
289307 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
290 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
308 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
291309
292310 try testStruct();
293311 try comptime testStruct();
......@@ -310,6 +328,8 @@ const TestStruct = struct {
310328};
311329
312330test "type info: packed struct info" {
331 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
332
313333 try testPackedStruct();
314334 try comptime testPackedStruct();
315335}
......@@ -361,7 +381,7 @@ fn testOpaque() !void {
361381}
362382
363383test "type info: function type info" {
364 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
384 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
365385 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
366386
367387 try testFunction();
......@@ -429,6 +449,8 @@ extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.c) usize;
429449extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.c) usize;
430450
431451test "type info: generic function types" {
452 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
453
432454 const G1 = @typeInfo(@TypeOf(generic1));
433455 try expect(G1.@"fn".param_types.len == 1);
434456 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" {
477499}
478500
479501test "type info: vectors" {
502 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
503
480504 try testVector();
481505 try comptime testVector();
482506}
......@@ -549,7 +573,7 @@ fn add(a: i32, b: i32) i32 {
549573
550574test "Declarations are returned in declaration order" {
551575 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
552 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
576 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
553577
554578 const S = struct {
555579 pub const a = 1;
......@@ -571,8 +595,7 @@ test "Struct.is_tuple for anon list literal" {
571595}
572596
573597test "Struct.is_tuple for anon struct literal" {
574 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
575
598 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
576599 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
577600
578601 const info = @typeInfo(@TypeOf(.{ .a = 0 }));
......@@ -594,6 +617,7 @@ test "value from struct @typeInfo default_value_ptr can be loaded at comptime" {
594617}
595618
596619test "type info of tuple of string literal default value" {
620 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
597621 const struct_info = @typeInfo(@TypeOf(.{"hi"})).@"struct";
598622 const struct_field_attrs = struct_info.field_attrs[0];
599623 const struct_field_type = struct_info.field_types[0];
......@@ -611,7 +635,8 @@ test "@typeInfo function with generic return type and inferred error set" {
611635}
612636
613637test "type info: spirv info" {
614 if (builtin.zig_backend != .stage2_spirv) return error.SkipZigTest;
638 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
639 if (!builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
615640
616641 try testSpirv();
617642 try comptime testSpirv();
test/behavior/typename.zig+8-8
......@@ -14,7 +14,7 @@ const expectStringStartsWith = std.testing.expectStringStartsWith;
1414test "anon fn param" {
1515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1616 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
17 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1818
1919 // https://github.com/ziglang/zig/issues/9339
2020 try expectEqualStringsIgnoreDigits(
......@@ -39,7 +39,7 @@ test "anon fn param" {
3939test "anon field init" {
4040 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4141 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
42 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4343
4444 const Foo = .{
4545 .T1 = struct {},
......@@ -64,7 +64,7 @@ test "anon field init" {
6464test "basic" {
6565 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6666 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
67 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6868
6969 try expectEqualStrings("i64", @typeName(i64));
7070 try expectEqualStrings("*usize", @typeName(*usize));
......@@ -85,7 +85,7 @@ test "basic" {
8585test "top level decl" {
8686 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8787 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
88 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
88 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8989
9090 try expectEqualStrings(
9191 "behavior.typename.A_Struct",
......@@ -134,7 +134,7 @@ const B = struct {
134134test "fn param" {
135135 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
136136 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
137 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
138138
139139 // https://github.com/ziglang/zig/issues/675
140140 try expectEqualStrings(
......@@ -213,7 +213,7 @@ pub fn expectEqualStringsIgnoreDigits(expected: []const u8, actual: []const u8)
213213test "local variable" {
214214 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
215215 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
216 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
216 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
217217
218218 const Foo = struct { a: u32 };
219219 const Bar = union { a: u32 };
......@@ -231,7 +231,7 @@ test "local variable" {
231231test "comptime parameters not converted to anytype in function type" {
232232 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
233233 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
234 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
234 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
235235
236236 const T = fn (comptime fn (comptime type) void, void) void;
237237 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" {
240240test "anon name strategy used in sub expression" {
241241 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
242242 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
243 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
244244
245245 const S = struct {
246246 fn getTheName() []const u8 {
test/behavior/undefined.zig+6-3
......@@ -14,6 +14,7 @@ fn initStaticArray() [10]i32 {
1414}
1515const static_array = initStaticArray();
1616test "init static array to undefined" {
17 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1718 // This test causes `initStaticArray()` to be codegen'd, and the
1819 // C backend does not yet support returning arrays, so it fails
1920 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
......@@ -45,6 +46,7 @@ fn setFooX(foo: *Foo) void {
4546}
4647
4748test "assign undefined to struct" {
49 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4850 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4951 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5052
......@@ -61,6 +63,7 @@ test "assign undefined to struct" {
6163}
6264
6365test "assign undefined to struct with method" {
66 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
6467 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6568 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6669
......@@ -77,7 +80,7 @@ test "assign undefined to struct with method" {
7780}
7881
7982test "type name of undefined" {
80 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8184 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8285
8386 const x = undefined;
......@@ -88,7 +91,7 @@ var buf: []u8 = undefined;
8891
8992test "reslice of undefined global var slice" {
9093 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
91 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
94 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
9295
9396 var stack_buf: [100]u8 = @splat(0);
9497 buf = &stack_buf;
......@@ -98,7 +101,7 @@ test "reslice of undefined global var slice" {
98101
99102test "returned undef is 0xaa bytes when runtime safety is enabled" {
100103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
101 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
104 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
102105 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
103106
104107 const Rect = struct {
test/behavior/underscore.zig+1
......@@ -7,6 +7,7 @@ test "ignore lval with underscore" {
77}
88
99test "ignore lval with underscore (while loop)" {
10 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1011 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1112
1213 while (optionalReturnError()) |_| {
test/behavior/union.zig+85-39
......@@ -15,7 +15,7 @@ test "basic unions with floats" {
1515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1616 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1717 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
18 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
18 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1919
2020 var foo = FooWithFloats{ .int = 1 };
2121 try expect(foo.int == 1);
......@@ -28,6 +28,7 @@ fn setFloat(foo: *FooWithFloats, x: f64) void {
2828}
2929
3030test "init union with runtime value - floats" {
31 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3132 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3233 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3334 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -41,7 +42,7 @@ test "init union with runtime value - floats" {
4142test "basic unions" {
4243 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4344 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
44 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
45 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4546
4647 var foo = Foo{ .int = 1 };
4748 try expect(foo.int == 1);
......@@ -60,7 +61,7 @@ test "init union with runtime value" {
6061 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6162 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6263 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
63 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
64 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6465
6566 var foo: Foo = undefined;
6667
......@@ -98,7 +99,7 @@ const FooExtern = extern union {
9899
99100test "basic extern unions" {
100101 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
101 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
102 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
102103
103104 var foo = FooExtern{ .int = 1 };
104105 try expect(foo.int == 1);
......@@ -160,6 +161,7 @@ test "unions embedded in aggregate types" {
160161}
161162
162163test "constant tagged union with payload" {
164 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
163165 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
164166 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
165167
......@@ -212,7 +214,7 @@ test "union with specified enum tag" {
212214 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
213215 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
214216 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
215 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
217 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
216218
217219 try doTest();
218220 try comptime doTest();
......@@ -245,7 +247,7 @@ fn testComparison() !void {
245247test "comparison between union and enum literal" {
246248 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
247249 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
248 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
250 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
249251
250252 try testComparison();
251253 try comptime testComparison();
......@@ -258,6 +260,7 @@ const TheUnion = union(TheTag) {
258260 C: i32,
259261};
260262test "cast union to tag type of union" {
263 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
261264 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
262265 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
263266
......@@ -272,12 +275,14 @@ fn testCastUnionToTag() !void {
272275}
273276
274277test "union field access gives the enum values" {
278 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
275279 try expect(TheUnion.A == TheTag.A);
276280 try expect(TheUnion.B == TheTag.B);
277281 try expect(TheUnion.C == TheTag.C);
278282}
279283
280284test "cast tag type of union to union" {
285 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
281286 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
282287 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
283288
......@@ -293,6 +298,7 @@ const Value2 = union(Letter2) {
293298};
294299
295300test "implicit cast union to its tag type" {
301 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
296302 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
297303 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
298304
......@@ -315,7 +321,7 @@ pub const PackThis = union(enum) {
315321test "constant packed union" {
316322 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
317323 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
318 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
324 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
319325
320326 try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
321327}
......@@ -407,7 +413,7 @@ test "tagged union with no payloads" {
407413
408414test "union with only 1 field casted to its enum type" {
409415 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
410 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
416 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
411417
412418 const Literal = union(enum) {
413419 Number: f64,
......@@ -442,7 +448,7 @@ const Foo1 = union(enum) {
442448var glbl: Foo1 = undefined;
443449
444450test "global union with single field is correctly initialized" {
445 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
451 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
446452 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
447453 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
448454
......@@ -462,7 +468,7 @@ var glbl_array: [2]FooUnion = undefined;
462468test "initialize global array of union" {
463469 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
464470 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
465 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
471 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
466472
467473 glbl_array[1] = FooUnion{ .U1 = 2 };
468474 glbl_array[0] = FooUnion{ .U0 = 1 };
......@@ -471,6 +477,7 @@ test "initialize global array of union" {
471477}
472478
473479test "update the tag value for zero-sized unions" {
480 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
474481 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
475482 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
476483
......@@ -485,6 +492,7 @@ test "update the tag value for zero-sized unions" {
485492}
486493
487494test "union initializer generates padding only if needed" {
495 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
488496 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
489497 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
490498
......@@ -499,7 +507,7 @@ test "union initializer generates padding only if needed" {
499507
500508test "runtime tag name with single field" {
501509 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
502 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
510 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
503511
504512 const U = union(enum) {
505513 A: i32,
......@@ -511,6 +519,7 @@ test "runtime tag name with single field" {
511519}
512520
513521test "method call on an empty union" {
522 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
514523 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
515524 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
516525
......@@ -551,6 +560,7 @@ const FooNoVoid = union(enum) {
551560const Baz = enum { A, B, C, D };
552561
553562test "tagged union type" {
563 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
554564 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
555565
556566 const foo1 = TaggedFoo{ .One = 13 };
......@@ -572,6 +582,7 @@ test "tagged union type" {
572582}
573583
574584test "tagged union as return value" {
585 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
575586 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
576587 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
577588 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -588,6 +599,7 @@ fn returnAnInt(x: i32) TaggedFoo {
588599}
589600
590601test "tagged union with all void fields but a meaningful tag" {
602 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
591603 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
592604 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
593605
......@@ -615,6 +627,7 @@ test "tagged union with all void fields but a meaningful tag" {
615627}
616628
617629test "union(enum(u32)) with specified and unspecified tag values" {
630 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
618631 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
619632 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
620633 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -652,6 +665,7 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
652665}
653666
654667test "switch on union with only 1 field" {
668 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
655669 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
656670 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
657671
......@@ -682,7 +696,7 @@ const PartialInstWithPayload = union(enum) {
682696
683697test "union with only 1 field casted to its enum type which has enum value specified" {
684698 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
685 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
699 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
686700
687701 const Literal = union(enum) {
688702 number: f64,
......@@ -705,6 +719,7 @@ test "union with only 1 field casted to its enum type which has enum value speci
705719}
706720
707721test "@intFromEnum works on unions" {
722 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
708723 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
709724 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
710725
......@@ -724,6 +739,8 @@ test "@intFromEnum works on unions" {
724739}
725740
726741test "comptime union field value equality" {
742 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
743
727744 const a0 = Setter(Attribute{ .A = false });
728745 const a1 = Setter(Attribute{ .A = true });
729746 const a2 = Setter(Attribute{ .A = false });
......@@ -763,6 +780,7 @@ fn Setter(comptime attr: Attribute) type {
763780}
764781
765782test "return union init with void payload" {
783 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
766784 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
767785 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
768786 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -787,6 +805,7 @@ test "return union init with void payload" {
787805}
788806
789807test "@unionInit stored to a const" {
808 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
790809 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
791810 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
792811 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -817,6 +836,7 @@ test "@unionInit stored to a const" {
817836}
818837
819838test "@unionInit can modify a union type" {
839 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
820840 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
821841 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
822842
......@@ -839,6 +859,7 @@ test "@unionInit can modify a union type" {
839859}
840860
841861test "@unionInit can modify a pointer value" {
862 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
842863 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
843864 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
844865
......@@ -860,7 +881,7 @@ test "@unionInit can modify a pointer value" {
860881test "union no tag with struct member" {
861882 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
862883 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
863 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
884 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
864885
865886 const Struct = struct {};
866887 const Union = union {
......@@ -887,7 +908,8 @@ test "anonymous union literal syntax" {
887908 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
888909 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
889910 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
890 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
911 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
912
891913 const S = struct {
892914 const Number = union {
893915 int: i32,
......@@ -911,6 +933,7 @@ test "anonymous union literal syntax" {
911933}
912934
913935test "function call result coerces from tagged union to the tag" {
936 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
914937 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
915938 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
916939 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" {
946969}
947970
948971test "switching on non exhaustive union" {
972 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
949973 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
950974 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
951975
......@@ -973,6 +997,7 @@ test "switching on non exhaustive union" {
973997}
974998
975999test "containers with single-field enums" {
1000 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
9761001 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9771002 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9781003
......@@ -1004,7 +1029,7 @@ test "containers with single-field enums" {
10041029test "@unionInit on union with u8 tag but no fields" {
10051030 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10061031 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1007 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1032 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10081033
10091034 const S = struct {
10101035 const Type = enum(u8) { no_op = 105 };
......@@ -1049,7 +1074,7 @@ test "union enum type gets a separate scope" {
10491074test "global variable struct contains union initialized to non-most-aligned field" {
10501075 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10511076 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1052 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1077 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10531078
10541079 const T = struct {
10551080 const U = union(enum) {
......@@ -1073,6 +1098,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
10731098}
10741099
10751100test "union with no result loc initiated with a runtime value" {
1101 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10761102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10771103 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10781104 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1090,6 +1116,7 @@ test "union with no result loc initiated with a runtime value" {
10901116}
10911117
10921118test "union with a large struct field" {
1119 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
10931120 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10941121 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10951122 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1124,6 +1151,7 @@ test "comptime equality of extern unions with same tag" {
11241151}
11251152
11261153test "union tag is set when initiated as a temporary value at runtime" {
1154 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11271155 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11281156 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11291157 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1146,7 +1174,7 @@ test "extern union most-aligned field is smaller" {
11461174 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11471175 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11481176 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1149 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1177 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11501178
11511179 const U = extern union {
11521180 in6: extern struct {
......@@ -1166,7 +1194,7 @@ test "return an extern union from C calling convention" {
11661194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11671195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11681196 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1169 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1197 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11701198
11711199 const namespace = struct {
11721200 const S = extern struct {
......@@ -1195,6 +1223,7 @@ test "return an extern union from C calling convention" {
11951223}
11961224
11971225test "noreturn field in union" {
1226 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
11981227 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11991228 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12001229 const U = union(enum) {
......@@ -1244,6 +1273,7 @@ test "noreturn field in union" {
12441273}
12451274
12461275test "@unionInit uses tag value instead of field index" {
1276 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
12471277 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12481278 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12491279 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -1274,7 +1304,7 @@ test "@unionInit uses tag value instead of field index" {
12741304test "union field ptr - zero sized payload" {
12751305 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12761306 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1277 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1307 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12781308
12791309 const U = union {
12801310 foo: void,
......@@ -1288,7 +1318,7 @@ test "union field ptr - zero sized payload" {
12881318test "union field ptr - zero sized field" {
12891319 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12901320 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1291 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1321 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12921322
12931323 const U = union {
12941324 foo: void,
......@@ -1303,7 +1333,7 @@ test "packed union in packed struct" {
13031333 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13041334 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13051335 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1306 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1336 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13071337
13081338 const S = packed struct {
13091339 nested: packed union {
......@@ -1353,7 +1383,7 @@ test "union int tag type is properly managed" {
13531383
13541384test "no dependency loop when function pointer in union returns the union" {
13551385 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1356 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1386 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13571387 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13581388
13591389 const U = union(enum) {
......@@ -1373,6 +1403,7 @@ test "no dependency loop when function pointer in union returns the union" {
13731403}
13741404
13751405test "union reassignment can use previous value" {
1406 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13761407 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13771408 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13781409
......@@ -1387,7 +1418,7 @@ test "union reassignment can use previous value" {
13871418
13881419test "reinterpreting enum value inside packed union" {
13891420 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1390 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1421 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13911422
13921423 const U = packed union {
13931424 tag: enum(u8) { a, b },
......@@ -1404,7 +1435,7 @@ test "reinterpreting enum value inside packed union" {
14041435}
14051436
14061437test "access the tag of a global tagged union" {
1407 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1438 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14081439
14091440 const U = union(enum) {
14101441 a,
......@@ -1415,6 +1446,8 @@ test "access the tag of a global tagged union" {
14151446}
14161447
14171448test "coerce enum literal to union in result loc" {
1449 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1450
14181451 const U = union(enum) {
14191452 a,
14201453 b: u8,
......@@ -1431,7 +1464,7 @@ test "coerce enum literal to union in result loc" {
14311464test "defined-layout union field pointer has correct alignment" {
14321465 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14331466 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1434 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1467 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14351468
14361469 const S = struct {
14371470 fn doTheTest(comptime U: type) !void {
......@@ -1465,7 +1498,7 @@ test "defined-layout union field pointer has correct alignment" {
14651498test "undefined-layout union field pointer has correct alignment" {
14661499 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14671500 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1468 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1501 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14691502
14701503 const S = struct {
14711504 fn doTheTest(comptime U: type) !void {
......@@ -1500,7 +1533,7 @@ test "packed union field pointer has correct alignment" {
15001533 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15011534 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15021535 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1503 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1536 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
15041537
15051538 const U = packed union { x: u20 };
15061539 const S = packed struct(u24) { a: u2, u: U, b: u2 };
......@@ -1531,6 +1564,7 @@ test "packed union field pointer has correct alignment" {
15311564}
15321565
15331566test "union with 128 bit integer" {
1567 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
15341568 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15351569
15361570 const ValueTag = enum { int, other };
......@@ -1554,7 +1588,7 @@ test "union with 128 bit integer" {
15541588}
15551589
15561590test "memset extern union" {
1557 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1591 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15581592
15591593 const U = extern union {
15601594 foo: u8,
......@@ -1575,7 +1609,7 @@ test "memset extern union" {
15751609}
15761610
15771611test "memset packed union" {
1578 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1612 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15791613
15801614 const U = packed union {
15811615 a: u32,
......@@ -1677,7 +1711,7 @@ test "reinterpret extern union" {
16771711
16781712test "reinterpret packed union" {
16791713 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1680 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1714 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16811715
16821716 const U = packed union {
16831717 foo: packed struct(u64) {
......@@ -1755,7 +1789,7 @@ test "reinterpret packed union" {
17551789
17561790test "reinterpret packed union inside packed struct" {
17571791 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1758 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1792 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17591793 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
17601794
17611795 const U = packed union {
......@@ -1794,6 +1828,8 @@ test "reinterpret packed union inside packed struct" {
17941828}
17951829
17961830test "inner struct initializer uses union layout" {
1831 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1832
17971833 const namespace = struct {
17981834 const U = union {
17991835 a: struct {
......@@ -1818,6 +1854,8 @@ test "inner struct initializer uses union layout" {
18181854}
18191855
18201856test "inner struct initializer uses packed union layout" {
1857 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1858
18211859 const namespace = struct {
18221860 const U = packed union {
18231861 a: packed struct {
......@@ -1861,7 +1899,7 @@ test "extern union initialized via reintepreted struct field initializer" {
18611899
18621900test "packed union initialized via reintepreted struct field initializer" {
18631901 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1864 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1902 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18651903
18661904 const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
18671905
......@@ -1884,7 +1922,7 @@ test "packed union initialized via reintepreted struct field initializer" {
18841922}
18851923
18861924test "store of comptime reinterpreted memory to extern union" {
1887 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1925 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18881926
18891927 const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
18901928
......@@ -1907,7 +1945,7 @@ test "store of comptime reinterpreted memory to extern union" {
19071945
19081946test "store of comptime reinterpreted memory to packed union" {
19091947 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1910 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1948 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19111949
19121950 const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
19131951
......@@ -1933,7 +1971,7 @@ test "store of comptime reinterpreted memory to packed union" {
19331971
19341972test "union field is a pointer to an aligned version of itself" {
19351973 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1936 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1974 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19371975
19381976 const E = union {
19391977 next: *align(1) @This(),
......@@ -1947,7 +1985,7 @@ test "union field is a pointer to an aligned version of itself" {
19471985test "pass register-sized field as non-register-sized union" {
19481986 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
19491987 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1950 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1988 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19511989
19521990 const S = struct {
19531991 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" {
19712009}
19722010
19732011test "circular dependency through pointer field of a union" {
1974 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2012 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
19752013
19762014 const S = struct {
19772015 const UnionInner = extern struct {
......@@ -1994,6 +2032,7 @@ test "circular dependency through pointer field of a union" {
19942032}
19952033
19962034test "pass nested union with rls" {
2035 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
19972036 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
19982037
19992038 const Union = union(enum) {
......@@ -2014,6 +2053,7 @@ test "pass nested union with rls" {
20142053}
20152054
20162055test "runtime union init, most-aligned field != largest" {
2056 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
20172057 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20182058 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20192059 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -2039,6 +2079,7 @@ test "runtime union init, most-aligned field != largest" {
20392079}
20402080
20412081test "copied union field doesn't alias source" {
2082 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
20422083 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20432084 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20442085
......@@ -2059,7 +2100,7 @@ test "copied union field doesn't alias source" {
20592100test "create union(enum) from other union(enum)" {
20602101 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20612102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2062 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2103 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
20632104 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20642105
20652106 const string = "hello world";
......@@ -2192,6 +2233,7 @@ test "capture used as explicit field value" {
21922233}
21932234
21942235test "signed enum tag with negative value" {
2236 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
21952237 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21962238 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21972239
......@@ -2247,7 +2289,7 @@ test "extern union @FieldType" {
22472289}
22482290
22492291test "assign global tagged union" {
2250 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2292 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
22512293
22522294 const U = union(enum) {
22532295 a: u16,
......@@ -2268,6 +2310,8 @@ test "assign global tagged union" {
22682310}
22692311
22702312test "set mutable union by switching on same union" {
2313 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2314
22712315 const U = union(enum) {
22722316 foo,
22732317 bar: usize,
......@@ -2292,6 +2336,8 @@ test "initialize empty field of union inside comptime-known struct constant" {
22922336}
22932337
22942338test "union with function body field" {
2339 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
2340
22952341 const U = union {
22962342 f: fn () void,
22972343 fn foo() void {}
test/behavior/var_args.zig+10-6
......@@ -14,6 +14,8 @@ fn add(args: anytype) i32 {
1414}
1515
1616test "add arbitrary args" {
17 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
18
1719 try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
1820 try expect(add(.{@as(i32, 1234)}) == 1234);
1921 try expect(add(.{}) == 0);
......@@ -28,6 +30,7 @@ test "send void arg to var args" {
2830}
2931
3032test "pass args directly" {
33 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
3134 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3235
3336 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 {
4043}
4144
4245test "runtime parameter before var args" {
46 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
4347 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4448
4549 try expect((try extraFn(10, .{})) == 0);
......@@ -94,7 +98,7 @@ fn doNothingWithFirstArg(args: anytype) void {
9498test "simple variadic function" {
9599 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
96100 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
97 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
101 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
98102 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
99103 if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
100104 // https://github.com/ziglang/zig/issues/14096
......@@ -155,7 +159,7 @@ test "simple variadic function" {
155159test "coerce reference to var arg" {
156160 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
157161 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
158 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
162 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
159163 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
160164 if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
161165 // https://github.com/ziglang/zig/issues/14096
......@@ -187,7 +191,7 @@ test "variadic functions" {
187191 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188192 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
189193 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
190 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
194 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
191195 if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
192196 // https://github.com/ziglang/zig/issues/14096
193197 return error.SkipZigTest;
......@@ -238,7 +242,7 @@ test "variadic functions" {
238242
239243test "copy VaList" {
240244 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
241 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
245 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
242246 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
243247 if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
244248 // https://github.com/ziglang/zig/issues/14096
......@@ -272,7 +276,7 @@ test "copy VaList" {
272276
273277test "unused VaList arg" {
274278 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
275 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
279 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
276280 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
277281 if (builtin.zig_backend == .stage2_llvm and !builtin.os.tag.isDarwin() and builtin.cpu.arch.isAARCH64()) {
278282 // https://github.com/ziglang/zig/issues/14096
......@@ -303,7 +307,7 @@ test "unused VaList arg" {
303307
304308test "floating point VaList args" {
305309 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
306 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
310 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
307311 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
308312 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/16961
309313
test/behavior/vector.zig+49-37
......@@ -8,7 +8,7 @@ const expectEqual = std.testing.expectEqual;
88
99test "implicit cast vector to array - bool" {
1010 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
1212
1313 const S = struct {
1414 fn doTheTest() !void {
......@@ -31,7 +31,7 @@ test "implicit cast vector to array - bool" {
3131}
3232
3333test "implicit cast array to vector - bool" {
34 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
34 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3535 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3636
3737 const S = struct {
......@@ -59,7 +59,7 @@ test "vector wrap operators" {
5959 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6060 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6161 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
62 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
62 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6363
6464 const S = struct {
6565 fn doTheTest() !void {
......@@ -82,7 +82,7 @@ test "vector bin compares with mem.eql" {
8282 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8383 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8484 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
85 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
85 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
8686
8787 const S = struct {
8888 fn doTheTest() !void {
......@@ -106,7 +106,7 @@ test "vector int operators" {
106106 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
107107 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108108 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
109 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
109 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
110110
111111 const S = struct {
112112 fn doTheTest() !void {
......@@ -127,7 +127,7 @@ test "vector float operators" {
127127 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
128128 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
129129 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
130 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
130 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
131131
132132 const S = struct {
133133 fn doTheTest(T: type) !void {
......@@ -164,7 +164,7 @@ test "vector bit operators" {
164164 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
165165 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
166166 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
167 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
167 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
168168
169169 const S = struct {
170170 fn doTheTest() !void {
......@@ -195,7 +195,7 @@ test "implicit cast vector to array" {
195195 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
196196 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
197197 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
198 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
198 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
199199
200200 const S = struct {
201201 fn doTheTest() !void {
......@@ -214,7 +214,7 @@ test "array to vector" {
214214 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
215215 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
216216 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
217 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
217 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
218218
219219 const S = struct {
220220 fn doTheTest() !void {
......@@ -233,7 +233,7 @@ test "array of abi-sized integer to vector of same type" {
233233 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
234234 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
235235 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
236 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
236 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
237237
238238 const S = struct {
239239 const one: u32 = 1;
......@@ -318,7 +318,7 @@ test "array of float to vector of same type" {
318318 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
319319 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
320320 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
321 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
321 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
322322 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
323323
324324 const S = struct {
......@@ -375,6 +375,7 @@ test "array of float to vector of same type" {
375375}
376376
377377test "array of non-abi-sized integer to vector of same type" {
378 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
378379 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
379380 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
380381 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" {
427428}
428429
429430test "array vector coercion - odd sizes" {
431 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
430432 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
431433 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
432434 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -468,7 +470,7 @@ test "array to vector with element type coercion" {
468470 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
469471 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
470472 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
471 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
473 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
472474 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
473475
474476 const S = struct {
......@@ -502,7 +504,7 @@ test "peer type resolution with coercible element types" {
502504}
503505
504506test "tuple to vector" {
505 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
507 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
506508 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
507509 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
508510 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -529,7 +531,7 @@ test "vector casts of sizes not divisible by 8" {
529531 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
530532 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
531533 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
532 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
534 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
533535
534536 const S = struct {
535537 fn doTheTest() !void {
......@@ -564,6 +566,7 @@ test "vector casts of sizes not divisible by 8" {
564566}
565567
566568test "load vector elements via comptime index" {
569 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
567570 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
568571 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
569572
......@@ -584,6 +587,7 @@ test "load vector elements via comptime index" {
584587}
585588
586589test "store vector elements via comptime index" {
590 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
587591 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
588592 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
589593
......@@ -610,6 +614,7 @@ test "store vector elements via comptime index" {
610614}
611615
612616test "initialize vector which is a struct field" {
617 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
613618 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
614619 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
615620
......@@ -634,7 +639,7 @@ test "vector comparison operators" {
634639 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
635640 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
636641 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
637 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
642 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
638643
639644 const S = struct {
640645 fn doTheTest() !void {
......@@ -679,7 +684,7 @@ test "vector division operators" {
679684 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
680685 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
681686 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
682 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
687 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
683688
684689 const S = struct {
685690 fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
......@@ -798,6 +803,7 @@ test "vector division operators" {
798803}
799804
800805test "vector bitwise not operator" {
806 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
801807 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
802808 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
803809 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -830,6 +836,7 @@ test "vector bitwise not operator" {
830836}
831837
832838test "vector boolean not operator" {
839 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
833840 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
834841 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
835842 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -856,7 +863,7 @@ test "vector shift operators" {
856863 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
857864 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
858865 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
859 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
866 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
860867
861868 const S = struct {
862869 fn doTheTestShift(x: anytype, y: anytype) !void {
......@@ -926,7 +933,7 @@ test "vector reduce operation" {
926933 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
927934 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
928935 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
929 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
936 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
930937 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
931938
932939 const S = struct {
......@@ -1087,7 +1094,7 @@ test "saturating add" {
10871094 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10881095 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10891096 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1090 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1097 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
10911098 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10921099
10931100 const S = struct {
......@@ -1187,7 +1194,7 @@ test "saturating subtraction" {
11871194 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11881195 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11891196 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1190 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1197 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
11911198 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11921199
11931200 const S = struct {
......@@ -1279,7 +1286,7 @@ test "saturating multiplication" {
12791286 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12801287 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12811288 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1282 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1289 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
12831290 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12841291
12851292 const S = struct {
......@@ -1303,7 +1310,7 @@ test "saturating shift-left" {
13031310 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13041311 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13051312 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1306 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1313 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13071314 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13081315
13091316 const S = struct {
......@@ -1323,6 +1330,7 @@ test "saturating shift-left" {
13231330}
13241331
13251332test "multiplication-assignment operator with an array operand" {
1333 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
13261334 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13271335 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13281336 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1346,7 +1354,7 @@ test "@addWithOverflow" {
13461354 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13471355 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13481356 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1349 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1357 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13501358
13511359 const S = struct {
13521360 fn doTheTest() !void {
......@@ -1393,7 +1401,7 @@ test "@subWithOverflow" {
13931401 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13941402 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13951403 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1396 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1404 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
13971405
13981406 const S = struct {
13991407 fn doTheTest() !void {
......@@ -1420,7 +1428,7 @@ test "@subWithOverflow" {
14201428}
14211429
14221430test "@mulWithOverflow" {
1423 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1431 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14241432 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14251433 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14261434 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1441,7 +1449,7 @@ test "@mulWithOverflow" {
14411449}
14421450
14431451test "@shlWithOverflow" {
1444 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1452 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14451453 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14461454 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14471455 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1462,6 +1470,8 @@ test "@shlWithOverflow" {
14621470}
14631471
14641472test "alignment of vectors" {
1473 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1474
14651475 try expect(@alignOf(@Vector(2, u8)) == switch (builtin.zig_backend) {
14661476 else => 2,
14671477 .stage2_c, .stage2_wasm => @alignOf(u8),
......@@ -1487,7 +1497,7 @@ test "alignment of vectors" {
14871497test "loading the second vector from a slice of vectors" {
14881498 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14891499 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1490 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1500 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
14911501
14921502 @setRuntimeSafety(false);
14931503 var small_bases = [2]@Vector(2, u8){
......@@ -1503,7 +1513,7 @@ test "array of vectors is copied" {
15031513 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15041514 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15051515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1506 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1516 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15071517
15081518 const Vec3 = @Vector(3, i32);
15091519 var points = [_]Vec3{
......@@ -1567,7 +1577,7 @@ test "zero multiplicand" {
15671577 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15681578 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
15691579 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1570 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1580 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
15711581
15721582 const zeros = @Vector(2, u32){ 0.0, 0.0 };
15731583 var ones = @Vector(2, u32){ 1.0, 1.0 };
......@@ -1610,7 +1620,7 @@ test "modRem with zero divisor" {
16101620}
16111621
16121622test "array operands to shuffle are coerced to vectors" {
1613 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1623 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16141624 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16151625 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16161626 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1625,6 +1635,7 @@ test "array operands to shuffle are coerced to vectors" {
16251635}
16261636
16271637test "load packed vector element" {
1638 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
16281639 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16291640 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16301641 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1636,7 +1647,7 @@ test "load packed vector element" {
16361647}
16371648
16381649test "store packed vector element" {
1639 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1650 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16401651 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16411652 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16421653 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1653,7 +1664,7 @@ test "store to vector in slice" {
16531664 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16541665 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16551666 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1656 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1667 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
16571668
16581669 var v = [_]@Vector(3, f32){
16591670 .{ 1, 1, 1 },
......@@ -1670,7 +1681,7 @@ test "store vector with memset" {
16701681 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16711682 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16721683 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1673 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1684 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest; // TODO
16741685 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
16751686
16761687 var a: [5]@Vector(2, i1) = undefined;
......@@ -1697,7 +1708,7 @@ test "store vector with memset" {
16971708}
16981709
16991710test "addition of vectors represented as strings" {
1700 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1711 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17011712 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17021713 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17031714
......@@ -1708,7 +1719,7 @@ test "addition of vectors represented as strings" {
17081719}
17091720
17101721test "compare vectors with different element types" {
1711 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1722 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17121723 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17131724 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17141725 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1721,6 +1732,7 @@ test "compare vectors with different element types" {
17211732}
17221733
17231734test "vector pointer is indexable" {
1735 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
17241736 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17251737 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17261738
......@@ -1758,7 +1770,7 @@ test "bitcast to vector with different child type" {
17581770 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17591771 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17601772 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1761 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1773 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
17621774
17631775 const S = struct {
17641776 fn doTheTest() !void {
......@@ -1810,7 +1822,7 @@ test "@reduce on bool vector" {
18101822test "bitcast vector to array of smaller vectors" {
18111823 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
18121824 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1813 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1825 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
18141826
18151827 const u8x32 = @Vector(32, u8);
18161828 const u8x64 = @Vector(64, u8);
test/behavior/void.zig+1-1
......@@ -21,7 +21,7 @@ test "compare void with void compile time known" {
2121test "iterate over a void slice" {
2222 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2323 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
24 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
2525
2626 var j: usize = 0;
2727 for (times(10), 0..) |_, i| {
test/behavior/while.zig+18-6
......@@ -4,6 +4,7 @@ const expect = std.testing.expect;
44const assert = std.debug.assert;
55
66test "while loop" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
89
910 var i: i32 = 0;
......@@ -50,6 +51,8 @@ test "while with continue expression" {
5051}
5152
5253test "while with else" {
54 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
55
5356 var sum: i32 = 0;
5457 var i: i32 = 0;
5558 var got_else: i32 = 0;
......@@ -104,6 +107,7 @@ fn testBreakOuter() void {
104107}
105108
106109test "while copies its payload" {
110 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
107111 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
108112 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
109113
......@@ -122,7 +126,7 @@ test "while copies its payload" {
122126}
123127
124128test "continue and break" {
125 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
129 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
126130
127131 try runContinueAndBreakTest();
128132 try expect(continue_and_break_counter == 8);
......@@ -142,7 +146,7 @@ fn runContinueAndBreakTest() !void {
142146}
143147
144148test "while with optional as condition" {
145 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
149 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
146150 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
147151 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
148152 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -156,7 +160,7 @@ test "while with optional as condition" {
156160}
157161
158162test "while with optional as condition with else" {
159 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
163 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
160164 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161165 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162166 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -175,7 +179,7 @@ test "while with optional as condition with else" {
175179}
176180
177181test "while with error union condition" {
178 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
182 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
179183 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
180184 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
181185
......@@ -207,6 +211,7 @@ test "while on bool with else result follow break prong" {
207211}
208212
209213test "while on optional with else result follow else prong" {
214 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
210215 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
211216 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
212217
......@@ -217,6 +222,7 @@ test "while on optional with else result follow else prong" {
217222}
218223
219224test "while on optional with else result follow break prong" {
225 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
220226 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221227 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222228
......@@ -255,6 +261,7 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
255261}
256262
257263test "while on error union with else result follow else prong" {
264 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
258265 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
259266
260267 const result = while (returnError()) |value| {
......@@ -264,6 +271,7 @@ test "while on error union with else result follow else prong" {
264271}
265272
266273test "while on error union with else result follow break prong" {
274 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
267275 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
268276
269277 const result = while (returnSuccess(10)) |value| {
......@@ -288,6 +296,7 @@ test "while bool 2 break statements and an else" {
288296}
289297
290298test "while optional 2 break statements and an else" {
299 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
291300 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
292301 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
293302
......@@ -306,6 +315,7 @@ test "while optional 2 break statements and an else" {
306315}
307316
308317test "while error 2 break statements and an else" {
318 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
309319 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
310320 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
311321
......@@ -344,7 +354,7 @@ test "else continue outer while" {
344354
345355test "try terminating an infinite loop" {
346356 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
347 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
357 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
348358
349359 // Test coverage for https://github.com/ziglang/zig/issues/13546
350360 const Foo = struct {
......@@ -370,6 +380,7 @@ test "while loop with comptime true condition needs no else block to return valu
370380}
371381
372382test "int returned from switch in while" {
383 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
373384 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
374385
375386 var x: u32 = 3;
......@@ -381,6 +392,7 @@ test "int returned from switch in while" {
381392}
382393
383394test "breaking from a loop in an if statement" {
395 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
384396 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
385397 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
386398
......@@ -402,7 +414,7 @@ test "breaking from a loop in an if statement" {
402414}
403415
404416test "labeled break from else" {
405 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
417 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
406418
407419 const S = struct {
408420 fn doTheTest(x: u32) !void {
test/behavior/widening.zig+5-4
......@@ -4,6 +4,7 @@ const mem = std.mem;
44const builtin = @import("builtin");
55
66test "integer widening" {
7 if (builtin.cpu.arch.isSpirv() and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
78 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
......@@ -28,7 +29,7 @@ test "integer widening u0 to u8" {
2829
2930test "implicit unsigned integer to signed integer" {
3031 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
3233
3334 var a: u8 = 250;
3435 var b: i16 = a;
......@@ -39,7 +40,7 @@ test "implicit unsigned integer to signed integer" {
3940test "float widening" {
4041 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4142 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
43 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
4344 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
4445
4546 var a: f16 = 12.34;
......@@ -58,7 +59,7 @@ test "float widening" {
5859test "float widening f16 to f128" {
5960 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6061 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
61 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
62 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
6263 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6364
6465 var x: f16 = 12.34;
......@@ -70,7 +71,7 @@ test "float widening f16 to f128" {
7071test "cast small unsigned to larger signed" {
7172 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7273 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
74 if (builtin.cpu.arch.isSpirv()) return error.SkipZigTest;
7475
7576 try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
7677 try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));
test/cases/compile_errors/spirv_slices.zig+2-4
......@@ -19,7 +19,5 @@ export fn b() void {
1919// target=spirv32-opengl,spirv32-vulkan
2020// cpu_features=baseline+variable_pointers
2121//
22// :3:16: error: cannot construct slice from address space 'generic'
23// :3:16: note: only 'shared' and 'storage_buffer' address spaces support slicing on SPIR-V
24// :14:11: error: cannot construct slice from address space 'generic'
25// :14:11: note: only 'shared' and 'storage_buffer' address spaces support slicing on SPIR-V
22// :3:16: error: cannot construct slice from logical address space 'generic'
23// :14:11: error: cannot construct slice from logical address space 'generic'
test/cases/spirv_mergable_pointers.zig+3-3
......@@ -1,7 +1,7 @@
11export fn a() void {
2 var x: *addrspace(.global) i32 = undefined;
2 var x: *addrspace(.physical_storage_buffer) i32 = undefined;
33 _ = &x;
4 var y: *addrspace(.global) i32 = undefined;
4 var y: *addrspace(.physical_storage_buffer) i32 = undefined;
55 _ = &y;
66 var rt_cond = false;
77 _ = &rt_cond;
......@@ -13,5 +13,5 @@ export fn a() void {
1313// compile
1414// output_mode=Obj
1515// backend=selfhosted
16// target=spirv32-vulkan
16// target=spirv64-vulkan
1717// emit_bin=true
test/src/Cases.zig+1-1
......@@ -465,7 +465,7 @@ pub fn lowerToBuildSteps(
465465 if (options.skip_non_native and !std.zig.target.isNative(&case.target.query, &case.target.result, &b.graph.host.result))
466466 continue;
467467
468 if (options.skip_spirv and case.target.query.cpu_arch != null and case.target.query.cpu_arch.?.isSpirV()) continue;
468 if (options.skip_spirv and case.target.query.cpu_arch != null and case.target.query.cpu_arch.?.isSpirv()) continue;
469469 if (options.skip_wasm and case.target.query.cpu_arch != null and case.target.query.cpu_arch.?.isWasm()) continue;
470470
471471 if (options.skip_freebsd and case.target.query.os_tag == .freebsd) continue;
test/tests.zig+1-1
......@@ -2568,7 +2568,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
25682568 if (test_target.link_libc == null and !std.os.targetRequiresLibC(target)) continue;
25692569 }
25702570
2571 if (options.skip_spirv and target.cpu.arch.isSpirV()) continue;
2571 if (options.skip_spirv and target.cpu.arch.isSpirv()) continue;
25722572 if (options.skip_wasm and target.cpu.arch.isWasm()) continue;
25732573
25742574 if (options.skip_freebsd and target.os.tag == .freebsd) continue;
tools/gen_spirv_spec.zig+1
......@@ -15,6 +15,7 @@ const allowed_vendors = [_][]const u8{ "KHR", "EXT" };
1515const set_names = std.StaticStringMap(struct { []const u8, []const u8 }).initComptime(.{
1616 .{ "opencl.std.100", .{ "OpenCL.std", "OpenClOpcode" } },
1717 .{ "glsl.std.450", .{ "GLSL.std.450", "GlslOpcode" } },
18 .{ "nonsemantic.shader.debuginfo.100", .{ "NonSemantic.Shader.DebugInfo.100", "ShaderDebugInfoOpCode" } },
1819});
1920
2021const Extension = struct {